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 / Primitives.pm < prev    next >
Encoding:
Perl POD Document  |  2003-01-08  |  3.5 KB  |  153 lines
  1. #!/usr/bin/perl -sw
  2. ##
  3. ## Crypt::RSA::Primitives -- Cryptography and encoding primitives  
  4. ##                           used by Crypt::RSA.
  5. ##
  6. ## Copyright (c) 2001, Vipul Ved Prakash.  All rights reserved.
  7. ## This code is free software; you can redistribute it and/or modify
  8. ## it under the same terms as Perl itself.
  9. ##
  10. ## $Id: Primitives.pm,v 1.14 2001/06/22 23:27:35 vipul Exp $
  11.  
  12. package Crypt::RSA::Primitives; 
  13. use lib qw(lib);
  14. use strict;
  15. use vars qw(@ISA);
  16. use Crypt::RSA::Errorhandler;
  17. use Crypt::RSA::Debug qw(debug);
  18. use Math::Pari qw(PARI Mod lift);
  19. use Carp;
  20. @ISA = qw(Crypt::RSA::Errorhandler);
  21.  
  22. sub new { 
  23.     return bless {}, shift; 
  24. } 
  25.  
  26.  
  27. sub core_encrypt {
  28.  
  29.     # procedure: 
  30.     # c = (m ** e) mod n 
  31.  
  32.     my ($self, %params) = @_;
  33.     my $key = $params{Key}; 
  34.     $self->error ("Bad key.", \%params, $key) unless $key->check();
  35.     my $plaintext = $params{Message} || $params{Plaintext};
  36.     debug ("pt == $plaintext");
  37.  
  38.     my $e = $key->e; my $n = $key->n;
  39.     return $self->error ("Numeric representation of plaintext is out of bound.", 
  40.                           \$plaintext, $key, \%params) if $plaintext > $n;
  41.     my $c = mod_exp($plaintext, $e, $n);
  42.     debug ("ct == $c");
  43.     $n = undef; $e = undef;
  44.     return $c;
  45.  
  46. }
  47.  
  48.  
  49. sub core_decrypt {
  50.  
  51.     # procedure: 
  52.     # p = (c ** d) mod n
  53.  
  54.  
  55.     my ($self, %params) = @_;
  56.     my $key = $params{Key}; 
  57.     $self->error ("Bad key.") unless $key->check();
  58.  
  59.     my $cyphertext = $params{Cyphertext} || $params{Ciphertext};
  60.     my $n = $key->n;
  61.     return $self->error ("Decryption error.") if $cyphertext > $n;
  62.  
  63.     my $pt;
  64.     if ($key->p && $key->q) {
  65.         my($p, $q, $d) = ($key->p, $key->q, $key->d);
  66.         $key->u (mod_inverse($p, $q)) unless $key->u;
  67.         $key->dp ($d % ($p-1)) unless $key->dp;
  68.         $key->dq ($d % ($q-1)) unless $key->dq;
  69.         my $p2 = mod_exp($cyphertext % $p, $key->dp, $p);
  70.         my $q2 = mod_exp($cyphertext % $q, $key->dq, $q);
  71.         $pt = $p2 + ($p * ((($q2 - $p2) * $key->u) % $q));
  72.     }
  73.     else {
  74.         $pt = mod_exp ($cyphertext, $key->d, $n);
  75.     }
  76.  
  77.     debug ("ct == $cyphertext");
  78.     debug ("pt == $pt");
  79.     return $pt;
  80.  
  81. }
  82.  
  83.  
  84. sub core_sign { 
  85.  
  86.     my ($self, %params) = @_; 
  87.     $params{Cyphertext} = $params{Message} || $params{Plaintext};
  88.     return $self->core_decrypt (%params); 
  89.  
  90. } 
  91.  
  92.  
  93. sub core_verify { 
  94.  
  95.     my ($self, %params) = @_; 
  96.     $params{Plaintext} = $params{Signature};
  97.     return $self->core_encrypt (%params); 
  98.  
  99. }
  100.  
  101.  
  102. sub mod_inverse {
  103.     my($a, $n) = @_;
  104.     my $m = Mod(1, $n);
  105.     lift($m / $a);
  106. }
  107.  
  108.  
  109. sub mod_exp {
  110.     my($a, $exp, $n) = @_;
  111.     my $m = Mod($a, $n);
  112.     lift($m ** $exp);
  113. }
  114.  
  115.  
  116. 1;
  117.  
  118. =head1 NAME
  119.  
  120. Crypt::RSA::Primitives - RSA encryption, decryption, signature and verification primitives. 
  121.  
  122. =head1 SYNOPSIS
  123.  
  124.     my $prim = new Crypt::RSA::Primitives;
  125.     my $ctxt = $prim->core_encrypt (Key => $key, Plaintext => $string); 
  126.     my $ptxt = $prim->core_decrypt (Key => $key, Cyphertext => $ctxt);
  127.     my $sign = $prim->core_sign    (Key => $key, Message => $string); 
  128.     my $vrfy = $prim->core_verify  (Key => $key, Signature => $sig);
  129.  
  130. =head1 DESCRIPTION
  131.  
  132. This module implements RSA encryption, decryption, signature and
  133. verfication primitives. These primitives should only be used in the
  134. context of an encryption or signing scheme. See Crypt::RSA::ES::OAEP(3),
  135. and Crypt::RSA::SS::PSS(3) for the implementation of two such schemes.
  136.  
  137. =head1 ERROR HANDLING
  138.  
  139. See B<ERROR HANDLING> in Crypt::RSA(3) manpage.
  140.  
  141. =head1 AUTHOR
  142.  
  143. Vipul Ved Prakash, E<lt>mail@vipul.netE<gt>
  144.  
  145. =head1 SEE ALSO 
  146.  
  147. Crypt::RSA(3), Crypt::RSA::Key(3), Crypt::RSA::ES::OAEP(3), 
  148. Crypt::RSA::SS::PSS(3)
  149.  
  150. =cut
  151.  
  152.  
  153.