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 / OAEP.pm < prev    next >
Encoding:
Perl POD Document  |  2003-01-08  |  8.4 KB  |  287 lines
  1. #!/usr/bin/perl -sw
  2. ##
  3. ## Crypt::RSA::ES::OAEP 
  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: OAEP.pm,v 1.24 2001/06/22 23:27:37 vipul Exp $
  10.  
  11. package Crypt::RSA::ES::OAEP; 
  12. use lib qw(lib);
  13. use strict;
  14. use vars qw(@ISA $VERSION);
  15. use Crypt::Random          qw(makerandom_octet);
  16. use Crypt::RSA::Errorhandler; 
  17. use Crypt::RSA::DataFormat qw(bitsize os2ip i2osp octet_xor mgf1 octet_len);
  18. use Crypt::RSA::Primitives;
  19. use Crypt::RSA::Debug      qw(debug);
  20. use Digest::SHA1           qw(sha1);
  21. use Math::Pari             qw(floor);
  22. use Sort::Versions         qw(versioncmp);
  23. use Carp;
  24. @ISA = qw(Crypt::RSA::Errorhandler);
  25. ($VERSION)  = '$Revision: 1.24 $' =~ /\s(\d+\.\d+)\s/; 
  26.  
  27. sub new { 
  28.     my ($class, %params) = @_;
  29.     my $self = bless { primitives => new Crypt::RSA::Primitives, 
  30.                        P          => "",
  31.                        hlen       => 20,
  32.                        VERSION    => $VERSION,
  33.                       }, $class;
  34.     if ($params{Version}) { 
  35.         if (versioncmp($params{Version}, '1.15') == -1) { 
  36.             $$self{P} = "Crypt::RSA"; 
  37.             $$self{VERSION} = $params{Version};
  38.         } elsif (versioncmp($params{Version}, $$self{VERSION}) == 1) { 
  39.             croak "Required version ($params{Version}) greater than installed version ($$self{VERSION}) of $class.\n";
  40.         }
  41.     }
  42.     return $self;
  43. }
  44.  
  45.  
  46. sub encrypt { 
  47.     my ($self, %params) = @_; 
  48.     my $key = $params{Key}; my $M = $params{Message} || $params{Plaintext};
  49.     return $self->error ($key->errstr, \$M, $key, \%params) unless $key->check;
  50.     my $k = octet_len ($key->n);  debug ("octet_len of modulus: $k");
  51.     my $em = $self->encode ($M, $self->{P}, $k-1) || 
  52.         return $self->error ($self->errstr, \$M, $key, \%params);
  53.     my $m = os2ip ($em);
  54.     my $c = $self->{primitives}->core_encrypt ( Plaintext => $m, Key => $key );
  55.     my $ec = i2osp ($c, $k);  debug ("ec: $ec");
  56.     return $ec;
  57. }    
  58.  
  59.  
  60. sub decrypt { 
  61.     my ($self, %params) = @_;
  62.     my $key = $params{Key}; my $C = $params{Cyphertext} || $params{Ciphertext}; 
  63.     return $self->error ($key->errstr, $key, \%params) unless $key->check;
  64.     my $k = octet_len ($key->n);  
  65.     my $c = os2ip ($C);
  66.     if (bitsize($c) > bitsize($key->n)) { 
  67.         return $self->error ("Decryption error.", $key, \%params) 
  68.     }
  69.     my $m = $self->{primitives}->core_decrypt (Cyphertext => $c, Key => $key) || 
  70.         return $self->error ("Decryption error.", $key, \%params);
  71.     my $em = i2osp ($m, $k-1) || 
  72.         return $self->error ("Decryption error.", $key, \%params);
  73.     my $M; $self->errstrrst;  # reset the errstr
  74.     unless ($M = $self->decode ($em, $$self{P})) { 
  75.         return $self->error ("Decryption error.", $key, \%params) if $self->errstr();
  76.         return $M;
  77.     } 
  78.     return $M;
  79. } 
  80.  
  81.  
  82. sub encode { 
  83.     my ($self, $M, $P, $emlen) = @_; 
  84.     my $hlen = $$self{hlen};
  85.     my $mlen = length($M);
  86.     return $self->error ("Message too long.", \$P, \$M) if $mlen > $emlen-(2*$hlen)-1;
  87.     my ($PS, $pslen) = ("", 0);
  88.     if ($pslen = $emlen-(2*$hlen+1+$mlen)) { 
  89.         $PS = chr(0)x$pslen;
  90.     }
  91.     my $phash = $self->hash ($P);
  92.     my $db = $phash . $PS . chr(1) . $M; 
  93.     my $seed = makerandom_octet (Length => $hlen);
  94.     my $dbmask = $self->mgf ($seed, $emlen-$hlen);
  95.     my $maskeddb = octet_xor ($db, $dbmask);
  96.     my $seedmask = $self->mgf ($maskeddb, $hlen);
  97.     my $maskedseed = octet_xor ($seed, $seedmask);
  98.     my $em = $maskedseed . $maskeddb;
  99.  
  100.     debug ("emlen == $emlen");
  101.     debug ("M == $M [" . length($M) . "]"); 
  102.     debug ("PS == $PS [$pslen]"); 
  103.     debug ("phash == $phash [" . length($phash) . "]"); 
  104.     debug ("seed == $seed [" . length($seed) . "]"); 
  105.     debug ("seedmask == $seedmask [" . length($seedmask) . "]"); 
  106.     debug ("db == $db [" . length($db) . "]"); 
  107.     debug ("dbmask == $dbmask [" . length($dbmask) . "]"); 
  108.     debug ("maskeddb == $maskeddb [" . length($maskeddb) . "]"); 
  109.     debug ("em == $em [" . length($em) . "]"); 
  110.  
  111.     return $em;
  112. }
  113.  
  114.  
  115. sub decode { 
  116.     my ($self, $em, $P) = @_; 
  117.     my $hlen = $$self{hlen};
  118.  
  119.     debug ("P == $P");
  120.     return $self->error ("Decoding error.", \$P) if length($em) < 2*$hlen+1;
  121.     my $maskedseed = substr $em, 0, $hlen; 
  122.     my $maskeddb = substr $em, $hlen; 
  123.     my $seedmask = $self->mgf ($maskeddb, $hlen);
  124.     my $seed = octet_xor ($maskedseed, $seedmask);
  125.     my $dbmask = $self->mgf ($seed, length($em) - $hlen);
  126.     my $db = octet_xor ($maskeddb, $dbmask); 
  127.     my $phash = $self->hash ($P); 
  128.  
  129.     debug ("em == $em [" . length($em) . "]"); 
  130.     debug ("phash == $phash [" . length($phash) . "]"); 
  131.     debug ("seed == $seed [" . length($seed) . "]"); 
  132.     debug ("seedmask == $seedmask [" . length($seedmask) . "]"); 
  133.     debug ("maskedseed == $maskedseed [" . length($maskedseed) . "]"); 
  134.     debug ("db == $db [" . length($db) . "]"); 
  135.     debug ("maskeddb == $maskeddb [" . length($maskeddb) . "]"); 
  136.     debug ("dbmask == $dbmask [" . length($dbmask) . "]"); 
  137.  
  138.     my ($phashorig) = substr $db, 0, $hlen;
  139.     debug ("phashorig == $phashorig [" . length($phashorig) . "]"); 
  140.     return $self->error ("Decoding error.", \$P) unless $phashorig eq $phash; 
  141.     $db = substr $db, $hlen;
  142.     my ($chr0, $chr1) = (chr(0), chr(1));
  143.     my ($ps, $m);
  144.     debug ("db == $db [" . length($db) . "]"); 
  145.     unless ( ($ps, undef, $m) = $db =~ /^($chr0*)($chr1)(.*)$/s ) { 
  146.         return $self->error ("Decoding error.", \$P);
  147.     } 
  148.  
  149.     return $m;
  150. }
  151.  
  152.  
  153. sub hash { 
  154.     my ($self, $data) = @_;
  155.     return sha1 ($data);
  156. }
  157.  
  158.  
  159. sub mgf {
  160.     my ($self, @data) = @_;
  161.     return mgf1 (@data);
  162. }
  163.  
  164.  
  165. sub encryptblock { 
  166.     my ($self, %params) = @_;
  167.     return octet_len ($params{Key}->n) - 42;
  168. } 
  169.  
  170.  
  171. sub decryptblock { 
  172.     my ($self, %params) = @_;
  173.     return octet_len ($params{Key}->n);
  174. }
  175.  
  176.  
  177. # should be able to call this as a class method.
  178. sub version {
  179.     my $self = shift;
  180.     return $self->{VERSION};
  181. }
  182.  
  183.  
  184. 1;
  185.  
  186. =head1 NAME
  187.  
  188. Crypt::RSA::ES::OAEP - Plaintext-aware encryption with RSA. 
  189.  
  190. =head1 SYNOPSIS
  191.  
  192.     my $oaep = new Crypt::RSA::ES::OAEP; 
  193.  
  194.     my $ct = $oaep->encrypt( Key => $key, Message => $message ) || 
  195.                 die $oaep->errstr; 
  196.  
  197.     my $pt = $oaep->decrypt( Key => $key, Cyphertext => $ct )   || 
  198.                 die $oaep->errstr; 
  199.  
  200. =head1 DESCRIPTION
  201.  
  202. This module implements Optimal Asymmetric Encryption, a plaintext-aware
  203. encryption scheme based on RSA. The notion of plaintext-aware implies it's
  204. computationally infeasible to obtain full or partial information about a
  205. message from a cyphertext, and computationally infeasible to generate a
  206. valid cyphertext without knowing the corresponding message.
  207. Plaintext-aware schemes, such as OAEP, are semantically secure,
  208. non-malleable and secure against chosen-ciphertext attack. For more
  209. information on OAEP and plaintext-aware encryption, see [3], [9] & [13].
  210.  
  211. =head1 METHODS
  212.  
  213. =head2 B<new()>
  214.  
  215. Constructor. 
  216.  
  217. =head2 B<version()>
  218.  
  219. Returns the version number of the module.
  220.  
  221. =head2 B<encrypt()>
  222.  
  223. Encrypts a string with a public key and returns the encrypted string
  224. on success. encrypt() takes a hash argument with the following
  225. mandatory keys:
  226.  
  227. =over 4
  228.  
  229. =item B<Message>
  230.  
  231. A string to be encrypted. The length of this string should not exceed k-42
  232. octets, where k is the octet length of the RSA modulus. If Message is
  233. longer than k-42, the method will fail and set $self->errstr to "Message
  234. too long."
  235.  
  236. =item B<Key>
  237.  
  238. Public key of the recipient, a Crypt::RSA::Key::Public object.
  239.  
  240. =back
  241.  
  242. =head2 B<decrypt()>
  243.  
  244. Decrypts cyphertext with a private key and returns plaintext on
  245. success. $self->errstr is set to "Decryption Error." or appropriate
  246. error on failure. decrypt() takes a hash argument with the following
  247. mandatory keys:
  248.  
  249. =over 4
  250.  
  251. =item B<Cyphertext>
  252.  
  253. A string encrypted with encrypt(). The length of the cyphertext must be k
  254. octets, where k is the length of the RSA modulus.
  255.  
  256. =item B<Key>
  257.  
  258. Private key of the receiver, a Crypt::RSA::Key::Private object.
  259.  
  260. =item B<Version>
  261.  
  262. Version of the module that was used for creating the Cyphertext. This is
  263. an optional argument. When present, decrypt() will ensure before
  264. proceeding that the installed version of the module can successfully
  265. decrypt the Cyphertext.
  266.  
  267. =head1 ERROR HANDLING
  268.  
  269. See ERROR HANDLING in Crypt::RSA(3) manpage.
  270.  
  271. =head1 BIBLIOGRAPHY 
  272.  
  273. See BIBLIOGRAPHY in Crypt::RSA(3) manpage.
  274.  
  275. =head1 AUTHOR
  276.  
  277. Vipul Ved Prakash, E<lt>mail@vipul.netE<gt>
  278.  
  279. =head1 SEE ALSO 
  280.  
  281. Crypt::RSA(3), Crypt::RSA::Primitives(3), Crypt::RSA::Keys(3),
  282. Crypt::RSA::SSA::PSS(3)
  283.  
  284. =cut
  285.  
  286.  
  287.