| 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; |