C4/InstallAuth.pm

   1 package C4::InstallAuth;
   2
   3 # Copyright 2000-2002 Katipo Communications
   4 #
   5 # This file is part of Koha.
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 use strict;
  21 #use warnings; FIXME - Bug 2505
  22 use Digest::MD5 qw(md5_base64);
  23 use CGI::Session;
  24 use File::Spec;
  25
  26 require Exporter;
  27
  28 use C4::Context;
  29 use C4::Output;
  30 use C4::Templates;
  31 use C4::Koha;
  32
  33 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
  34
  35
  36 =head1 NAME
  37
  38 InstallAuth - Authenticates Koha users for Install process
  39
  40 =head1 SYNOPSIS
  41
  42   use CGI qw ( -utf8 );
  43   use InstallAuth;
  44   use C4::Output;
  45
  46   my $query = new CGI;
  47
  48     my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
  49         {   template_name   => "opac-main.tt",
  50             query           => $query,
  51             type            => "opac",
  52             authnotrequired => 1,
  53             flagsrequired   => { acquisition => '*' },
  54         }
  55     );
  56
  57   output_html_with_http_headers $query, $cookie, $template->output;
  58
  59 =head1 DESCRIPTION
  60
  61     The main function of this module is to provide
  62     authentification. However the get_template_and_user function has
  63     been provided so that a users login information is passed along
  64     automatically. This gets loaded into the template.
  65     This package is different from C4::Auth in so far as
  66     C4::Auth uses many preferences which are supposed NOT to be obtainable when installing the database.
  67
  68     As in C4::Auth, Authentication is based on cookies.
  69
  70 =head1 FUNCTIONS
  71
  72 =over 2
  73
  74 =cut
  75
  76 @ISA    = qw(Exporter);
  77 @EXPORT = qw(
  78   &checkauth
  79   &get_template_and_user
  80 );
  81
  82 =item get_template_and_user
  83
  84     my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
  85         {   template_name   => "opac-main.tt",
  86             query           => $query,
  87             type            => "opac",
  88             authnotrequired => 1,
  89             flagsrequired   => { acquisition => '*' },
  90         }
  91     );
  92
  93     This call passes the C<query>, C<flagsrequired> and C<authnotrequired>
  94     to C<&checkauth> (in this module) to perform authentification.
  95     See C<&checkauth> for an explanation of these parameters.
  96
  97     The C<template_name> is then used to find the correct template for
  98     the page. The authenticated users details are loaded onto the
  99     template in the logged_in_user variable (which is a Koha::Patron object). Also the
 100     C<sessionID> is passed to the template. This can be used in templates
 101     if cookies are disabled. It needs to be put as and input to every
 102     authenticated page.
 103
 104     More information on the C<gettemplate> sub can be found in the
 105     Templates.pm module.
 106
 107 =cut
 108
 109 sub get_template_and_user {
 110     my $in       = shift;
 111     my $query    = $in->{'query'};
 112     my $language =_get_template_language($query->cookie('KohaOpacLanguage'));
 113     my $path     = C4::Context->config('intrahtdocs'). "/prog/". $language;
 114
 115     my $tmplbase = $in->{template_name};
 116     my $filename = "$path/modules/" . $tmplbase;
 117     my $interface = 'intranet';
 118     my $template = C4::Templates->new( $interface, $filename, $tmplbase, $query);
 119
 120     my ( $user, $cookie, $sessionID, $flags ) = checkauth(
 121         $in->{'query'},
 122         $in->{'authnotrequired'},
 123         $in->{'flagsrequired'},
 124         $in->{'type'}
 125     );
 126
 127     #     use Data::Dumper;warn "utilisateur $user cookie : ".Dumper($cookie);
 128
 129     my $borrowernumber;
 130     if ($user) {
 131         $template->param( loggedinusername => $user );
 132         $template->param( sessionID        => $sessionID );
 133
 134         # We are going to use the $flags returned by checkauth
 135         # to create the template's parameters that will indicate
 136         # which menus the user can access.
 137         if ( ( $flags && $flags->{superlibrarian} == 1 ) ) {
 138             $template->param( CAN_user_circulate        => 1 );
 139             $template->param( CAN_user_catalogue        => 1 );
 140             $template->param( CAN_user_parameters       => 1 );
 141             $template->param( CAN_user_borrowers        => 1 );
 142             $template->param( CAN_user_permission       => 1 );
 143             $template->param( CAN_user_reserveforothers => 1 );
 144             $template->param( CAN_user_editcatalogue    => 1 );
 145             $template->param( CAN_user_updatecharges    => 1 );
 146             $template->param( CAN_user_acquisition      => 1 );
 147             $template->param( CAN_user_tools            => 1 );
 148             $template->param( CAN_user_editauthorities  => 1 );
 149             $template->param( CAN_user_serials          => 1 );
 150             $template->param( CAN_user_reports          => 1 );
 151         }
 152
 153         my $minPasswordLength = C4::Context->preference('minPasswordLength');
 154         $minPasswordLength = 3 if not $minPasswordLength or $minPasswordLength < 3;
 155         $template->param(minPasswordLength => $minPasswordLength,);
 156     }
 157     return ( $template, $borrowernumber, $cookie );
 158 }
 159
 160 sub _get_template_language {
 161
 162     #verify if opac language exists in staff (bug 5660)
 163     #conditions are 1) dir exists and 2) enabled in prefs
 164     my ($opaclang) = @_;
 165     return 'en' unless $opaclang;
 166     $opaclang =~ s/[^a-zA-Z_-]*//g;
 167     my $path = C4::Context->config('intrahtdocs') . "/prog/$opaclang";
 168     -d $path ? $opaclang : 'en';
 169 }
 170
 171 =item checkauth
 172
 173   ($userid, $cookie, $sessionID) = &checkauth($query, $noauth, $flagsrequired, $type);
 174
 175 Verifies that the user is authorized to run this script.  If
 176 the user is authorized, a (userid, cookie, session-id, flags)
 177 quadruple is returned.  If the user is not authorized but does
 178 not have the required privilege (see $flagsrequired below), it
 179 displays an error page and exits.  Otherwise, it displays the
 180 login page and exits.
 181
 182 Note that C<&checkauth> will return if and only if the user
 183 is authorized, so it should be called early on, before any
 184 unfinished operations (e.g., if you've opened a file, then
 185 C<&checkauth> won't close it for you).
 186
 187 C<$query> is the CGI object for the script calling C<&checkauth>.
 188
 189 The C<$noauth> argument is optional. If it is set, then no
 190 authorization is required for the script.
 191
 192 C<&checkauth> fetches user and session information from C<$query> and
 193 ensures that the user is authorized to run scripts that require
 194 authorization.
 195
 196 The C<$flagsrequired> argument specifies the required privileges
 197 the user must have if the username and password are correct.
 198 It should be specified as a reference-to-hash; keys in the hash
 199 should be the "flags" for the user, as specified in the Members
 200 intranet module. Any key specified must correspond to a "flag"
 201 in the userflags table. E.g., { circulate => 1 } would specify
 202 that the user must have the "circulate" privilege in order to
 203 proceed. To make sure that access control is correct, the
 204 C<$flagsrequired> parameter must be specified correctly.
 205
 206 The C<$type> argument specifies whether the template should be
 207 retrieved from the opac or intranet directory tree.  "opac" is
 208 assumed if it is not specified; however, if C<$type> is specified,
 209 "intranet" is assumed if it is not "opac".
 210
 211 If C<$query> does not have a valid session ID associated with it
 212 (i.e., the user has not logged in) or if the session has expired,
 213 C<&checkauth> presents the user with a login page (from the point of
 214 view of the original script, C<&checkauth> does not return). Once the
 215 user has authenticated, C<&checkauth> restarts the original script
 216 (this time, C<&checkauth> returns).
 217
 218 The login page is provided using a HTML::Template, which is set in the
 219 systempreferences table or at the top of this file. The variable C<$type>
 220 selects which template to use, either the opac or the intranet
 221 authentification template.
 222
 223 C<&checkauth> returns a user ID, a cookie, and a session ID. The
 224 cookie should be sent back to the browser; it verifies that the user
 225 has authenticated.
 226
 227 =cut
 228
 229 sub checkauth {
 230     my $query = shift;
 231
 232 # $authnotrequired will be set for scripts which will run without authentication
 233     my $authnotrequired = shift;
 234     my $flagsrequired   = shift;
 235     my $type            = shift;
 236     $type = 'intranet' unless $type;
 237
 238     my $dbh = C4::Context->dbh();
 239     my $template_name;
 240     $template_name = "installer/auth.tt";
 241     my $sessdir = File::Spec->catdir( C4::Context::temporary_directory, 'cgisess_' . C4::Context->config('database') ); # same construction as in C4/Auth
 242
 243     # state variables
 244     my $loggedin = 0;
 245     my %info;
 246     my ( $userid, $cookie, $sessionID, $flags, $envcookie );
 247     my $logout = $query->param('logout.x');
 248     if ( $sessionID = $query->cookie("CGISESSID") ) {
 249         C4::Context->_new_userenv($sessionID);
 250         my $session =
 251           new CGI::Session( "driver:File;serializer:yaml", $sessionID,
 252             { Directory => $sessdir } );
 253         if ( $session->param('cardnumber') ) {
 254             C4::Context->set_userenv(
 255                 $session->param('number'),
 256                 $session->param('id'),
 257                 $session->param('cardnumber'),
 258                 $session->param('firstname'),
 259                 $session->param('surname'),
 260                 $session->param('branch'),
 261                 $session->param('branchname'),
 262                 $session->param('flags'),
 263                 $session->param('emailaddress'),
 264                 $session->param('branchprinter')
 265             );
 266             $cookie = $query->cookie(
 267                 -name     => 'CGISESSID',
 268                 -value    => $session->id,
 269                 -HttpOnly => 1,
 270                 -secure => ( C4::Context->https_enabled() ? 1 : 0 ),
 271             );
 272             $loggedin = 1;
 273             $userid   = $session->param('cardnumber');
 274         }
 275         my ( $ip, $lasttime );
 276
 277         if ($logout) {
 278
 279             # voluntary logout the user
 280             C4::Context->_unset_userenv($sessionID);
 281             $sessionID = undef;
 282             $userid    = undef;
 283            # Commented out due to its lack of usefulness
 284            # open L, ">>/tmp/sessionlog";
 285            # my $time = localtime( time() );
 286            # printf L "%20s from %16s logged out at %30s (manually).\n", $userid,
 287            #   $ip, $time;
 288            # close L;
 289         }
 290     }
 291     unless ($userid) {
 292         my $session =
 293           new CGI::Session( "driver:File;serializer:yaml", undef, { Directory => $sessdir } );
 294         $sessionID = $session->id;
 295         $userid    = $query->param('userid');
 296         C4::Context->_new_userenv($sessionID);
 297         my $password = $query->param('password');
 298         C4::Context->_new_userenv($sessionID);
 299         my ( $return, $cardnumber ) = checkpw( $userid, $password );
 300         if ($return) {
 301             $loggedin = 1;
 302             # open L, ">>/tmp/sessionlog";
 303             # my $time = localtime( time() );
 304             # printf L "%20s from %16s logged in  at %30s.\n", $userid,
 305             #  $ENV{'REMOTE_ADDR'}, $time;
 306             # close L;
 307             $cookie = $query->cookie(
 308                 -name     => 'CGISESSID',
 309                 -value    => $sessionID,
 310                 -HttpOnly => 1,
 311                 -secure => ( C4::Context->https_enabled() ? 1 : 0 ),
 312             );
 313             if ( $return == 2 ) {
 314
 315            #Only superlibrarian should have access to this page.
 316            #Since if it is a user, it is supposed that there is a borrower table
 317            #And thus that data structure is loaded.
 318                 my $hash = C4::Context->set_userenv(
 319                     0,                           0,
 320                     C4::Context->config('user'), C4::Context->config('user'),
 321                     C4::Context->config('user'), "",
 322                     "NO_LIBRARY_SET",            1,
 323                     ""
 324                 );
 325                 $session->param( 'number',     0 );
 326                 $session->param( 'id',         C4::Context->config('user') );
 327                 $session->param( 'cardnumber', C4::Context->config('user') );
 328                 $session->param( 'firstname',  C4::Context->config('user') );
 329                 $session->param( 'surname',    C4::Context->config('user'), );
 330                 $session->param( 'branch',     'NO_LIBRARY_SET' );
 331                 $session->param( 'branchname', 'NO_LIBRARY_SET' );
 332                 $session->param( 'flags',      1 );
 333                 $session->param( 'emailaddress',
 334                     C4::Context->preference('KohaAdminEmailAddress') );
 335                 $session->param( 'ip',       $session->remote_addr() );
 336                 $session->param( 'lasttime', time() );
 337                 $userid = C4::Context->config('user');
 338             }
 339         }
 340         else {
 341             if ($userid) {
 342                 $info{'invalid_username_or_password'} = 1;
 343                 C4::Context->_unset_userenv($sessionID);
 344             }
 345         }
 346     }
 347
 348     # finished authentification, now respond
 349     if ($loggedin) {
 350
 351         # successful login
 352         unless ($cookie) {
 353             $cookie = $query->cookie(
 354                 -name    => 'CGISESSID',
 355                 -value   => '',
 356                 -HttpOnly => 1,
 357                 -expires => '',
 358                 -secure => ( C4::Context->https_enabled() ? 1 : 0 ),
 359             );
 360         }
 361         if ($envcookie) {
 362             return ( $userid, [ $cookie, $envcookie ], $sessionID, $flags );
 363         }
 364         else {
 365             return ( $userid, $cookie, $sessionID, $flags );
 366         }
 367     }
 368
 369     # else we have a problem...
 370     # get the inputs from the incoming query
 371     my @inputs = ();
 372     foreach my $name ( param $query) {
 373         (next) if ( $name eq 'userid' || $name eq 'password' );
 374         my $value = $query->param($name);
 375         push @inputs, { name => $name, value => $value };
 376     }
 377
 378     my $path =
 379       C4::Context->config('intrahtdocs') . "/prog/"
 380       . ( $query->param('language') ? $query->param('language') : "en" );
 381     my $filename = "$path/modules/$template_name";
 382     my $interface = 'intranet';
 383     my $template = C4::Templates->new( $interface, $filename, '', $query);
 384     $template->param(
 385         INPUTS => \@inputs,
 386
 387     );
 388     $template->param( login => 1 );
 389     $template->param( loginprompt => 1 ) unless $info{'nopermission'};
 390
 391     if ($info{'invalid_username_or_password'} && $info{'invalid_username_or_password'} == 1) {
 392                 $template->param( 'invalid_username_or_password' => $info{'invalid_username_or_password'});
 393     }
 394
 395     $template->param( \%info );
 396     $cookie = $query->cookie(
 397         -name    => 'CGISESSID',
 398         -value   => $sessionID,
 399         -HttpOnly => 1,
 400         -expires => '',
 401         -secure => ( C4::Context->https_enabled() ? 1 : 0 ),
 402     );
 403     print $query->header(
 404         -type    => 'text/html; charset=utf-8',
 405         -cookie  => $cookie
 406       ),
 407       $template->output;
 408     exit;
 409 }
 410
 411 sub checkpw {
 412
 413     my ( $userid, $password ) = @_;
 414
 415     if (   $userid
 416         && $userid     eq C4::Context->config('user')
 417         && "$password" eq C4::Context->config('pass') )
 418     {
 419
 420         # Koha superuser account
 421         C4::Context->set_userenv(
 422             0, 0,
 423             C4::Context->config('user'),
 424             C4::Context->config('user'),
 425             C4::Context->config('user'),
 426             "", "NO_LIBRARY_SET", 1
 427         );
 428         return 2;
 429     }
 430     return 0;
 431 }
 432
 433 END { }    # module clean-up code here (global destructor)
 434 1;
 435 __END__
 436
 437 =back
 438
 439 =head1 SEE ALSO
 440
 441 CGI(3)
 442
 443 C4::Output(3)
 444
 445 Digest::MD5(3)
 446
 447 =cut