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

filter: Statementstmt 0.0% 0 / 197 Branchbran 0.0% 0 / 16 Conditioncond 0.0% 0 / 18 MC/DCmcdc n/a Subroutinesub 0.0% 0 / 54 Podpod 0.0% 0 / 26 totaltotal 0.0% 0 / 311 CC 9 SCAR 13.9
CC
9
Cov
0%
_verify
20.0
_explicit_curve_parameters
12.0
to_der_with_curve_name
6.0
CRAP 4.0
1 package Crypt::Perl::ECDSA::KeyBase;
2  
3 use strict;
4 use warnings;
5  
6 use Try::Tiny;
7  
8 use parent qw(
9 Crypt::Perl::KeyBase
10 );
11  
12 use Crypt::Format ();
13  
14 use Crypt::Perl::ASN1 ();
15 use Crypt::Perl::BigInt ();
16 use Crypt::Perl::Math ();
17 use Crypt::Perl::ECDSA::EC::Curve ();
18 use Crypt::Perl::ECDSA::EC::DB ();
19 use Crypt::Perl::ECDSA::EC::Point ();
20 use Crypt::Perl::ECDSA::ECParameters ();
21 use Crypt::Perl::ECDSA::NIST ();
22 use Crypt::Perl::ECDSA::EncodedPoint ();
23 use Crypt::Perl::ECDSA::Utils ();
24 use Crypt::Perl::X ();
25  
26 use constant ASN1_SIGNATURE => q<
27 SEQUENCE {
28 r INTEGER,
29 s INTEGER
30 }
31 >;
32  
33 use constant ASN1_Params => Crypt::Perl::ECDSA::ECParameters::ASN1_ECParameters() . q<
34 EcpkParameters ::= CHOICE {
35 namedCurve OBJECT IDENTIFIER,
36 ecParameters ECParameters
37 }
38 >;
39  
40 use constant _JWK_THUMBPRINT_JSON_ORDER => qw( crv kty x y );
41  
42 use constant JWA_DIGEST_prime256v1 => 'sha256';
43 use constant JWA_DIGEST_secp384r1 => 'sha384';
44 use constant JWA_DIGEST_secp521r1 => 'sha512';
45  
46 use constant JWA_CURVE_ALG_prime256v1 => 'ES256';
47 use constant JWA_CURVE_ALG_secp384r1 => 'ES384';
48 use constant JWA_CURVE_ALG_secp521r1 => 'ES512';
49  
50 #Expects $key_parts to be a hash ref:
51 #
52 # version - AFAICT unused
53 # private - BigInt or its byte-string representation
54 # public - ^^
55 #
56 sub new_by_curve_name {
57 my ($class, $key_parts, $curve_name) = @_;
58  
59 #We could store the curve name on here if looking it up
60 #in to_der_with_curve_name() proves prohibitive.
61 return $class->new(
62 $key_parts,
63  
64 #“Fake out” the $curve_parts attribute by recreating
65 #the structure that ASN.1 would give from a named curve.
66 {
67 namedCurve => Crypt::Perl::ECDSA::EC::DB::get_oid_for_curve_name($curve_name),
68 },
69 );
70 }
71  
72 #$msg has to be small enough that the key could have signed it.
73 #It’s probably a digest rather than the original message.
74 sub verify {
75 my ($self, $msg, $sig) = @_;
76  
77 my $struct = Crypt::Perl::ASN1->new()->prepare(ASN1_SIGNATURE)->decode($sig);
78  
79 return $self->_verify($msg, @{$struct}{ qw( r s ) });
80 }
81  
82 #cf. RFC 7518, page 8
83 sub verify_jwa {
84 my ($self, $msg, $sig) = @_;
85  
86 my $dgst_cr = $self->_get_jwk_digest_cr();
87  
88 my $half_len = (length $sig) / 2;
89  
90 my $r = substr($sig, 0, $half_len);
91 my $s = substr($sig, $half_len);
92  
93 $_ = Crypt::Perl::BigInt->from_bytes($_) for ($r, $s);
94  
95 return $self->_verify($dgst_cr->($msg), $r, $s);
96 }
97  
98 sub to_der_with_curve_name {
99 my ($self, %params) = @_;
100  
101 if ($params{'seed'}) {
102 die Crypt::Perl::X::create('Generic', '“seed” is meaningless to a named-curve export.');
103 }
104  
105 return $self->_get_asn1_parts($self->_named_curve_parameters(), %params);
106 }
107  
108 sub to_der_with_explicit_curve {
109 my ($self, @params) = @_;
110  
111 return $self->_get_asn1_parts($self->_explicit_curve_parameters(@params), @params);
112 }
113  
114 sub to_pem_with_curve_name {
115 my ($self, @params) = @_;
116  
117 my $der = $self->to_der_with_curve_name(@params);
118  
119 return Crypt::Format::der2pem($der, $self->_PEM_HEADER());
120 }
121  
122 sub to_pem_with_explicit_curve {
123 my ($self, @params) = @_;
124  
125 my $der = $self->to_der_with_explicit_curve(@params);
126  
127 return Crypt::Format::der2pem($der, $self->_PEM_HEADER());
128 }
129  
130 sub max_sign_bits {
131 my ($self) = @_;
132  
133 return $self->_get_curve_obj()->keylen();
134 }
135  
136 sub get_curve_name {
137 my ($self) = @_;
138  
139 return Crypt::Perl::ECDSA::EC::DB::get_curve_name_by_data( $self->_curve() );
140 }
141  
142 sub get_struct_for_public_jwk {
143 my ($self) = @_;
144  
145 my ($xb, $yb) = Crypt::Perl::ECDSA::Utils::split_G_or_public( $self->_decompress_public_point() );
146  
147 require MIME::Base64;
148  
149 return {
150 kty => 'EC',
151 crv => $self->_get_jwk_curve_name(),
152 x => MIME::Base64::encode_base64url($xb),
153 y => MIME::Base64::encode_base64url($yb),
154 }
155 }
156  
157 sub get_jwa_alg {
158 my ($self) = @_;
159  
160 my $name = $self->get_curve_name();
161  
162 my $getter_cr = __PACKAGE__->can("JWA_CURVE_ALG_$name") or do {
163 my $err = sprintf( "“%s” knows of no JWA “alg” for the curve “%s”!", ref($self), $name);
164  
165 die Crypt::Perl::X::create('Generic', $err);
166 };
167  
168 return $getter_cr->();
169 }
170  
171 #----------------------------------------------------------------------
172  
173 sub _set_public {
174 my ($self, $pub_in) = @_;
175  
176 $self->{'_public'} = Crypt::Perl::ECDSA::EncodedPoint->new($pub_in);
177  
178 return;
179 }
180  
181 sub _compress_public_point {
182 my ($self) = @_;
183  
184 return $self->{'_public'}->get_compressed();
185 }
186  
187 sub _decompress_public_point {
188 my ($self) = @_;
189  
190 return $self->{'_public'}->get_uncompressed( $self->_curve() );
191 }
192  
193 sub _get_jwk_digest_cr {
194 my ($self) = @_;
195  
196 my $name = $self->get_curve_name();
197  
198 my $getter_cr = $self->can("JWA_DIGEST_$name") or do {
199 my $err = sprintf( "“%s” knows of no digest to use for JWA with the curve “%s”!", ref($self), $name);
200 die Crypt::Perl::X::create('Generic', $err);
201 };
202  
203 require Digest::SHA;
204  
205 return Digest::SHA->can( $getter_cr->() );
206 }
207  
208 sub _get_jwk_curve_name {
209 my ($self) = @_;
210  
211 my $name = $self->get_curve_name();
212  
213 return Crypt::Perl::ECDSA::NIST::get_nist_for_curve_name($name);
214 }
215  
216 sub _verify {
217 my ($self, $msg, $r, $s) = @_;
218  
219 if ($r->is_positive() && $s->is_positive()) {
220 my ($x, $y) = Crypt::Perl::ECDSA::Utils::split_G_or_public( $self->_decompress_public_point() );
221 $_ = Crypt::Perl::BigInt->from_bytes($_) for ($x, $y);
222  
223 my $curve = $self->_get_curve_obj();
224  
225 my $Q = Crypt::Perl::ECDSA::EC::Point->new(
226 $curve,
227 $curve->from_bigint($x),
228 $curve->from_bigint($y),
229 );
230  
231 my $e = Crypt::Perl::BigInt->from_bytes($msg);
232  
233 #----------------------------------------------------------------------
234  
235 my $n = $self->_curve()->{'n'};
236  
237 if ($r->blt($n) && $s->blt($n)) {
238 my $c = $s->copy()->bmodinv($n);
239  
240 my $u1 = $e->copy()->bmul($c)->bmod($n);
241 my $u2 = $r->copy()->bmul($c)->bmod($n);
242  
243 my $point = $self->_G()->multiply($u1)->add( $Q->multiply($u2) );
244  
245 my $v = $point->get_x()->to_bigint()->copy()->bmod($n);
246  
247 return 1 if $v->beq($r);
248 }
249 }
250  
251 return 0;
252 }
253  
254 #return isa EC::Point
255 sub _G {
256 my ($self) = @_;
257 return $self->_get_curve_obj()->decode_point( @{$self->_curve()}{ qw( gx gy ) } );
258 }
259  
260 sub _pad_bytes_for_asn1 {
261 my ($self, $bytes) = @_;
262  
263 return Crypt::Perl::ECDSA::Utils::pad_bytes_for_asn1( $bytes, $self->_curve()->{'p'} );
264 }
265  
266 sub _named_curve_parameters {
267 my ($self) = @_;
268  
269 my $curve_name = $self->get_curve_name();
270  
271 return {
272 namedCurve => Crypt::Perl::ECDSA::EC::DB::get_oid_for_curve_name($curve_name),
273 };
274 }
275  
276 #The idea is to emulate what Convert::ASN1 gives us as the parse.
277 sub _explicit_curve_parameters {
278 my ($self, %params) = @_;
279  
280 my $curve_hr = $self->_curve();
281  
282 my ($gx, $gy) = map { $_->as_bytes() } @{$curve_hr}{'gx', 'gy'};
283  
284 for my $str ( $gx, $gy ) {
285 $str = $self->_pad_bytes_for_asn1($str);
286 }
287  
288 my %curve = (
289 a => $curve_hr->{'a'}->as_bytes(),
290 b => $curve_hr->{'b'}->as_bytes(),
291 );
292  
293 if ($params{'seed'} && $curve_hr->{'seed'}) {
294  
295 #We don’t care about the bit count. (Right?)
296 $curve{'seed'} = $curve_hr->{'seed'}->as_bytes();
297 }
298  
299 my $base = "\x{04}$gx$gy";
300 if ( $params{'compressed'} ) {
301 $base = Crypt::Perl::ECDSA::Utils::compress_point($base);
302 }
303  
304 return {
305 ecParameters => {
306 version => 1,
307 fieldID => {
308 fieldType => Crypt::Perl::ECDSA::ECParameters::OID_prime_field(),
309 parameters => {
310 'prime-field' => $curve_hr->{'p'},
311 },
312 },
313 curve => \%curve,
314 base => $base,
315 order => $curve_hr->{'n'},
316 cofactor => $curve_hr->{'h'},
317 },
318 };
319 }
320  
321 sub __to_der {
322 my ($self, $macro, $template, $data_hr, %params) = @_;
323  
324 my $pub_bin = $params{'compressed'} ? $self->_compress_public_point() : $self->_decompress_public_point();
325  
326 local $data_hr->{'publicKey'} = $pub_bin;
327  
328 require Crypt::Perl::ASN1;
329 my $asn1 = Crypt::Perl::ASN1->new()->prepare($template);
330  
331 return $asn1->find($macro)->encode( $data_hr );
332 }
333  
334 #return isa EC::Curve
335 sub _get_curve_obj {
336 my ($self) = @_;
337  
338 return $self->{'_curve_obj'} ||= Crypt::Perl::ECDSA::EC::Curve->new( @{$self->_curve()}{ qw( p a b ) } );
339 }
340  
341 sub _add_params {
342 my ($self, $params_struct) = @_;
343  
344 if (my $params = $params_struct->{'ecParameters'}) {
345  
346 #Convert::ASN1 returns bit strings as an array of [ $content, $length ].
347 #Since normalize() wants that, we local() it here.
348 #local $params->{'curve'}{'seed'} = [$params->{'curve'}{'seed'}] if $params->{'curve'} && $params->{'curve'}{'seed'};
349  
350 $self->{'curve'} = Crypt::Perl::ECDSA::ECParameters::normalize($params);
351 }
352 else {
353 $self->{'curve'} = $self->_curve_params_for_OID($params_struct->{'namedCurve'});
354 }
355  
356 return $self;
357 }
358  
359 sub _curve_params_for_OID {
360 my ($self, $oid) = @_;
361  
362 return Crypt::Perl::ECDSA::EC::DB::get_curve_data_by_oid($oid);
363 }
364  
365 sub _curve {
366 my ($self) = @_;
367  
368 return $self->{'curve'};
369 }
370  
371 #----------------------------------------------------------------------
372  
373 1;