File Coverage

lib/Crypt/Perl/RSA/KeyBase.pm
Criterion Covered Total %
statement 75 78 96.1
branch 3 4 75.0
condition n/a
subroutine 23 24 95.8
pod 1 11 9.0
total 102 117 87.1


line stmt bran cond sub pod time code
1             package Crypt::Perl::RSA::KeyBase;
2              
3 7     7   3545 use strict;
  7         17  
  7         214  
4 7     7   46 use warnings;
  7         22  
  7         201  
5              
6 7         61 use parent qw(
7             Class::Accessor::Fast
8             Crypt::Perl::KeyBase
9 7     7   35 );
  7         26  
10              
11 7     7   11981 use Module::Load ();
  7         18  
  7         107  
12              
13 7     7   62 use Crypt::Perl::BigInt ();
  7         16  
  7         95  
14 7     7   32 use Crypt::Perl::X ();
  7         19  
  7         424  
15              
16             BEGIN {
17 7     7   101 __PACKAGE__->mk_ro_accessors('modulus');
18 7         1805 __PACKAGE__->mk_ro_accessors('publicExponent');
19              
20 7         1566 *N = \&modulus;
21 7         234 *E = \&publicExponent;
22             }
23              
24 7     7   52 use constant _JWK_THUMBPRINT_JSON_ORDER => qw( e kty n );
  7         14  
  7         4256  
25              
26             sub new {
27 340     340 1 27870 my ($class, @args) = @_;
28              
29 340         3482 my $self = $class->SUPER::new(@args);
30              
31 340         7368 $self->{'publicExponent'} = Crypt::Perl::BigInt->new( $self->{'publicExponent'} );
32              
33 340         24120 return $self;
34             }
35              
36             sub to_pem {
37 51     51 0 993 my ($self) = @_;
38              
39 51         1568 require Crypt::Format;
40 51         684 return Crypt::Format::der2pem( $self->to_der(), $self->_PEM_HEADER() );
41             }
42              
43             #i.e., modulus length, in bits
44             sub size {
45 0     0 0 0 my ($self) = @_;
46              
47 0         0 return length( $self->modulus()->as_bin() ) - 2;
48             }
49              
50             sub modulus_byte_length {
51 1317     1317 0 2631 my ($self) = @_;
52              
53 1317         30796 return length $self->N()->as_bytes();
54              
55             #return( ( length( $self->N()->as_hex() ) - 2 ) / 2 );
56             }
57              
58             sub verify_RS256 {
59 777     777 0 199203 my ($self, $msg, $sig) = @_;
60              
61 777         2514 return $self->_verify($msg, $sig, 'Digest::SHA', 'sha256', 'PKCS1_v1_5');
62             }
63              
64             sub verify_RS384 {
65 2     2 0 23 my ($self, $msg, $sig) = @_;
66              
67 2         12 return $self->_verify($msg, $sig, 'Digest::SHA', 'sha384', 'PKCS1_v1_5');
68             }
69              
70             sub verify_RS512 {
71 2     2 0 24 my ($self, $msg, $sig) = @_;
72              
73 2         6 return $self->_verify($msg, $sig, 'Digest::SHA', 'sha512', 'PKCS1_v1_5');
74             }
75              
76             sub encrypt_raw {
77 1     1 0 14 my ($self, $bytes) = @_;
78              
79 1         6 return Crypt::Perl::BigInt->from_bytes($bytes)->bmodpow($self->{'publicExponent'}, $self->{'modulus'})->as_bytes();
80             }
81              
82             sub to_der {
83 56     56 0 298 my ($self) = @_;
84              
85 56         963 return $self->_to_der($self->_ASN1_MACRO());
86             }
87              
88             sub algorithm_identifier {
89 5     5 0 29 my ($self) = @_;
90              
91             return {
92 5         41 algorithm => OID_rsaEncryption(),
93             parameters => Crypt::Perl::ASN1::NULL(),
94             };
95             }
96              
97 7     7   65 use constant OID_rsaEncryption => '1.2.840.113549.1.1.1';
  7         29  
  7         3924  
98              
99             sub _to_subject_public_der {
100 5     5   23 my ($self) = @_;
101              
102 5         50 my $asn1 = $self->_asn1_find('SubjectPublicKeyInfo');
103              
104 5         165 return $asn1->encode( {
105             algorithm => $self->algorithm_identifier(),
106             subjectPublicKey => $self->_to_der('RSAPublicKey'),
107             } );
108             }
109              
110             sub get_struct_for_public_jwk {
111 4     4 0 68 my ($self) = @_;
112              
113 4         26 require MIME::Base64;
114              
115             return {
116 4         134 kty => 'RSA',
117             n => MIME::Base64::encode_base64url($self->N()->as_bytes()),
118             e => MIME::Base64::encode_base64url($self->E()->as_bytes()),
119             }
120             }
121              
122             #----------------------------------------------------------------------
123              
124             sub _asn1_find {
125 66     66   213 my ($self, $macro) = @_;
126              
127 66         1613 require Crypt::Perl::ASN1;
128 66         856 require Crypt::Perl::RSA::Template;
129 66         1663 my $asn1 = Crypt::Perl::ASN1->new()->prepare(
130             Crypt::Perl::RSA::Template::get_template('INTEGER'),
131             );
132              
133 66         451 return $asn1->find($macro);
134             }
135              
136             sub _to_der {
137 61     61   578 my ($self, $macro) = @_;
138              
139 61         304 return $self->_asn1_find($macro)->encode( { %$self } );
140             }
141              
142             sub _verify {
143 781     781   2103 my ($self, $message, $signature, $hash_module, $hasher, $scheme) = @_;
144              
145 781         3094 Module::Load::load($hash_module);
146              
147 781         86760 my $digest = $hash_module->can($hasher)->($message);
148              
149 781         5507 my $y = Crypt::Perl::BigInt->from_hex( unpack 'H*', $signature );
150              
151             #This modifies $y, but it doesn’t matter here.
152 781         248869 my $x = $y->bmodpow( $self->E(), $self->N() );
153              
154             #Math::BigInt will strip off the leading zero that PKCS1_v1_5 requires,
155             #so let’s put it back first of all.
156 781         102534 my $octets = "\0" . $x->as_bytes();
157              
158             #printf "OCTETS - %v02x\n", $octets;
159              
160 781 50       2384 if ($scheme eq 'PKCS1_v1_5') {
161 781         2649 my $key_bytes_length = $self->modulus_byte_length();
162 781 100       2830 if (length($octets) != $key_bytes_length) {
163 203         1723 my $err = sprintf( "Invalid PKCS1_v1_5 length: %d (should be %d)", length($octets), $key_bytes_length );
164 203         1089 die Crypt::Perl::X::create('Generic', $err);
165             }
166              
167 578         3878 require Crypt::Perl::RSA::PKCS1_v1_5;
168 578         2372 return $digest eq Crypt::Perl::RSA::PKCS1_v1_5::decode($octets, $hasher);
169             }
170              
171 0           die Crypt::Perl::X::create('Generic', "Unknown signature scheme: “$scheme”");
172             }
173              
174             1;