| 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; |