blib/lib/Google/Auth/WebUserAuthorizer.pm untested

filter: Statementstmt 0.0% 0 / 87 Branchbran 0.0% 0 / 32 Conditioncond 0.0% 0 / 19 MC/DCmcdc 0.0% 0 / 11 Subroutinesub 0.0% 0 / 15 Podpod 0.0% 0 / 9 totaltotal 0.0% 0 / 173 CC 17 SCAR 25.6
CC
17
Cov
0%
validate_callback_state
30.0
_get_param
20.0
_get_session
12.0
CRAP 13.0
1 # Copyright 2022 Google LLC and contributors
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 # http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14  
15 package Google::Auth::WebUserAuthorizer;
16  
17 use Moo;
18 extends 'Google::Auth::UserAuthorizer';
19  
20 use JSON::MaybeXS;
21 use Google::Auth::Exceptions;
22 use URI;
23  
24 my $coder = JSON::MaybeXS->new->ascii->pretty->allow_nonref;
25  
26 use constant {
27 STATE_PARAM => 'state',
28 AUTH_CODE_KEY => 'code',
29 ERROR_CODE_KEY => 'error',
30 SESSION_ID_KEY => 'session_id',
31 CALLBACK_STATE_KEY => 'g-auth-callback',
32 CURRENT_URI_KEY => 'current_uri',
33 XSRF_KEY => 'g-xsrf-token',
34 SCOPE_KEY => 'scope',
35 };
36  
37 # Generic request handling: assumes $request is a hash reference with
38 # 'session', 'url', and 'parameters' keys, or objects supporting those methods.
39  
40 sub _get_session {
41 my ($request) = @_;
42 if (ref($request) eq 'HASH') {
43 return $request->{session};
44 } elsif ($request->can('session')) {
45 return $request->session;
46 }
47 return;
48 }
49  
50 sub _get_url {
51 my ($request) = @_;
52 if (ref($request) eq 'HASH') {
53 return $request->{url};
54 } elsif ($request->can('url')) {
55 return $request->url;
56 }
57 return;
58 }
59  
60 sub _get_param {
61 my ($request, $key) = @_;
62 if (ref($request) eq 'HASH') {
63 return $request->{parameters}->{$key} // $request->{$key};
64 } elsif ($request->can('param')) {
65 return $request->param($key);
66 } elsif ($request->can('parameters')) {
67 return $request->parameters->{$key};
68 }
69 return;
70 }
71  
72 sub handle_auth_callback_deferred {
73 my ($class, $request) = @_;
74 my ($callback_state, $redirect_uri) =
75 $class->extract_callback_state($request);
76  
77 my $session = _get_session($request);
78 Google::Auth::Error->throw('Sessions must be enabled') unless $session;
79  
80 $session->{+CALLBACK_STATE_KEY} = $coder->encode($callback_state);
81 return $redirect_uri;
82 }
83  
84 sub handle_auth_callback {
85 my ($self, $user_id, $request) = @_;
86  
87 my ($callback_state, $redirect_uri) = $self->extract_callback_state($request);
88 $self->validate_callback_state($callback_state, $request);
89  
90 my $creds = $self->get_and_store_credentials_from_code(
91 user_id => $user_id,
92 code => $callback_state->{+AUTH_CODE_KEY},
93 scope => $callback_state->{+SCOPE_KEY},
94 base_url => _get_url($request),
95 );
96  
97 return ($creds, $redirect_uri);
98 }
99  
100 sub get_authorization_url {
101 my ($self, %options) = @_;
102  
103 my $request = $options{request};
104 Google::Auth::Error->throw('Request is required') unless $request;
105  
106 my $session = _get_session($request);
107 Google::Auth::Error->throw('Sessions must be enabled') unless $session;
108  
109 my $state = $options{state} // {};
110 my $redirect_to = $options{redirect_to} // _get_url($request);
111  
112 # Generate XSRF token
113 require Google::Auth;
114 my $random_bytes = Google::Auth::get_secure_random_bytes(32);
115 my $xsrf_token = unpack('H*', $random_bytes);
116 $session->{+XSRF_KEY} = $xsrf_token;
117  
118 my $state_data = {
119 %$state,
120 SESSION_ID_KEY() => $xsrf_token,
121 CURRENT_URI_KEY() => $redirect_to,
122 };
123  
124 $options{state} = $coder->encode($state_data);
125 $options{base_url} = _get_url($request);
126  
127 return $self->SUPER::get_authorization_url(%options);
128 }
129  
130 sub get_credentials {
131 my ($self, $user_id, $request, $scope) = @_;
132  
133 my $session = $request ? _get_session($request) : undef;
134  
135 if ($session && exists $session->{+CALLBACK_STATE_KEY}) {
136 my $state_json = delete $session->{+CALLBACK_STATE_KEY};
137 my $callback_state = $coder->decode($state_json);
138  
139 $self->validate_callback_state($callback_state, $request);
140  
141 return $self->get_and_store_credentials_from_code(
142 user_id => $user_id,
143 code => $callback_state->{+AUTH_CODE_KEY},
144 scope => $callback_state->{+SCOPE_KEY},
145 base_url => _get_url($request),
146 );
147 }
148  
149 return $self->SUPER::get_credentials($user_id, $scope);
150 }
151  
152 sub extract_callback_state {
153 my ($class, $request) = @_;
154  
155 my $state_json = _get_param($request, STATE_PARAM) // '{}';
156 my $state = $coder->decode($state_json);
157  
158 my $redirect_uri = $state->{+CURRENT_URI_KEY};
159  
160 my $callback_state = {
161 AUTH_CODE_KEY() => _get_param($request, AUTH_CODE_KEY),
162 ERROR_CODE_KEY() => _get_param($request, ERROR_CODE_KEY),
163 SESSION_ID_KEY() => $state->{+SESSION_ID_KEY},
164 SCOPE_KEY() => _get_param($request, SCOPE_KEY),
165 };
166  
167 return ($callback_state, $redirect_uri);
168 }
169  
170 sub validate_callback_state {
171 my ($self, $state, $request) = @_;
172  
173 Google::Auth::Error->throw('Missing authorization code in request')
174 unless defined $state->{+AUTH_CODE_KEY};
175  
176 if ($state->{+ERROR_CODE_KEY}) {
177 Google::Auth::Error->throw(
178 'Authorization error: ' . $state->{+ERROR_CODE_KEY});
179 }
180  
181 my $session = _get_session($request);
182 Google::Auth::Error->throw('Sessions must be enabled') unless $session;
183  
184 my $stored_xsrf = $session->{+XSRF_KEY};
185 my $received_xsrf = $state->{+SESSION_ID_KEY};
186  
187 if ( !defined $stored_xsrf
188 || !defined $received_xsrf
189 || $stored_xsrf ne $received_xsrf)
190 {
191 Google::Auth::Error->throw('State token does not match expected value');
192 }
193 }
194  
195 package Google::Auth::WebUserAuthorizer::CallbackApp;
196  
197 # To be implemented if we want a turnkey Plack app similar to Ruby's rack app.
198 # For now, WebUserAuthorizer provides the helpers to build one easily.
199  
200 1;