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 / PKCS1v15.pm < prev    next >
Encoding:
Perl POD Document  |  2003-01-08  |  6.1 KB  |  246 lines
  1. #!/usr/bin/perl -sw
  2. ##
  3. ## Crypt::RSA::SS:PKCS1v15
  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: PKCS1v15.pm,v 1.6 2001/06/22 23:27:38 vipul Exp $
  10.  
  11. package Crypt::RSA::SS::PKCS1v15;
  12. use lib qw(lib);
  13. use strict;
  14. use vars qw(@ISA $VERSION);
  15. use Crypt::RSA::Errorhandler; 
  16. use Crypt::RSA::DataFormat qw(octet_len os2ip i2osp h2osp);
  17. use Crypt::RSA::Primitives;
  18. use Crypt::RSA::Debug qw(debug);
  19. use Digest::SHA1 qw(sha1);
  20. use Digest::MD5 qw(md5);
  21. use Digest::MD2 qw(md2);
  22. use Math::Pari qw(floor);
  23. @ISA = qw(Crypt::RSA::Errorhandler);
  24. ($VERSION)  = '$Revision: 1.6 $' =~ /\s(\d+\.\d+)\s/; 
  25.  
  26.  
  27. sub new { 
  28.  
  29.     my ($class, %params) = @_;
  30.     my $self = bless { 
  31.                        primitives => new Crypt::RSA::Primitives, 
  32.                        digest     => $params{Digest} || 'SHA1',
  33.                        encoding   => { 
  34.                                         MD2 => "0x 30 20 30 0C 06 08 2A 86 48
  35.                                                    86 F7 0D 02 02 05 00 04 10",
  36.                                         MD5 => "0x 30 20 30 0C 06 08 2A 86 48
  37.                                                    86 F7 0D 02 05 05 00 04 10",
  38.                                        SHA1 => "0x 30 21 30 09 06 05 2B 0E 03
  39.                                                    02 1A 05 00 04 14",
  40.                                      },
  41.                        VERSION    => $VERSION,
  42.                      }, $class;           
  43.     if ($params{Version}) { 
  44.         # do versioning here
  45.     }
  46.     return $self;
  47.  
  48. }
  49.  
  50.  
  51. sub sign { 
  52.  
  53.     my ($self, %params) = @_; 
  54.     my $key = $params{Key}; my $M = $params{Message} || $params{Plaintext};
  55.     my $k = octet_len ($key->n);
  56.  
  57.     my $em; 
  58.     unless ($em = $self->encode ($M, $k-1)) { 
  59.         return $self->error ($self->errstr, \$key, \%params, \$M) 
  60.             if $self->errstr eq "Message too long.";
  61.         return $self->error ("Modulus too short.", \$key, \%params, \$M)
  62.             if $self->errstr eq "Intended encoded message length too short";
  63.     }
  64.  
  65.     my $m = os2ip ($em);
  66.     my $sig = $self->{primitives}->core_sign (Key => $key, Message => $m);
  67.     return i2osp ($sig, $k);
  68.  
  69. }    
  70.  
  71.  
  72. sub verify { 
  73.  
  74.     my ($self, %params) = @_;
  75.     my $key = $params{Key}; my $M = $params{Message} || $params{Plaintext};
  76.     my $S = $params{Signature}; 
  77.     my $k = octet_len ($key->n);
  78.     return $self->error ("Invalid signature.", \$key, \$M, \%params) if length($S) != $k;
  79.     my $s = os2ip ($S);
  80.     my $m = $self->{primitives}->core_verify (Key => $key, Signature => $s) || 
  81.         $self->error ("Invalid signature.", \$M, $key, \%params);
  82.     my $em = i2osp ($m, $k-1) || 
  83.         return $self->error ("Invalid signature.", \$M, \$S, $key, \%params);
  84.     my $em1; 
  85.     unless ($em1 = $self->encode ($M, $k-1)) { 
  86.         return $self->error ($self->errstr, \$key, \%params, \$M) 
  87.             if $self->errstr eq "Message too long.";
  88.         return $self->error ("Modulus too short.", \$key, \%params, \$M)
  89.             if $self->errstr eq "Intended encoded message length too short.";
  90.     }
  91.  
  92.     debug ("em: $em"); debug ("em1: $em1");
  93.  
  94.     return 1 if $em eq $em1;
  95.     return $self->error ("Invalid signature.", \$M, \$key, \%params);
  96.  
  97. }
  98.  
  99.  
  100. sub encode { 
  101.  
  102.     my ($self, $M, $emlen) = @_;
  103.  
  104.     my $H;
  105.     if    ($self->{digest} eq "SHA1") { $H = sha1 ($M) }
  106.     elsif ($self->{digest} eq "MD5" ) { $H =  md5 ($M) }
  107.     elsif ($self->{digest} eq "MD2" ) { $H =  md2 ($M) }
  108.  
  109.     my $alg = h2osp($self->{encoding}->{$self->{digest}});
  110.     my $T = $alg . $H;
  111.     $self->error ("Intended encoded message length too short.", \$M) if $emlen < length($T) + 10;
  112.     my $pslen = $emlen - length($T) - 2;
  113.     my $PS = chr(0xff) x $pslen;
  114.     my $em = chr(1) . $PS . chr(0) . $T; 
  115.     return $em;
  116.  
  117. }
  118.  
  119.  
  120. sub version { 
  121.     my $self = shift;
  122.     return $self->{VERSION};
  123. }
  124.  
  125.  
  126. sub signblock { 
  127.     return -1;
  128. }
  129.  
  130.  
  131. sub verifyblock { 
  132.     my ($self, %params) = @_;
  133.     return octet_len($params{Key}->n);
  134. }
  135.  
  136.  
  137. 1;
  138.  
  139. =head1 NAME
  140.  
  141. Crypt::RSA::SS::PKCS1v15 - PKCS #1 v1.5 signatures. 
  142.  
  143. =head1 SYNOPSIS
  144.  
  145.     my $pkcs = new Crypt::RSA::SS::PKCS1v15 ( 
  146.                         Digest => 'MD5'
  147.                     );
  148.  
  149.     my $signature = $pkcs->sign (
  150.                         Message => $message,
  151.                         Key     => $private, 
  152.                     ) || die $pss->errstr;
  153.  
  154.     my $verify    = $pkcs->verify (
  155.                         Message   => $message, 
  156.                         Key       => $key, 
  157.                         Signature => $signature, 
  158.                     ) || die $pss->errstr;
  159.  
  160.  
  161. =head1 DESCRIPTION
  162.  
  163. This module implements PKCS #1 v1.5 signatures based on RSA. See [13] 
  164. for details on the scheme.
  165.  
  166. =head1 METHODS
  167.  
  168. =head2 B<new()>
  169.  
  170. Constructor.   Takes a hash as argument with the following key: 
  171.  
  172. =over 4
  173.  
  174. =item B<Digest> 
  175.  
  176. Name of the Message Digest algorithm. Three Digest algorithms are
  177. supported: MD2, MD5 and SHA1. Digest defaults to SHA1.
  178.  
  179. =back 
  180.  
  181.  
  182. =head2 B<version()>
  183.  
  184. Returns the version number of the module. 
  185.  
  186. =head2 B<sign()>
  187.  
  188. Computes a PKCS #1 v1.5 signature on a message with the private key of the
  189. signer. sign() takes a hash argument with the following mandatory keys:
  190.  
  191. =over 4
  192.  
  193. =item B<Message> 
  194.  
  195. Message to be signed, a string of arbitrary length.  
  196.  
  197. =item B<Key> 
  198.  
  199. Private key of the signer, a Crypt::RSA::Key::Private object.
  200.  
  201. =back
  202.  
  203. =head2 B<verify()>
  204.  
  205. Verifies a signature generated with sign(). Returns a true value on
  206. success and false on failure. $self->errstr is set to "Invalid signature."
  207. or appropriate error on failure. verify() takes a hash argument with the
  208. following mandatory keys:
  209.  
  210. =over 4
  211.  
  212. =item B<Key>
  213.  
  214. Public key of the signer, a Crypt::RSA::Key::Public object. 
  215.  
  216. =item B<Message>
  217.  
  218. The original signed message, a string of arbitrary length. 
  219.  
  220. =item B<Signature>
  221.  
  222. Signature computed with sign(), a string. 
  223.  
  224. =head1 ERROR HANDLING
  225.  
  226. See ERROR HANDLING in Crypt::RSA(3) manpage.
  227.  
  228. =head1 BIBLIOGRAPHY
  229.  
  230. See BIBLIOGRAPHY in Crypt::RSA(3) manpage.
  231.  
  232. =over
  233.  
  234. =head1 AUTHOR
  235.  
  236. Vipul Ved Prakash, E<lt>mail@vipul.netE<gt>
  237.  
  238. =head1 SEE ALSO 
  239.  
  240. Crypt::RSA(3), Crypt::RSA::Primitives(3), Crypt::RSA::Keys(3),
  241. Crypt::RSA::EME::OAEP(3)
  242.  
  243. =cut
  244.  
  245.  
  246.