File Coverage

lib/Crypt/RSA/ES/PKCS1v15.pm
Criterion Covered Total %
statement 86 92 93.5
branch 9 20 45.0
condition 6 17 35.3
subroutine 18 19 94.7
pod 4 8 50.0
total 123 156 78.8


line stmt bran cond sub pod time code
1             #!/usr/bin/perl -sw
2             ##
3             ## Crypt::RSA::ES::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.10 2001/06/22 23:27:37 vipul Exp $
10              
11             package Crypt::RSA::ES::PKCS1v15;
12 1     1   15 use lib qw(lib);
  1         15  
  1         13  
13 1     1   20 use strict;
  1         9  
  1         15  
14 1     1   15 use vars qw(@ISA $VERSION);
  1         8  
  1         15  
15 1     1   65 use Crypt::Random qw(makerandom_octet);
  1         12  
  1         24  
16 1     1   34 use Crypt::RSA::Errorhandler;
  1         10  
  1         35  
17 1     1   30 use Crypt::RSA::DataFormat qw(bitsize octet_len os2ip i2osp);
  1         19  
  1         149  
18 1     1   1029 use Crypt::RSA::Primitives;
  1         10  
  1         28  
19 1     1   15 use Crypt::RSA::Debug qw(debug);
  1         9  
  1         18  
20 1     1   15 use Math::Pari qw(floor);
  1         9  
  1         14  
21 1     1   30 use Sort::Versions qw(versioncmp);
  1         10  
  1         22  
22 1     1   16 use Carp;
  1         10  
  1         17  
23             @ISA = qw(Crypt::RSA::Errorhandler);
24             ($VERSION)  = '$Revision: 1.91 $' =~ /\s(\d+\.\d+)\s/;
25              
26             sub new {
27 1     1 1 102     my ($class, %params) = @_;
28 1         19     my $self = bless { primitives => new Crypt::RSA::Primitives,
29                                    VERSION => $VERSION,
30                                   }, $class;
31 1 50       15     if ($params{Version}) {
32             # do versioning here.
33                 }
34 1         14     return $self;
35             }
36              
37              
38             sub encrypt {
39 2     2 1 78     my ($self, %params) = @_;
40 2   33     19     my $key = $params{Key}; my $M = $params{Message} || $params{Plaintext};
  2         22  
41 2 50       63     return $self->error ($key->errstr, \$M, $key, \%params) unless $key->check;
42 2         26     my $k = octet_len ($key->n); debug ("octet_len of modulus: $k");
  2         44  
43 2   33     154     my $em = $self->encode ($M, $k-1) ||
44                     return $self->error ($self->errstr, \$M, $key, \%params);
45 2         29         debug ("encoded: $em");
46 2         26     my $m = os2ip ($em);
47 2         37     my $c = $self->{primitives}->core_encrypt (Plaintext => $m, Key => $key);
48 2         26     my $ec = i2osp ($c, $k); debug ("cyphertext: $ec");
  2         29  
49 2         40     return $ec;
50             }    
51              
52              
53             sub decrypt {
54 2     2 1 48     my ($self, %params) = @_;
55 2   33     20     my $key = $params{Key}; my $C = $params{Cyphertext} || $params{Ciphertext};
  2         23  
56 2 50       30     return $self->error ($key->errstr, $key, \%params) unless $key->check;
57 2         37     my $k = octet_len ($key->n);
58 2         43     my $c = os2ip ($C);
59 2         29     debug ("bitsize(c): " . bitsize($c));
60 2         47     debug ("bitsize(n): " . bitsize($key->n));
61 2 50       696     if (bitsize($c) > bitsize($key->n)) {
62 0         0         return $self->error ("Decryption error.", $key, \%params)
63                 }
64 2   33     51     my $m = $self->{primitives}->core_decrypt (Cyphertext => $c, Key => $key) ||
65                     return $self->error ("Decryption error.", $key, \%params);
66 2   33     28     my $em = i2osp ($m, $k-1) ||
67                     return $self->error ("Decryption error.", $key, \%params);
68 2         18     my $M; $self->errstrrst; # reset the errstr
  2         44  
69 2 50       23     unless ($M = $self->decode ($em)) {
70 0 0       0         return $self->error ("Decryption error.", $key, \%params) if $self->errstr();
71 0         0         return $M;
72                 }
73 2         36     return $M;
74             } 
75              
76              
77             sub encode {
78 2     2 0 23     my ($self, $M, $emlen) = @_;
79 2   50     21     $M = $M || ""; my $mlen = length($M);
  2         18  
80 2 50       23     return $self->error ("Message too long.", \$M) if $mlen > $emlen-10;
81 2         20     my ($PS, $pslen) = ("", 0);
82              
83 2         19     $pslen = $emlen-$mlen-2;
84 2         26     $PS = makerandom_octet (Length => $pslen, Skip => chr(0));
85 2         27     my $em = chr(2).$PS.chr(0).$M;
86 2         29     return $em;
87             }
88              
89              
90             sub decode {
91 2     2 0 20     my ($self, $em) = @_;
92              
93 2 50       23     return $self->error ("Decoding error.") if length($em) < 10;
94              
95 2         25     debug ("to decode: $em");
96 2         49     my ($chr0, $chr2) = (chr(0), chr(2));
97 2         18     my ($ps, $M);
98 2 50       70     unless ( ($ps, $M) = $em =~ /^$chr2(.*?)$chr0(.*)$/s ) {
99 0         0         return $self->error ("Decoding error.");
100                 }
101 2 50       22     return $self->error ("Decoding error.") if length($ps) < 8;
102 2         24     return $M;
103             }
104              
105              
106             sub encryptblock {
107 1     1 0 24     my ($self, %params) = @_;
108 1         15     return octet_len ($params{Key}->n) - 11;
109             } 
110              
111              
112             sub decryptblock {
113 1     1 0 119     my ($self, %params) = @_;
114 1         21     return octet_len ($params{Key}->n);
115             }
116              
117              
118             sub version {
119 0     0 1       my $self = shift;
120 0               return $self->{VERSION};
121             }
122              
123              
124             1;
125              
126             =head1 NAME
127            
128             Crypt::RSA::ES::PKCS1v15 - PKCS #1 v1.5 padded encryption scheme based on RSA.
129            
130             =head1 SYNOPSIS
131            
132             my $pkcs = new Crypt::RSA::ES::PKCS1v15;
133            
134             my $ct = $pkcs->encrypt( Key => $key, Message => $message ) ||
135             die $pkcs->errstr;
136            
137             my $pt = $pkcs->decrypt( Key => $key, Cyphertext => $ct ) ||
138             die $pkcs->errstr;
139            
140             =head1 DESCRIPTION
141            
142             This module implements PKCS #1 v1.5 padded encryption scheme based on RSA.
143             See [13] for details on the encryption scheme.
144            
145             =head1 METHODS
146            
147             =head2 B<new()>
148            
149             Constructor.
150            
151             =head2 B<version()>
152            
153             Returns the version number of the module.
154            
155             =head2 B<encrypt()>
156            
157             Encrypts a string with a public key and returns the encrypted string
158             on success. encrypt() takes a hash argument with the following
159             mandatory keys:
160            
161             =over 4
162            
163             =item B<Message>
164            
165             A string to be encrypted. The length of this string should not exceed k-10
166             octets, where k is the octet length of the RSA modulus. If Message is
167             longer than k-10, the method will fail and set $self->errstr to "Message
168             too long."
169            
170             =item B<Key>
171            
172             Public key of the recipient, a Crypt::RSA::Key::Public object.
173            
174             =back
175            
176             =head2 B<decrypt()>
177            
178             Decrypts cyphertext with a private key and returns plaintext on
179             success. $self->errstr is set to "Decryption Error." or appropriate
180             error on failure. decrypt() takes a hash argument with the following
181             mandatory keys:
182            
183             =over 4
184            
185             =item B<Cyphertext>
186            
187             A string encrypted with encrypt(). The length of the cyphertext must be k
188             octets, where k is the length of the RSA modulus.
189            
190             =item B<Key>
191            
192             Private key of the receiver, a Crypt::RSA::Key::Private object.
193            
194             =back
195            
196             =head1 ERROR HANDLING
197            
198             See ERROR HANDLING in Crypt::RSA(3) manpage.
199            
200             =head1 BIBLIOGRAPHY
201            
202             See BIBLIOGRAPHY in Crypt::RSA(3) manpage.
203            
204             =head1 AUTHOR
205            
206             Vipul Ved Prakash, E<lt>mail@vipul.netE<gt>
207            
208             =head1 SEE ALSO
209            
210             Crypt::RSA(3), Crypt::RSA::Primitives(3), Crypt::RSA::Keys(3),
211             Crypt::RSA::SSA::PSS(3)
212            
213             =cut
214              
215              
216