blib/lib/Crypt/Perl/RSA/Parse.pm untested

filter: Statementstmt 0.0% 0 / 112 Branchbran 0.0% 0 / 6 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 29 Podpod 0.0% 0 / 17 totaltotal 0.0% 0 / 164 CC 4 SCAR 11.6
CC
4
Cov
0%
jwk
12.0
_ensure_der
6.0
_asn1
2.0
CRAP 3.2
1 package Crypt::Perl::RSA::Parse;
2  
3 =encoding utf-8
4  
5 =head1 NAME
6  
7 Crypt::Perl::RSA::Parse - RSA key parsing
8  
9 =head1 SYNOPSIS
10  
11 use Crypt::Perl::RSA::Parse ();
12  
13 # These accept either DER or PEM, native format or PKCS8/SPKI.
14 my $prkey = Crypt::Perl::RSA::Parse::private($buffer);
15 my $pbkey = Crypt::Perl::RSA::Parse::public($buffer);
16  
17 # Note that this accepts a structure, not raw JSON.
18 my $key = Crypt::Perl::RSA::Parse::jwk($jwk_hr);
19  
20 =head1 DISCUSSION
21  
22 See L<Crypt::Perl::RSA::PrivateKey> and L<Crypt::Perl::RSA::PublicKey>
23 for descriptions of the interfaces that this module returns.
24  
25 =cut
26  
27 use strict;
28 use warnings;
29  
30 use Try::Tiny;
31  
32 use Crypt::Format ();
33  
34 use Crypt::Perl::ASN1 ();
35 use Crypt::Perl::RSA::Template ();
36 use Crypt::Perl::X ();
37  
38 sub _asn1 {
39 return Crypt::Perl::ASN1->new()->prepare(
40 Crypt::Perl::RSA::Template::get_template('INTEGER'),
41 );
42 }
43  
44 sub private {
45 my ( $pem_or_der) = @_;
46  
47 _ensure_der($pem_or_der);
48  
49 my $key_obj;
50  
51 try {
52 my $parsed = _decode_rsa($pem_or_der);
53 $key_obj = _new_private($parsed);
54 }
55 catch {
56 my $rsa_err = $_;
57  
58 try {
59 $key_obj = private_pkcs8($pem_or_der);
60 }
61 catch {
62 die Crypt::Perl::X::create('Generic', "Failed to parse as either RSA ($rsa_err) or PKCS8 ($_)");
63 };
64 };
65  
66 return $key_obj;
67 }
68  
69 #Like private(), but only does PKCS8.
70 sub private_pkcs8 {
71 my ($pem_or_der) = @_;
72  
73 _ensure_der($pem_or_der);
74  
75 my $pkcs8 = _decode_pkcs8($pem_or_der);
76  
77 my $parsed = _decode_rsa_within_pkcs8_or_die($pkcs8);
78  
79 return _new_private($parsed);
80 }
81  
82 #Checks for RSA format first, then falls back to PKCS8.
83 sub public {
84 my ($pem_or_der) = @_;
85  
86 _ensure_der($pem_or_der);
87  
88 my $key_obj;
89  
90 try {
91 my $parsed = _decode_rsa_public($pem_or_der);
92 $key_obj = _new_public($parsed);
93 }
94 catch {
95 my $rsa_err = $_;
96  
97 try {
98 $key_obj = public_SPKI($pem_or_der);
99 }
100 catch {
101 die Crypt::Perl::X::create('Generic', "Failed to parse as either RSA ($rsa_err) or SubjectPublicKeyInfo ($_)");
102 };
103 };
104  
105 return $key_obj;
106 }
107  
108 #Like public(), but only does SubjectPublicKeyInfo.
109 sub public_SPKI {
110 my ($pem_or_der) = @_;
111  
112 _ensure_der($pem_or_der);
113  
114 my $spki = _decode_spki($pem_or_der);
115  
116 my $parsed = _decode_rsa_public_within_spki_or_die($spki);
117  
118 return _new_public($parsed);
119 }
120  
121 my %JTK_TO_NEW = qw(
122 n modulus
123 e publicExponent
124 d privateExponent
125 p prime1
126 q prime2
127 dp exponent1
128 dq exponent2
129 qi coefficient
130 );
131  
132 sub jwk {
133 my ($hr) = @_;
134  
135 my %constr_args;
136  
137 require Crypt::Perl::JWK;
138  
139 for my $k (keys %$hr) {
140 next if !$JTK_TO_NEW{$k};
141 $constr_args{ $JTK_TO_NEW{$k} } = Crypt::Perl::JWK::jwk_num_to_bigint($hr->{$k});
142 }
143  
144 if ($hr->{'d'}) {
145 $constr_args{'version'} = 0;
146 require Crypt::Perl::RSA::PrivateKey;
147 return Crypt::Perl::RSA::PrivateKey->new( \%constr_args );
148 }
149  
150 require Crypt::Perl::RSA::PublicKey;
151 return Crypt::Perl::RSA::PublicKey->new( \%constr_args );
152 }
153  
154 #----------------------------------------------------------------------
155  
156 sub _decode_macro {
157 my ( $der_r, $macro ) = ( \$_[0], $_[1] );
158  
159 my $parser = _asn1()->find($macro);
160  
161 return $parser->decode($$der_r);
162 }
163  
164 #Checks for RSA format first, then falls back to PKCS8.
165 sub _decode_rsa {
166 my ($der_r) = (\$_[0]);
167  
168 return _decode_macro( $$der_r, 'RSAPrivateKey' );
169 }
170  
171 sub _decode_rsa_public {
172 my ($der_r) = (\$_[0]);
173  
174 return _decode_macro( $$der_r, 'RSAPublicKey' );
175 }
176  
177 sub _decode_rsa_within_pkcs8_or_die {
178 my ($pkcs8_hr) = @_;
179  
180 my $dec;
181 try {
182 $dec = _decode_rsa( $pkcs8_hr->{'privateKey'} );
183 }
184 catch {
185 die Crypt::Perl::X::create('Generic', "Failed to parse RSA within PKCS8: $_");
186 };
187  
188 return $dec;
189 }
190  
191 sub _decode_rsa_public_within_spki_or_die {
192 my ($spki_hr) = @_;
193  
194 my $dec;
195 try {
196 $dec = _decode_rsa_public( $spki_hr->{'subjectPublicKey'}[0] );
197 }
198 catch {
199 die Crypt::Perl::X::create('Generic', "Failed to parse RSA within SubjectPublicKeyInfo: $_");
200 };
201  
202 return $dec;
203 }
204  
205 sub _decode_pkcs8 {
206 my ($der_r) = (\$_[0]);
207  
208 return _decode_macro( $$der_r, 'PrivateKeyInfo' );
209 }
210  
211 sub _decode_spki {
212 my ($der_r) = (\$_[0]);
213  
214 return _decode_macro( $$der_r, 'SubjectPublicKeyInfo' );
215 }
216  
217 sub _new_public {
218 my ($parsed_hr) = @_;
219  
220 require Crypt::Perl::RSA::PublicKey;
221 return Crypt::Perl::RSA::PublicKey->new($parsed_hr);
222 }
223  
224 sub _new_private {
225 my ($parsed_hr) = @_;
226  
227 require Crypt::Perl::RSA::PrivateKey;
228 return Crypt::Perl::RSA::PrivateKey->new($parsed_hr);
229 }
230  
231 #Modifies in-place.
232 sub _pem_to_der {
233 $_[0] = Crypt::Format::pem2der(@_);
234  
235 return;
236 }
237  
238 sub _ensure_der {
239 my ($pem_or_der_r) = \$_[0];
240  
241 if ( $$pem_or_der_r =~ m<\A-> ) {
242 _pem_to_der($$pem_or_der_r);
243 }
244  
245 return;
246 }
247  
248 1;