home *** CD-ROM | disk | FTP | other *** search
/ PC Professionell 2004 December / PCpro_2004_12.ISO / files / webserver / tsw / TSW_3.4.0.exe / Apache2 / perl / Private.pm < prev    next >
Encoding:
Perl POD Document  |  2003-01-08  |  8.1 KB  |  322 lines
  1. #!/usr/bin/perl -sw
  2. ##
  3. ## Crypt::RSA::Key::Private 
  4. ##
  5. ## Copyright (c) 2001, Vipul Ved Prakash.  All rights reserved.
  6. ## This code is free software; you can redistribute it and/or modify
  7. ## it under the same terms as Perl itself.
  8. ##
  9. ## $Id: Private.pm,v 1.15 2001/09/25 14:11:22 vipul Exp $
  10.  
  11. package Crypt::RSA::Key::Private;
  12. use lib qw(lib);
  13. use strict; 
  14. use vars qw($AUTOLOAD $VERSION);
  15. use Crypt::RSA::Errorhandler;
  16. use Crypt::RSA;
  17. use Tie::EncryptedHash; 
  18. use Data::Dumper;
  19. use Math::Pari qw(PARI pari2pv Mod isprime lcm lift);
  20. use Carp;
  21. use vars qw(@ISA);
  22.  
  23. ($VERSION) = '$Revision: 1.15 $' =~ /\s(\d+\.\d+)\s/; 
  24. @ISA       = qw(Crypt::RSA::Errorhandler);
  25.  
  26.  
  27. sub new { 
  28.  
  29.     my ($class, %params) = @_; 
  30.     my $self    = { Version => $Crypt::RSA::Key::VERSION };
  31.     if ($params{Filename}) { 
  32.         bless $self, $class;
  33.         $self = $self->read (%params);
  34.         return bless $self, $class; 
  35.     } else { 
  36.         bless $self, $class;
  37.         $self->Identity ($params{Identity}) if $params{Identity};
  38.         $self->Cipher   ($params{Cipher}||"Blowfish");
  39.         $self->Password ($params{Password}) if $params{Password};
  40.         return $self;
  41.     } 
  42.  
  43. } 
  44.  
  45.  
  46. sub AUTOLOAD { 
  47.  
  48.     my ($self, $value) = @_;
  49.     my $key = $AUTOLOAD; $key =~ s/.*:://;
  50.     if ($key =~ /^(e|n|d|p|q|dp|dq|u|phi)$/) { 
  51.         if (ref $value eq 'Math::Pari') { 
  52.             $self->{private}{"_$key"} = $value;
  53.             $self->{Checked} = 0;
  54.         } elsif ($value && !(ref $value)) { 
  55.             if ($value =~ /^0x/) { 
  56.                 $self->{private}->{"_$key"} = 
  57.                 $self->{Checked} = 0;
  58.                     Math::Pari::_hex_cvt($value);
  59.             } else { $self->{private}{"_$key"} = PARI($value) } 
  60.         }
  61.         return $self->{private}{"_$key"} || 
  62.                $self->{private_encrypted}{"_$key"} || 
  63.                "";
  64.     } elsif ($key =~ /^Identity|Cipher|Password$/) { 
  65.         $self->{$key} = $value if $value; 
  66.         return $self->{$key};
  67.     } elsif ($key =~ /^Checked$/) { 
  68.         my ($package) = caller();
  69.         $self->{Checked} = $value if ($value && $package eq "Crypt::RSA::Key::Private") ;
  70.         return $self->{Checked};
  71.     }
  72. } 
  73.  
  74.  
  75. sub hide { 
  76.  
  77.     my ($self) = @_; 
  78.  
  79.     return undef unless $$self{Password};
  80.  
  81.     $self->{private_encrypted} = new Tie::EncryptedHash 
  82.             __password => $self->{Password},
  83.             __cipher   => $self->{Cipher};
  84.  
  85.     for (keys %{$$self{private}}) { 
  86.         $$self{private_encrypted}{$_} = pari2pv($$self{private}{$_});
  87.     }
  88.  
  89.     my $private = $self->{private_encrypted};
  90.     delete $private->{__password};
  91.     delete $$self{private};
  92.     delete $$self{Password};
  93.  
  94. } 
  95.  
  96.  
  97. sub reveal { 
  98.  
  99.     my ($self, %params) = @_; 
  100.     $$self{Password} = $params{Password} if $params{Password};
  101.     return undef unless $$self{Password};
  102.     $$self{private_encrypted}{__password} = $params{Password};
  103.     for (keys %{$$self{private_encrypted}}) { 
  104.         $$self{private}{$_} = PARI($$self{private_encrypted}{$_});
  105.     }
  106.  
  107. }
  108.  
  109.  
  110. sub check { 
  111.  
  112.     my ($self) = @_;
  113.  
  114.     return 1 if $self->{Checked};
  115.  
  116.     return $self->error ("Incomplete key.") unless 
  117.         ($self->n && $self->d) || ($self->n && $self->p && $self->q);
  118.  
  119.     if ($self->p && $self->q) { 
  120.         return $self->error ("n is not a number.") if $self->n =~ /\D/;
  121.         return $self->error ("p is not a number.") if $self->p =~ /\D/;
  122.         return $self->error ("p is not a number.") if $self->p =~ /\D/;
  123.         return $self->error ("n is not p*q."  ) unless $self->n == $self->p * $self->q;
  124.         return $self->error ("p is not prime.") unless isprime($self->p);
  125.         return $self->error ("q is not prime.") unless isprime($self->q);
  126.     }
  127.  
  128.     if ($self->e) { 
  129.         # d * e == 1 mod lcm(p-1, q-1)
  130.         return $self->error ("e is not a number.") if $self->e =~ /\D/;
  131.         my $k = lcm (($self->p -1), ($self->q -1));
  132.         my $K = Mod (1, $k); my $KI = lift($K * $self->d * $self->e);
  133.         return $self->error ("Bad `d'.") unless $KI == 1;
  134.     }
  135.  
  136.     if ($self->dp) {
  137.         # dp == d mod (p-1)
  138.         return $self->error ("Bad `dp'.") unless $self->dp == $self->d % ($self->p - 1);
  139.     }
  140.  
  141.     if ($self->dq) {
  142.         # dq == d mod (q-1)
  143.         return $self->error ("Bad `dq'.") unless $self->dq == $self->d % ($self->q - 1);
  144.     }
  145.  
  146.     if ($self->u && $self->q && $self->p) { 
  147.         my $m =  Mod (1,$self->q); $m = lift ($m / $self->p);
  148.         return $self->error ("Bad `u'.") unless $self->u == $m;
  149.     }
  150.  
  151.     $self->Checked(1);
  152.     return 1;
  153.  
  154. }
  155.  
  156.  
  157. sub DESTROY { 
  158.  
  159.     my $self = shift; 
  160.     delete $$self{private_encrypted}{__password}; 
  161.     delete $$self{private_encrypted};
  162.     delete $$self{private};
  163.     delete $$self{Password};
  164.     undef $self;
  165.  
  166. }
  167.  
  168.  
  169. sub write { 
  170.  
  171.     my ($self, %params) = @_; 
  172.     $self->hide();
  173.     my $string = $self->serialize (%params); 
  174.     open DISK, ">$params{Filename}" || 
  175.         croak "Can't open $params{Filename} for writing.";
  176.     print DISK $string;
  177.     close DISK;
  178.  
  179. } 
  180.  
  181.  
  182. sub read { 
  183.     my ($self, %params) = @_;
  184.     open DISK, $params{Filename} or 
  185.         croak "Can't open $params{Filename} to read.";
  186.     my @key = <DISK>; 
  187.     close DISK;
  188.     $self = $self->deserialize (String => \@key);
  189.     $self->reveal(%params);
  190.     return $self;
  191. }
  192.  
  193.  
  194. sub serialize { 
  195.  
  196.     my ($self, %params) = @_;
  197.     if ($$self{private}) {   # this is an unencrypted key
  198.         for (keys %{$$self{private}}) { 
  199.             $$self{private}{$_} = pari2pv($$self{private}{$_});
  200.         }
  201.     }
  202.     return Dumper $self; 
  203.  
  204. } 
  205.  
  206.  
  207. sub deserialize { 
  208.  
  209.     my ($self, %params) = @_; 
  210.     my $string = join'', @{$params{String}}; 
  211.     $string =~ s/\$VAR1 =//;
  212.     $self = eval $string;
  213.     if ($$self{private}) { # the key is unencrypted 
  214.         for (keys %{$$self{private}}) { 
  215.             $$self{private}{$_} = PARI($$self{private}{$_});
  216.         }
  217.         return $self;
  218.     }
  219.     my $private = new Tie::EncryptedHash; 
  220.     %$private = %{$$self{private_encrypted}};
  221.     $self->{private_encrypted} = $private;
  222.     return $self;
  223.  
  224. }
  225.  
  226.  
  227. 1;
  228.  
  229. =head1 NAME
  230.  
  231. Crypt::RSA::Key::Private -- RSA Private Key Management.
  232.  
  233. =head1 SYNOPSIS
  234.  
  235.     $key = new Crypt::RSA::Key::Private (
  236.                 Identity => 'Lord Banquo <banquo@lochaber.com>',
  237.                 Password => 'The earth hath bubbles',
  238.            );
  239.  
  240.     $key->hide();
  241.  
  242.     $key->write( Filename => 'rsakeys/banquo.private'  );
  243.  
  244.     $akey = new Crypt::RSA::Key::Private (
  245.                  Filename => 'rsakeys/banquo.private'
  246.                 );   
  247.  
  248.     $akey->reveal ( Password => 'The earth hath bubbles' );
  249.  
  250. =head1 DESCRIPTION
  251.  
  252. Crypt::RSA::Key::Private provides basic private key management
  253. functionality for Crypt::RSA private keys. Following methods are
  254. available:
  255.  
  256. =over 4 
  257.  
  258. =item B<new()>
  259.  
  260. The constructor. Takes a hash, usually with two arguments: C<Filename> and
  261. C<Password>. C<Filename> indicates a file from which the private key
  262. should be read. More often than not, private keys are kept encrypted with
  263. a symmetric cipher and MUST be decrypted before use. When a C<Password>
  264. argument is provided, the key is also decrypted before it is returned by
  265. C<new()>. Here's a complete list of arguments accepted by C<new()> (all of
  266. which are optional):
  267.  
  268. =over 4
  269.  
  270. =item Identity 
  271.  
  272. A string identifying the owner of the key. Canonically, a name and
  273. email address.
  274.  
  275. =item Filename 
  276.  
  277. Name of the file that contains the private key. 
  278.  
  279. =item Password
  280.  
  281. Password with which the private key is encrypted, or should be encrypted
  282. (in case of a new key).
  283.  
  284. =item Cipher 
  285.  
  286. Name of the symmetric cipher in which the private key is encrypted (or
  287. should be encrypted). The default is "Blowfish" and possible values
  288. include DES, IDEA, Twofish and other ciphers supported by Crypt::CBC.
  289.  
  290. =back
  291.  
  292. =item B<reveal()>
  293.  
  294. If the key is not decrypted at C<new()>, it can be decrypted by calling
  295. C<reveal()> with a C<Password> argument.
  296.  
  297. =item B<hide()>
  298.  
  299. C<hide()> causes the key to be encrypted by the chosen symmetric cipher
  300. and password.
  301.  
  302. =item B<write()>
  303.  
  304. Causes the key to be written to a disk file specified by the
  305. C<Filename> argument. C<write()> will call C<hide()> before writing the
  306. key to disk. If you wish to store the key in plain, don't specify a
  307. password at C<new()>.
  308.  
  309. =back
  310.  
  311. =head1 AUTHOR
  312.  
  313. Vipul Ved Prakash, E<lt>mail@vipul.netE<gt>
  314.  
  315. =head1 SEE ALSO
  316.  
  317. Crypt::RSA::Key(3), Crypt::RSA::Public(3)
  318.  
  319. =cut
  320.  
  321.  
  322.