Crypto.pm untested

filter: Statementstmt 0.0% 0 / 245 Branchbran 0.0% 0 / 92 Conditioncond 0.0% 0 / 15 MC/DCmcdc 0.0% 0 / 9 Subroutinesub 0.0% 0 / 19 Podpod 0.0% 0 / 18 totaltotal 0.0% 0 / 398 CC 47 SCAR 35.5
CC
47
Cov
0%
addToken
90.0
new
56.0
getToken
42.0
CRAP 34.6
1 ## OpenCA::Crypto.pm
2 ##
3 ## Written by Michael Bell for the OpenCA project 2003
4 ## Copyright (C) 2003-2004 The OpenCA Project
5 ## All rights reserved.
6 ##
7 ## This library is free software; you can redistribute it and/or
8 ## modify it under the terms of the GNU Lesser General Public
9 ## License as published by the Free Software Foundation; either
10 ## version 2.1 of the License, or (at your option) any later version.
11 ##
12 ## This library is distributed in the hope that it will be useful,
13 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 ## Lesser General Public License for more details.
16 ##
17 ## You should have received a copy of the GNU Lesser General Public
18 ## License along with this library; if not, write to the Free Software
19 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 ##
21  
22 use strict;
23  
24 package OpenCA::Crypto;
25  
26 our ($errno, $errval);
27 our $AUTOLOAD;
28  
29 ($OpenCA::Crypto::VERSION = '$Revision: 1.1.1.1 $' )=~ s/(?:^.*: (\d+))|(?:\s+\$$)/defined $1?"0\.9":""/eg;
30  
31 # Preloaded methods go here.
32  
33 ## Create an instance of the Class
34 sub new {
35 my $that = shift;
36 my $class = ref($that) || $that;
37  
38 my $self = {
39 DEBUG => 0,
40 };
41  
42 bless $self, $class;
43  
44 my $keys = { @_ };
45 $self->{configfile} = $keys->{CONFIG};
46 $self->{DEBUG} = 1 if ($keys->{DEBUG});
47 $self->{DEFAULT_TOKEN} = $keys->{DEFAULT_TOKEN} if ($keys->{DEFAULT_TOKEN});
48 $self->{cache} = $keys->{CACHE};
49 $self->{gettext} = $keys->{GETTEXT};
50  
51 ## set default token
52 $self->{DEFAULT_TOKEN} = $self->{cache}->get_xpath (
53 FILENAME => $self->{configfile},
54 XPATH => [ 'token_config/default_token' ],
55 COUNTER => [ 0 ])
56 if ($self->{configfile});
57  
58 $self->debug ("new: configfile: $self->{configfile}");
59 $self->debug ("new: DEFAULT_TOKEN: $self->{DEFAULT_TOKEN}");
60  
61 ## this default token overrides the configuration
62 if ($self->{DEFAULT_TOKEN})
63 {
64 if ($self->{configfile})
65 {
66 return undef if (not $self->addToken ($self->{DEFAULT_TOKEN}));
67 } else {
68 return $self->setError (7110010,
69 $self->{gettext} ("There was token specified but there is no configurationfile."));
70 }
71 }
72  
73 $self->debug ("new: crypto layer is ready");
74 return $self;
75 }
76  
77 sub setError {
78 my $self = shift;
79  
80 if (scalar (@_) == 4) {
81 my $keys = { @_ };
82 $self->{errval} = $keys->{ERRVAL};
83 $self->{errno} = $keys->{ERRNO};
84 } else {
85 $self->{errno} = $_[0];
86 $self->{errval} = $_[1];
87 }
88  
89 $errno = $self->{errno};
90 $errval = $self->{errval};
91  
92 $self->debug ("setError: errno: $self->{errno}");
93 $self->debug ("setError: errval: $self->{errval}");
94  
95 ## support for: return $self->setError (1234, "Something fails.") if (not $xyz);
96 return undef;
97 }
98  
99 sub errno {
100 my $self = shift;
101 return $self->{errno};
102 }
103  
104 sub errval {
105 my $self = shift;
106 return $self->{errval};
107 }
108  
109 sub setConfig {
110  
111 my $self = shift;
112  
113 $self->{configfile} = $_[0];
114 return $self->getConfig;
115  
116 }
117  
118 sub debug {
119  
120 my $self = shift;
121  
122 return 1 if (not $self->{DEBUG});
123  
124 foreach my $msg (@_) {
125 print STDERR "OpenCA::Crypto->$msg\n";
126 }
127  
128 return 1;
129 }
130  
131 ######################################################################
132 ## slot management ##
133 ######################################################################
134  
135 ## implicit use token
136 sub getToken {
137  
138 my $self = shift;
139 $self->debug ("getToken: entering function");
140  
141 my $name = $_[0];
142 if (not $_[0])
143 {
144 if (not $self->{DEFAULT_TOKEN})
145 {
146 return $self->setError (7121010,
147 $self->{gettext} ("No default token specified."));
148 }
149 $name = $self->{DEFAULT_TOKEN};
150 }
151 $self->debug ("getToken: $name");
152  
153 return undef
154 if (not $self->{TOKEN}->{$name} and
155 not $self->addToken ($name));
156 $self->debug ("getToken: token added");
157  
158 return $self->setError (7121030,
159 $self->{gettext} ("The token is not present in the system"))
160 if (not $self->{TOKEN}->{$name});
161 $self->debug ("getToken: token is present");
162  
163 return $self->setError (7121040,
164 $self->{gettext} ("The token is not usable."))
165 if (not $self->useToken ($name));
166 $self->debug ("getToken: token is usable");
167  
168 return $self->{TOKEN}->{$name};
169 }
170  
171 sub addToken {
172  
173 my $self = shift;
174 $self->debug ("addToken: entering function");
175  
176 my $name = $_[0];
177 if (not $_[0])
178 {
179 if (not $self->{DEFAULT_TOKEN})
180 {
181 return $self->setError (7123010,
182 $self->{gettext} ("No default token specified."));
183 }
184 $name = $self->{DEFAULT_TOKEN};
185 }
186 $self->debug ("addToken: $name");
187  
188 ## get matching config
189 my $token_count = $self->{cache}->get_xpath_count (
190 FILENAME => $self->{configfile},
191 XPATH => 'token_config/token');
192 for (my $i=0; $i<$token_count; $i++)
193 {
194 $self->debug ("addToken: checking name");
195 next if ($name ne $self->{cache}->get_xpath (
196 FILENAME => $self->{configfile},
197 XPATH => [ 'token_config/token', 'name' ],
198 COUNTER => [ $i, 0 ]));
199 $self->debug ("addToken: name ok");
200 my @args = ();
201  
202 ## load CRYPTO, GETTEXT, NAME and MODE to array
203 push @args, "OPENCA_CRYPTO", $self;
204 push @args, "GETTEXT", $self->{gettext};
205 push @args, "OPENCA_TOKEN", $name;
206 $self->debug ("addToken: loading mode");
207 my $help = $self->{cache}->get_xpath (
208 FILENAME => $self->{configfile},
209 XPATH => [ 'token_config/token', 'mode' ],
210 COUNTER => [ $i, 0 ]);
211 push @args, "TOKEN_MODE", $help;
212  
213 ## load complete config in array
214 $self->debug ("addToken: loading options");
215 my $option_count = $self->{cache}->get_xpath_count (
216 FILENAME => $self->{configfile},
217 XPATH => [ 'token_config/token', 'option' ],
218 COUNTER => [ $i ]);
219 for (my $k=0; $k<$option_count; $k++)
220 {
221 $help = $self->{cache}->get_xpath (
222 FILENAME => $self->{configfile},
223 XPATH => [ 'token_config/token', 'option', 'name' ],
224 COUNTER => [ $i, $k, 0 ]),
225 $self->debug ("addToken: option name: $help");
226 push @args, $help;
227 $help = $self->{cache}->get_xpath (
228 FILENAME => $self->{configfile},
229 XPATH => [ 'token_config/token', 'option', 'value' ],
230 COUNTER => [ $i, $k, 0 ]);
231 $self->debug ("addToken: option value: $help");
232 push @args, $help;
233 }
234 $self->debug ("addToken: loaded options");
235  
236 ## handle multivalued parameters
237  
238 my $count = scalar @args / 2;
239 my %hargs = ();
240 for (my $i=0; $i<$count; $i++)
241 {
242 my $name = $args[2*$i];
243 my $value = $args[2*$i+1];
244 ## if global debug then local debug too
245 $value = $self->{DEBUG} if ($name =~ /DEBUG/i and not $value and $self->{DEBUG});
246 if (exists $hargs{$name})
247 {
248 $hargs{$name} = [ @{$hargs{$name}}, $value ];
249 } else
250 {
251 $hargs{$name} = [ $value ];
252 }
253 ## activate crypto layer debugging if a single token is in debug mode
254 $self->{DEBUG} = $value if ($name =~ /DEBUG/i and $value);
255 }
256 @args = ();
257 foreach my $key (keys %hargs)
258 {
259 $self->debug ("addToken: argument: name: $key");
260 push @args, $key;
261 if (scalar @{$hargs{$key}} > 1)
262 {
263 push @args, $hargs{$key};
264 } else
265 {
266 push @args, $hargs{$key}->[0];
267 }
268 }
269 $self->debug ("addToken: fixed multivalued options");
270  
271 ## init token
272 my $type = $self->{cache}->get_xpath (
273 FILENAME => $self->{configfile},
274 XPATH => [ 'token_config/token', 'type' ],
275 COUNTER => [ $i, 0 ]);
276 $self->debug ("addToken: try to setup $type token");
277 $self->{TOKEN}->{$name} = $self->newToken ($type, @args);
278 if (not $self->{TOKEN}->{$name})
279 {
280 $self->setError (7123080,
281 $self->{gettext} ("Cannot create new OpenCA Token object. __ERRVAL__",
282 "__ERRVAL__", $self->errval));
283 return undef;
284 }
285 $self->debug ("addToken: token $name successfully added");
286 return $self->{TOKEN}->{$name};
287 }
288 return $self->setError (7123090,
289 $self->{gettext} ("The requested token is not configured (__NAME__).",
290 "__NAME__", $name));
291 }
292  
293 sub newToken {
294  
295 my $self = shift;
296 my $name = shift;
297 $self->debug ("newToken: entering function");
298 foreach my $item (@_)
299 {
300 $self->debug ("newToken: argument: $item");
301 }
302  
303 ## get the token class
304 my $token_class = "OpenCA::Token::$name";
305 eval "require $token_class";
306 if ($@)
307 {
308 $self->debug ("newToken: compilation of driver OpenCA::Token::$name failed");
309 return $self->setError ($@, $@);
310 }
311 $self->debug ("newToken: class: OpenCA::Token::$name");
312  
313 ## get the token
314 my $token = eval {$token_class->new (@_)};
315  
316 if ($@)
317 {
318 $self->debug ("newToken: cannot get new instance of driver OpenCA::Token::$name");
319 return $self->setError ($@, $@);
320 }
321 $self->debug ("newToken: no error during new");
322 return $self->setError ($token_class::errno, $token_class::errval)
323 if (not $token);
324 $self->debug ("newToken: new token present");
325  
326 return $token;
327 }
328  
329 sub useToken {
330 my $self = shift;
331  
332 my $name = $_[0];
333 if (not $_[0])
334 {
335 if (not $self->{DEFAULT_TOKEN})
336 {
337 return $self->setError (7125010,
338 $self->{gettext} ("No default token specified"));
339 }
340 $name = $self->{DEFAULT_TOKEN};
341 }
342  
343 ## the token must be present
344 return $self->setError (7125020,
345 $self->{gettext} ("The token is not present."))
346 if (not $self->{TOKEN}->{$name});
347 return $self->{TOKEN}->{$name}->login
348 if (not $self->{TOKEN}->{$name}->online);
349 return 1;
350 }
351  
352 ########################################################################
353 ## access control ##
354 ########################################################################
355  
356 sub setAccessControl {
357 my $self = shift;
358 $self->{ACCESS_CONTROL} = $_[0];
359 return 1;
360 }
361  
362 sub getAccessControl {
363 my $self = shift;
364 return $self->{ACCESS_CONTROL};
365 }
366  
367 sub stopSession {
368 my $self = shift;
369 my $error = 0;
370 foreach my $token (keys %{$self->{TOKEN}})
371 {
372 next if (not $self->{TOKEN}->{$token}->getMode !~ /^session$/i);
373 $error = 1 if (not $self->{TOKEN}->{$token}->logout);
374 }
375 return $self->setError (7174010,
376 $self->{gettext} ("Logout of at minimum one token failed"))
377 if ($error);
378 return 1;
379 }
380  
381 sub tokenLogOut{
382 my $self = shift;
383 my $name = $_[0];
384  
385 my $error = 0;
386  
387
388 return $self->setError (7178030,
389 $self->{gettext} ("The token __NAME__ cannot be initialized.",
390 "__NAME__", $name))
391 if (not $self->addToken($name));
392  
393
394 if (not $self->{TOKEN}->{$name}->logout())
395 {
396 return $self->setError (7174010,
397 $self->{gettext} ("Logout of $name token failed"));
398 }
399 return 1;
400 }
401  
402  
403 sub startDaemon {
404 my $self = shift;
405 my $error = 0;
406 my $token_count = $self->{cache}->get_xpath_count (
407 FILENAME => $self->{configfile},
408 XPATH => 'token_config/token');
409 for (my $i=0; $i<$token_count; $i++)
410 {
411 next if ($self->{cache}->get_xpath (
412 FILENAME => $self->{configfile},
413 XPATH => [ 'token_config/token', 'mode' ],
414 COUNTER => [ $i, 0 ]) !~ /^daemon$/i);
415 my $name = $self->{cache}->get_xpath (
416 FILENAME => $self->{configfile},
417 XPATH => [ 'token_config/token', 'name' ],
418 COUNTER => [ $i, 0 ]);
419 return $self->setError (7176030,
420 $self->{gettext} ("The token __NAME__ cannot be initialized.",
421 "__NAME__", $name))
422 if (not $self->addToken($name));
423 return $self->setError (7176040,
424 $self->{gettext} ("The token __NAME__ cannot be used.",
425 "__NAME__", $name))
426 if (not $self->useToken($name));
427 }
428 return $self->setError (7176080,
429 $self->{gettext} ("Logout of at minimum one token failed"))
430 if ($error);
431 return 1;
432 }
433  
434 sub stopDaemon {
435 my $self = shift;
436 my $error = 0;
437 my $token_count = $self->{cache}->get_xpath_count (
438 FILENAME => $self->{configfile},
439 XPATH => 'token_config/token');
440 for (my $i=0; $i<$token_count; $i++)
441 {
442 next if ($self->{cache}->get_xpath (
443 FILENAME => $self->{configfile},
444 XPATH => [ 'token_config/token', 'mode' ],
445 COUNTER => [ $i, 0 ]) !~ /^daemon$/i);
446 my $name = $self->{cache}->get_xpath (
447 FILENAME => $self->{configfile},
448 XPATH => [ 'token_config/token', 'name' ],
449 COUNTER => [ $i, 0 ]);
450 return $self->setError (7178030,
451 $self->{gettext} ("The token __NAME__ cannot be initialized.",
452 "__NAME__", $name))
453 if (not $self->addToken($name));
454 $error = 1 if (not $self->{TOKEN}->{$name}->logout());
455 }
456 return $self->setError (7178010,
457 $self->{gettext} ("Logout of at minimum one token failed"))
458 if ($error);
459 return 1;
460 }
461  
462 ##################################################################
463 ## automatic functionality ##
464 ##################################################################
465  
466 ## failover to default token
467 sub AUTOLOAD {
468 my $self = shift;
469  
470 return $self->setError (7196010,
471 $self->{gettext} ("There is no default token specified."))
472 if (not $self->{DEFAULT_TOKEN});
473  
474 return $self->setError (7196020,
475 $self->{gettext} ("The default token is not present."))
476 if (not $self->{TOKEN}->{$self->{DEFAULT_TOKEN}});
477  
478 return $self->{TOKEN}->{$self->{DEFAULT_TOKEN}}->$AUTOLOAD ( @_ );
479 }
480  
481 ## logout all tokens except sessions and daemons
482 sub DESTROY {
483 my $self = shift;
484  
485 my $default_token = $self->{TOKEN}->{$self->{DEFAULT_TOKEN}};
486 delete $self->{TOKEN}->{$self->{DEFAULT_TOKEN}};
487  
488 my $error = 0;
489 foreach my $token (keys %{$self->{TOKEN}})
490 {
491 next if (not $self->{TOKEN}->{$token}->getMode =~ /^(session|daemon)$/i);
492 $error = 1 if (not $self->{TOKEN}->{$token}->logout);
493 }
494  
495 return $self->setError (7199010,
496 $self->{gettext} ("Logout of at minimum one token failed"))
497 if ($error);
498 return 1;
499 }
500  
501 1;