offline: Prefer user-supplied param to browser-supplied cookie in the authen proxy
[working/Evergreen.git] / Open-ILS / src / perlmods / lib / OpenILS / WWW / Proxy / Authen.pm
1 package OpenILS::WWW::Proxy::Authen;
2 use strict; use warnings;
3
4 use Apache2::Access;
5 use Apache2::RequestUtil;
6 use Apache2::Log;
7 use Apache2::Const -compile => qw(OK HTTP_UNAUTHORIZED DECLINED HTTP_MOVED_TEMPORARILY NOT_FOUND :log);
8 use APR::Const    -compile => qw(:error SUCCESS);
9 use CGI;
10 use Data::Dumper;
11 use Digest::MD5 qw/md5_hex/;
12
13 use OpenSRF::EX qw(:try);
14 use OpenSRF::System;
15
16 # set the bootstrap config when 
17 # this module is loaded
18 my $bootstrap;
19 my $ssl_off;
20
21 sub import {
22     my $self = shift;
23     $bootstrap = shift;
24     $ssl_off = shift;
25 }
26
27
28 sub child_init {
29     OpenSRF::System->bootstrap_client( config_file => $bootstrap );
30     return Apache2::Const::OK;
31 }
32
33 sub handler {
34     my $apache = shift;
35
36     my $ltype = $apache->dir_config('OILSProxyLoginType');
37     my $perms = [ split ' ', $apache->dir_config('OILSProxyPermissions') ];
38
39     return Apache2::Const::NOT_FOUND unless (@$perms);
40
41     my $cgi = new CGI;
42     my $auth_ses = $cgi->param('ses') || $cgi->cookie('ses');
43     my $ws_ou = $apache->dir_config('OILSProxyLoginOU') || $cgi->param('ws_ou') || $cgi->cookie('ws_ou');
44
45     my $url = $cgi->url;
46     my $bad_auth = 1; # Assume failure until proven otherwise ;)
47
48     # push everyone to the secure site
49     if (!$ssl_off && $url =~ /^http:/o) {
50         my $base = $cgi->url(-base=>1);
51         $base =~ s/^http:/https:/o;
52         $apache->headers_out->set(Location => $base . $apache->unparsed_uri);
53         return Apache2::Const::HTTP_MOVED_TEMPORARILY;
54     }
55
56     my $tried_login = 0;
57     my $cookie;
58
59     while ($bad_auth && $tried_login == 0) {
60         if (!$auth_ses) {
61             $tried_login = 1;
62             my ($status, $p) = $apache->get_basic_auth_pw;
63             my $u;
64             if ($status == Apache2::Const::OK) {
65                 $u = $apache->user;
66             } else {
67                 $u = $cgi->param('user');
68                 $p = $cgi->param('passwd');
69                 return $status if (!$u);
70             }
71     
72             if ($u) {
73                 $auth_ses = oils_login($u, $p, $ltype);
74                 if ($auth_ses) {
75                     $cookie = $cgi->cookie(
76                         -name=>'ses',
77                         -value=>$auth_ses,
78                         -path=>'/',
79                         -secure=>1
80                     );
81                 }
82             }
83         }
84     
85         my $user = verify_login($auth_ses);
86     
87         if ($user) {
88             $ws_ou ||= $user->home_ou;
89     
90             warn "Checking perms " . join(',', @$perms) . " for user " . $user->id . " at location $ws_ou\n";
91     
92             my $failures = OpenSRF::AppSession
93                 ->create('open-ils.actor')
94                 ->request('open-ils.actor.user.perm.check', $auth_ses, $user->id, $ws_ou, $perms)
95                 ->gather(1);
96     
97             if (@$failures > 0) {
98                 $cookie = $cgi->cookie(
99                         -name=>'ses',
100                         -value=>'',
101                         -path=>'/',
102                         -expires=>'-1h'
103                 );
104             } else {
105                 # it appears that as of Apache 2.4, authentication
106                 # handlers are expected to ensure that the request
107                 # object has ->user set.
108                 $apache->user($user->usrname);
109                 $bad_auth = 0;
110             }
111         }
112
113         $auth_ses = undef if($bad_auth && !$tried_login);
114     }
115
116     if ($bad_auth) {
117         $apache->err_headers_out->add('Set-Cookie' => $cookie) if($cookie);
118         $apache->note_basic_auth_failure;
119         return Apache2::Const::HTTP_UNAUTHORIZED;
120     }
121
122     if ($tried_login) {
123         # We authenticated, and thus likely got a new auth key.
124         # Set it and redirect in case what we are protecting needs the key.
125
126         # When not redirecting we don't need the err_ variant of this. Noting for reference.
127         $apache->err_headers_out->add('Set-Cookie' => $cookie) if($cookie);
128         my $base = $cgi->url(-base=>1);
129         $apache->headers_out->set(Location => $base . $apache->unparsed_uri);
130         return Apache2::Const::HTTP_MOVED_TEMPORARILY;
131     }
132
133     # they're good, let 'em through
134     return Apache2::Const::OK;
135 }
136
137 # returns the user object if the session is valid, 0 otherwise
138 sub verify_login {
139     my $auth_token = shift;
140     return undef unless $auth_token;
141
142     my $user = OpenSRF::AppSession
143         ->create("open-ils.auth")
144         ->request( "open-ils.auth.session.retrieve", $auth_token )
145         ->gather(1);
146
147     if (ref($user) eq 'HASH' && $user->{ilsevent} == 1001) {
148         return undef;
149     }
150
151     return $user if ref($user);
152     return undef;
153 }
154
155 sub oils_login {
156         my( $username, $password, $type ) = @_;
157
158         $type |= "staff";
159     my $nametype = 'username';
160     $nametype = 'barcode' if ($username =~ /^\d+$/o);
161
162         my $seed = OpenSRF::AppSession
163         ->create("open-ils.auth")
164         ->request( 'open-ils.auth.authenticate.init', $username )
165         ->gather(1);
166
167         return undef unless $seed;
168
169         my $response = OpenSRF::AppSession
170         ->create("open-ils.auth")
171         ->request( 'open-ils.auth.authenticate.complete',
172             { $nametype => $username, agent => 'authproxy',
173               password => md5_hex($seed . md5_hex($password)),
174               type => $type })
175         ->gather(1);
176
177         return undef unless $response;
178
179         return $response->{payload}->{authtoken};
180 }
181
182 1;
183