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

filter: Statementstmt 0.0% 0 / 108 Branchbran 0.0% 0 / 6 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 22 Podpod 0.0% 0 / 5 totaltotal 0.0% 0 / 141 CC 4 SCAR 10.9
CC
4
Cov
0%
private
6.0
public
6.0
jwk
6.0
CRAP 3.0
1 package Crypt::Perl::ECDSA::Parse;
2  
3 =encoding utf-8
4  
5 =head1 NAME
6  
7 Crypt::Perl::ECDSA::Parse - ECDSA key parsing
8  
9 =head1 SYNOPSIS
10  
11 use Crypt::Perl::ECDSA::Parse ();
12  
13 #These accept either DER or PEM, native format or PKCS8.
14 #
15 my $prkey = Crypt::Perl::ECDSA::Parse::private($buffer);
16 my $pbkey = Crypt::Perl::ECDSA::Parse::public($buffer);
17  
18 =head1 DISCUSSION
19  
20 See L<Crypt::Perl::ECDSA::PrivateKey> and L<Crypt::Perl::ECDSA::PublicKey>
21 for descriptions of the interfaces of these two classes.
22  
23 =cut
24  
25 use strict;
26 use warnings;
27  
28 use Try::Tiny;
29  
30 use Crypt::Perl::ASN1 ();
31 use Crypt::Perl::PKCS8 ();
32 use Crypt::Perl::ToDER ();
33 use Crypt::Perl::ECDSA::ECParameters ();
34 use Crypt::Perl::X ();
35  
36 sub private {
37 my ($pem_or_der) = @_;
38  
39 require Crypt::Perl::ECDSA::PrivateKey;
40  
41 Crypt::Perl::ToDER::ensure_der($pem_or_der);
42  
43 my $asn1 = _private_asn1();
44 my $asn1_ec = $asn1->find('ECPrivateKey');
45  
46 my $struct;
47 try {
48 $struct = $asn1_ec->decode($pem_or_der);
49 }
50 catch {
51 my $ec_err = $_;
52  
53 my $asn1_pkcs8 = $asn1->find('PrivateKeyInfo');
54  
55 try {
56 my $pk8_struct = $asn1_pkcs8->decode($pem_or_der);
57  
58 #It still might succeed, even if this is wrong, so don’t die().
59 if ( $pk8_struct->{'privateKeyAlgorithm'}{'algorithm'} ne Crypt::Perl::ECDSA::ECParameters::OID_ecPublicKey() ) {
60 warn "Unknown private key algorithm OID: “$pk8_struct->{'privateKeyAlgorithm'}{'algorithm'}”";
61 }
62  
63 my $asn1_params = $asn1->find('EcpkParameters');
64 my $params = $asn1_params->decode($pk8_struct->{'privateKeyAlgorithm'}{'parameters'});
65  
66 $struct = $asn1_ec->decode($pk8_struct->{'privateKey'});
67 $struct->{'parameters'} = $params;
68 }
69 catch {
70 die Crypt::Perl::X::create('Generic', "Failed to decode private key as either ECDSA native ($ec_err) or PKCS8 ($_)");
71 };
72 };
73  
74 my $key_parts = {
75 version => $struct->{'version'},
76 private => Crypt::Perl::BigInt->from_bytes($struct->{'privateKey'}),
77 public => Crypt::Perl::BigInt->from_bytes($struct->{'publicKey'}[0]),
78 };
79  
80 return Crypt::Perl::ECDSA::PrivateKey->new($key_parts, $struct->{'parameters'});
81 }
82  
83 sub public {
84 my ($pem_or_der) = @_;
85  
86 require Crypt::Perl::ECDSA::PublicKey;
87  
88 Crypt::Perl::ToDER::ensure_der($pem_or_der);
89  
90 my $asn1 = _public_asn1();
91 my $asn1_ec = $asn1->find('ECPublicKey');
92  
93 my $struct;
94 try {
95 $struct = $asn1_ec->decode($pem_or_der);
96 }
97 catch {
98 my $ec_err = $_;
99  
100 my $asn1_pkcs8 = $asn1->find('SubjectPublicKeyInfo');
101  
102 try {
103 my $spk_struct = $asn1_pkcs8->decode($pem_or_der);
104  
105 #It still might succeed, even if this is wrong, so don’t die().
106 if ( $spk_struct->{'algorithm'}{'algorithm'} ne Crypt::Perl::ECDSA::ECParameters::OID_ecPublicKey() ) {
107 warn "Unknown private key algorithm OID: “$spk_struct->{'algorithm'}{'algorithm'}”";
108 }
109  
110 my $asn1_params = $asn1->find('EcpkParameters');
111 my $params = $asn1_params->decode($spk_struct->{'algorithm'}{'parameters'});
112  
113 $struct = { publicKey => $spk_struct->{'subjectPublicKey'} };
114 $struct->{'keydata'}{'parameters'} = $params;
115 }
116 catch {
117 die Crypt::Perl::X::create('Generic', "Failed to decode public key as either ECDSA native ($ec_err) or SubjectPublicKeyInfo ($_)");
118 };
119 };
120  
121 return Crypt::Perl::ECDSA::PublicKey->new(
122 $struct->{'publicKey'}[0],
123 $struct->{'keydata'}{'parameters'},
124 );
125 }
126  
127 sub jwk {
128 my ($hr) = @_;
129  
130 require Crypt::Perl::ECDSA::NIST;
131 require Crypt::Perl::ECDSA::EC::DB;
132 require Crypt::Perl::Math;
133 require MIME::Base64;
134  
135 my $curve_name = Crypt::Perl::ECDSA::NIST::get_curve_name_for_nist($hr->{'crv'});
136 my $curve_hr = Crypt::Perl::ECDSA::EC::DB::get_curve_data_by_name($curve_name);
137  
138 my $keylen = $curve_hr->{'p'}->bit_length();
139 my $pub_half_byte_length = Crypt::Perl::Math::ceil( $keylen / 8 );
140  
141 my $x = MIME::Base64::decode_base64url($hr->{'x'});
142 my $y = MIME::Base64::decode_base64url($hr->{'y'});
143  
144 #Make sure both halves are the proper length.
145 substr($_, 0, 0) = ("\0" x ($pub_half_byte_length - length)) for ($x, $y);
146  
147 my $public = Crypt::Perl::BigInt->from_bytes("\x{04}$x$y");
148  
149 if ($hr->{'d'}) {
150 require Crypt::Perl::ECDSA::PrivateKey;
151 require Crypt::Perl::JWK;
152  
153 my %args = (
154 version => 1,
155 public => $public,
156 private => Crypt::Perl::JWK::jwk_num_to_bigint($hr->{'d'}),
157 );
158  
159 return Crypt::Perl::ECDSA::PrivateKey->new_by_curve_name(\%args, $curve_name);
160 }
161  
162 require Crypt::Perl::ECDSA::PublicKey;
163 return Crypt::Perl::ECDSA::PublicKey->new_by_curve_name( $public, $curve_name);
164 }
165  
166 #----------------------------------------------------------------------
167  
168 sub _private_asn1 {
169 my $template = join("\n", Crypt::Perl::ECDSA::PrivateKey->ASN1_PRIVATE(), Crypt::Perl::PKCS8::ASN1());
170  
171 return Crypt::Perl::ASN1->new()->prepare($template);
172 }
173  
174 sub _public_asn1 {
175 my $template = join("\n", Crypt::Perl::ECDSA::PublicKey->ASN1_PUBLIC(), Crypt::Perl::PKCS8::ASN1());
176  
177 return Crypt::Perl::ASN1->new()->prepare($template);
178 }
179  
180 1;