1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* X.509 certificate parser 3 * 4 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #define pr_fmt(fmt) "X.509: "fmt 9 #include <linux/kernel.h> 10 #include <linux/export.h> 11 #include <linux/slab.h> 12 #include <linux/err.h> 13 #include <linux/oid_registry.h> 14 #include <crypto/public_key.h> 15 #include "x509_parser.h" 16 #include "x509.asn1.h" 17 #include "x509_akid.asn1.h" 18 19 struct x509_parse_context { 20 struct x509_certificate *cert; /* Certificate being constructed */ 21 unsigned long data; /* Start of data */ 22 const void *key; /* Key data */ 23 size_t key_size; /* Size of key data */ 24 const void *params; /* Key parameters */ 25 size_t params_size; /* Size of key parameters */ 26 enum OID key_algo; /* Algorithm used by the cert's key */ 27 enum OID last_oid; /* Last OID encountered */ 28 enum OID sig_algo; /* Algorithm used to sign the cert */ 29 u8 o_size; /* Size of organizationName (O) */ 30 u8 cn_size; /* Size of commonName (CN) */ 31 u8 email_size; /* Size of emailAddress */ 32 u16 o_offset; /* Offset of organizationName (O) */ 33 u16 cn_offset; /* Offset of commonName (CN) */ 34 u16 email_offset; /* Offset of emailAddress */ 35 unsigned raw_akid_size; 36 const void *raw_akid; /* Raw authorityKeyId in ASN.1 */ 37 const void *akid_raw_issuer; /* Raw directoryName in authorityKeyId */ 38 unsigned akid_raw_issuer_size; 39 }; 40 41 /* 42 * Free an X.509 certificate 43 */ x509_free_certificate(struct x509_certificate * cert)44 void x509_free_certificate(struct x509_certificate *cert) 45 { 46 if (cert) { 47 public_key_free(cert->pub); 48 public_key_signature_free(cert->sig); 49 kfree(cert->issuer); 50 kfree(cert->subject); 51 kfree(cert->id); 52 kfree(cert->skid); 53 kfree(cert); 54 } 55 } 56 EXPORT_SYMBOL_GPL(x509_free_certificate); 57 58 /* 59 * Parse an X.509 certificate 60 */ x509_cert_parse(const void * data,size_t datalen)61 struct x509_certificate *x509_cert_parse(const void *data, size_t datalen) 62 { 63 struct x509_certificate *cert __free(x509_free_certificate); 64 struct x509_parse_context *ctx __free(kfree) = NULL; 65 struct asymmetric_key_id *kid; 66 long ret; 67 68 cert = kzalloc(sizeof(struct x509_certificate), GFP_KERNEL); 69 if (!cert) 70 return ERR_PTR(-ENOMEM); 71 cert->pub = kzalloc(sizeof(struct public_key), GFP_KERNEL); 72 if (!cert->pub) 73 return ERR_PTR(-ENOMEM); 74 cert->sig = kzalloc(sizeof(struct public_key_signature), GFP_KERNEL); 75 if (!cert->sig) 76 return ERR_PTR(-ENOMEM); 77 ctx = kzalloc(sizeof(struct x509_parse_context), GFP_KERNEL); 78 if (!ctx) 79 return ERR_PTR(-ENOMEM); 80 81 ctx->cert = cert; 82 ctx->data = (unsigned long)data; 83 84 /* Attempt to decode the certificate */ 85 ret = asn1_ber_decoder(&x509_decoder, ctx, data, datalen); 86 if (ret < 0) 87 return ERR_PTR(ret); 88 89 /* Decode the AuthorityKeyIdentifier */ 90 if (ctx->raw_akid) { 91 pr_devel("AKID: %u %*phN\n", 92 ctx->raw_akid_size, ctx->raw_akid_size, ctx->raw_akid); 93 ret = asn1_ber_decoder(&x509_akid_decoder, ctx, 94 ctx->raw_akid, ctx->raw_akid_size); 95 if (ret < 0) { 96 pr_warn("Couldn't decode AuthKeyIdentifier\n"); 97 return ERR_PTR(ret); 98 } 99 } 100 101 cert->pub->key = kmemdup(ctx->key, ctx->key_size, GFP_KERNEL); 102 if (!cert->pub->key) 103 return ERR_PTR(-ENOMEM); 104 105 cert->pub->keylen = ctx->key_size; 106 107 cert->pub->params = kmemdup(ctx->params, ctx->params_size, GFP_KERNEL); 108 if (!cert->pub->params) 109 return ERR_PTR(-ENOMEM); 110 111 cert->pub->paramlen = ctx->params_size; 112 cert->pub->algo = ctx->key_algo; 113 114 /* Grab the signature bits */ 115 ret = x509_get_sig_params(cert); 116 if (ret < 0) 117 return ERR_PTR(ret); 118 119 /* Generate cert issuer + serial number key ID */ 120 kid = asymmetric_key_generate_id(cert->raw_serial, 121 cert->raw_serial_size, 122 cert->raw_issuer, 123 cert->raw_issuer_size); 124 if (IS_ERR(kid)) 125 return ERR_CAST(kid); 126 cert->id = kid; 127 128 /* Detect self-signed certificates */ 129 ret = x509_check_for_self_signed(cert); 130 if (ret < 0) 131 return ERR_PTR(ret); 132 133 return_ptr(cert); 134 } 135 EXPORT_SYMBOL_GPL(x509_cert_parse); 136 137 /* 138 * Note an OID when we find one for later processing when we know how 139 * to interpret it. 140 */ x509_note_OID(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)141 int x509_note_OID(void *context, size_t hdrlen, 142 unsigned char tag, 143 const void *value, size_t vlen) 144 { 145 struct x509_parse_context *ctx = context; 146 147 ctx->last_oid = look_up_OID(value, vlen); 148 if (ctx->last_oid == OID__NR) { 149 char buffer[50]; 150 sprint_oid(value, vlen, buffer, sizeof(buffer)); 151 pr_debug("Unknown OID: [%lu] %s\n", 152 (unsigned long)value - ctx->data, buffer); 153 } 154 return 0; 155 } 156 157 /* 158 * Save the position of the TBS data so that we can check the signature over it 159 * later. 160 */ x509_note_tbs_certificate(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)161 int x509_note_tbs_certificate(void *context, size_t hdrlen, 162 unsigned char tag, 163 const void *value, size_t vlen) 164 { 165 struct x509_parse_context *ctx = context; 166 167 pr_debug("x509_note_tbs_certificate(,%zu,%02x,%ld,%zu)!\n", 168 hdrlen, tag, (unsigned long)value - ctx->data, vlen); 169 170 ctx->cert->tbs = value - hdrlen; 171 ctx->cert->tbs_size = vlen + hdrlen; 172 return 0; 173 } 174 175 /* 176 * Record the algorithm that was used to sign this certificate. 177 */ x509_note_sig_algo(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)178 int x509_note_sig_algo(void *context, size_t hdrlen, unsigned char tag, 179 const void *value, size_t vlen) 180 { 181 struct x509_parse_context *ctx = context; 182 183 pr_debug("PubKey Algo: %u\n", ctx->last_oid); 184 185 switch (ctx->last_oid) { 186 default: 187 return -ENOPKG; /* Unsupported combination */ 188 189 case OID_sha1WithRSAEncryption: 190 ctx->cert->sig->hash_algo = "sha1"; 191 goto rsa_pkcs1; 192 193 case OID_sha256WithRSAEncryption: 194 ctx->cert->sig->hash_algo = "sha256"; 195 goto rsa_pkcs1; 196 197 case OID_sha384WithRSAEncryption: 198 ctx->cert->sig->hash_algo = "sha384"; 199 goto rsa_pkcs1; 200 201 case OID_sha512WithRSAEncryption: 202 ctx->cert->sig->hash_algo = "sha512"; 203 goto rsa_pkcs1; 204 205 case OID_sha224WithRSAEncryption: 206 ctx->cert->sig->hash_algo = "sha224"; 207 goto rsa_pkcs1; 208 209 case OID_id_ecdsa_with_sha1: 210 ctx->cert->sig->hash_algo = "sha1"; 211 goto ecdsa; 212 213 case OID_id_rsassa_pkcs1_v1_5_with_sha3_256: 214 ctx->cert->sig->hash_algo = "sha3-256"; 215 goto rsa_pkcs1; 216 217 case OID_id_rsassa_pkcs1_v1_5_with_sha3_384: 218 ctx->cert->sig->hash_algo = "sha3-384"; 219 goto rsa_pkcs1; 220 221 case OID_id_rsassa_pkcs1_v1_5_with_sha3_512: 222 ctx->cert->sig->hash_algo = "sha3-512"; 223 goto rsa_pkcs1; 224 225 case OID_id_ecdsa_with_sha224: 226 ctx->cert->sig->hash_algo = "sha224"; 227 goto ecdsa; 228 229 case OID_id_ecdsa_with_sha256: 230 ctx->cert->sig->hash_algo = "sha256"; 231 goto ecdsa; 232 233 case OID_id_ecdsa_with_sha384: 234 ctx->cert->sig->hash_algo = "sha384"; 235 goto ecdsa; 236 237 case OID_id_ecdsa_with_sha512: 238 ctx->cert->sig->hash_algo = "sha512"; 239 goto ecdsa; 240 241 case OID_id_ecdsa_with_sha3_256: 242 ctx->cert->sig->hash_algo = "sha3-256"; 243 goto ecdsa; 244 245 case OID_id_ecdsa_with_sha3_384: 246 ctx->cert->sig->hash_algo = "sha3-384"; 247 goto ecdsa; 248 249 case OID_id_ecdsa_with_sha3_512: 250 ctx->cert->sig->hash_algo = "sha3-512"; 251 goto ecdsa; 252 253 case OID_gost2012Signature256: 254 ctx->cert->sig->hash_algo = "streebog256"; 255 goto ecrdsa; 256 257 case OID_gost2012Signature512: 258 ctx->cert->sig->hash_algo = "streebog512"; 259 goto ecrdsa; 260 } 261 262 rsa_pkcs1: 263 ctx->cert->sig->pkey_algo = "rsa"; 264 ctx->cert->sig->encoding = "pkcs1"; 265 ctx->sig_algo = ctx->last_oid; 266 return 0; 267 ecrdsa: 268 ctx->cert->sig->pkey_algo = "ecrdsa"; 269 ctx->cert->sig->encoding = "raw"; 270 ctx->sig_algo = ctx->last_oid; 271 return 0; 272 ecdsa: 273 ctx->cert->sig->pkey_algo = "ecdsa"; 274 ctx->cert->sig->encoding = "x962"; 275 ctx->sig_algo = ctx->last_oid; 276 return 0; 277 } 278 279 /* 280 * Note the whereabouts and type of the signature. 281 */ x509_note_signature(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)282 int x509_note_signature(void *context, size_t hdrlen, 283 unsigned char tag, 284 const void *value, size_t vlen) 285 { 286 struct x509_parse_context *ctx = context; 287 288 pr_debug("Signature: alg=%u, size=%zu\n", ctx->last_oid, vlen); 289 290 /* 291 * In X.509 certificates, the signature's algorithm is stored in two 292 * places: inside the TBSCertificate (the data that is signed), and 293 * alongside the signature. These *must* match. 294 */ 295 if (ctx->last_oid != ctx->sig_algo) { 296 pr_warn("signatureAlgorithm (%u) differs from tbsCertificate.signature (%u)\n", 297 ctx->last_oid, ctx->sig_algo); 298 return -EINVAL; 299 } 300 301 if (strcmp(ctx->cert->sig->pkey_algo, "rsa") == 0 || 302 strcmp(ctx->cert->sig->pkey_algo, "ecrdsa") == 0 || 303 strcmp(ctx->cert->sig->pkey_algo, "ecdsa") == 0) { 304 /* Discard the BIT STRING metadata */ 305 if (vlen < 1 || *(const u8 *)value != 0) 306 return -EBADMSG; 307 308 value++; 309 vlen--; 310 } 311 312 ctx->cert->raw_sig = value; 313 ctx->cert->raw_sig_size = vlen; 314 return 0; 315 } 316 317 /* 318 * Note the certificate serial number 319 */ x509_note_serial(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)320 int x509_note_serial(void *context, size_t hdrlen, 321 unsigned char tag, 322 const void *value, size_t vlen) 323 { 324 struct x509_parse_context *ctx = context; 325 ctx->cert->raw_serial = value; 326 ctx->cert->raw_serial_size = vlen; 327 return 0; 328 } 329 330 /* 331 * Note some of the name segments from which we'll fabricate a name. 332 */ x509_extract_name_segment(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)333 int x509_extract_name_segment(void *context, size_t hdrlen, 334 unsigned char tag, 335 const void *value, size_t vlen) 336 { 337 struct x509_parse_context *ctx = context; 338 339 switch (ctx->last_oid) { 340 case OID_commonName: 341 ctx->cn_size = vlen; 342 ctx->cn_offset = (unsigned long)value - ctx->data; 343 break; 344 case OID_organizationName: 345 ctx->o_size = vlen; 346 ctx->o_offset = (unsigned long)value - ctx->data; 347 break; 348 case OID_email_address: 349 ctx->email_size = vlen; 350 ctx->email_offset = (unsigned long)value - ctx->data; 351 break; 352 default: 353 break; 354 } 355 356 return 0; 357 } 358 359 /* 360 * Fabricate and save the issuer and subject names 361 */ x509_fabricate_name(struct x509_parse_context * ctx,size_t hdrlen,unsigned char tag,char ** _name,size_t vlen)362 static int x509_fabricate_name(struct x509_parse_context *ctx, size_t hdrlen, 363 unsigned char tag, 364 char **_name, size_t vlen) 365 { 366 const void *name, *data = (const void *)ctx->data; 367 size_t namesize; 368 char *buffer; 369 370 if (*_name) 371 return -EINVAL; 372 373 /* Empty name string if no material */ 374 if (!ctx->cn_size && !ctx->o_size && !ctx->email_size) { 375 buffer = kmalloc(1, GFP_KERNEL); 376 if (!buffer) 377 return -ENOMEM; 378 buffer[0] = 0; 379 goto done; 380 } 381 382 if (ctx->cn_size && ctx->o_size) { 383 /* Consider combining O and CN, but use only the CN if it is 384 * prefixed by the O, or a significant portion thereof. 385 */ 386 namesize = ctx->cn_size; 387 name = data + ctx->cn_offset; 388 if (ctx->cn_size >= ctx->o_size && 389 memcmp(data + ctx->cn_offset, data + ctx->o_offset, 390 ctx->o_size) == 0) 391 goto single_component; 392 if (ctx->cn_size >= 7 && 393 ctx->o_size >= 7 && 394 memcmp(data + ctx->cn_offset, data + ctx->o_offset, 7) == 0) 395 goto single_component; 396 397 buffer = kmalloc(ctx->o_size + 2 + ctx->cn_size + 1, 398 GFP_KERNEL); 399 if (!buffer) 400 return -ENOMEM; 401 402 memcpy(buffer, 403 data + ctx->o_offset, ctx->o_size); 404 buffer[ctx->o_size + 0] = ':'; 405 buffer[ctx->o_size + 1] = ' '; 406 memcpy(buffer + ctx->o_size + 2, 407 data + ctx->cn_offset, ctx->cn_size); 408 buffer[ctx->o_size + 2 + ctx->cn_size] = 0; 409 goto done; 410 411 } else if (ctx->cn_size) { 412 namesize = ctx->cn_size; 413 name = data + ctx->cn_offset; 414 } else if (ctx->o_size) { 415 namesize = ctx->o_size; 416 name = data + ctx->o_offset; 417 } else { 418 namesize = ctx->email_size; 419 name = data + ctx->email_offset; 420 } 421 422 single_component: 423 buffer = kmalloc(namesize + 1, GFP_KERNEL); 424 if (!buffer) 425 return -ENOMEM; 426 memcpy(buffer, name, namesize); 427 buffer[namesize] = 0; 428 429 done: 430 *_name = buffer; 431 ctx->cn_size = 0; 432 ctx->o_size = 0; 433 ctx->email_size = 0; 434 return 0; 435 } 436 x509_note_issuer(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)437 int x509_note_issuer(void *context, size_t hdrlen, 438 unsigned char tag, 439 const void *value, size_t vlen) 440 { 441 struct x509_parse_context *ctx = context; 442 struct asymmetric_key_id *kid; 443 444 ctx->cert->raw_issuer = value; 445 ctx->cert->raw_issuer_size = vlen; 446 447 if (!ctx->cert->sig->auth_ids[2]) { 448 kid = asymmetric_key_generate_id(value, vlen, "", 0); 449 if (IS_ERR(kid)) 450 return PTR_ERR(kid); 451 ctx->cert->sig->auth_ids[2] = kid; 452 } 453 454 return x509_fabricate_name(ctx, hdrlen, tag, &ctx->cert->issuer, vlen); 455 } 456 x509_note_subject(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)457 int x509_note_subject(void *context, size_t hdrlen, 458 unsigned char tag, 459 const void *value, size_t vlen) 460 { 461 struct x509_parse_context *ctx = context; 462 ctx->cert->raw_subject = value; 463 ctx->cert->raw_subject_size = vlen; 464 return x509_fabricate_name(ctx, hdrlen, tag, &ctx->cert->subject, vlen); 465 } 466 467 /* 468 * Extract the parameters for the public key 469 */ x509_note_params(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)470 int x509_note_params(void *context, size_t hdrlen, 471 unsigned char tag, 472 const void *value, size_t vlen) 473 { 474 struct x509_parse_context *ctx = context; 475 476 /* 477 * AlgorithmIdentifier is used three times in the x509, we should skip 478 * first and ignore third, using second one which is after subject and 479 * before subjectPublicKey. 480 */ 481 if (!ctx->cert->raw_subject || ctx->key) 482 return 0; 483 ctx->params = value - hdrlen; 484 ctx->params_size = vlen + hdrlen; 485 return 0; 486 } 487 488 /* 489 * Extract the data for the public key algorithm 490 */ x509_extract_key_data(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)491 int x509_extract_key_data(void *context, size_t hdrlen, 492 unsigned char tag, 493 const void *value, size_t vlen) 494 { 495 struct x509_parse_context *ctx = context; 496 enum OID oid; 497 498 ctx->key_algo = ctx->last_oid; 499 switch (ctx->last_oid) { 500 case OID_rsaEncryption: 501 ctx->cert->pub->pkey_algo = "rsa"; 502 break; 503 case OID_gost2012PKey256: 504 case OID_gost2012PKey512: 505 ctx->cert->pub->pkey_algo = "ecrdsa"; 506 break; 507 case OID_id_ecPublicKey: 508 if (parse_OID(ctx->params, ctx->params_size, &oid) != 0) 509 return -EBADMSG; 510 511 switch (oid) { 512 case OID_id_prime192v1: 513 ctx->cert->pub->pkey_algo = "ecdsa-nist-p192"; 514 break; 515 case OID_id_prime256v1: 516 ctx->cert->pub->pkey_algo = "ecdsa-nist-p256"; 517 break; 518 case OID_id_ansip384r1: 519 ctx->cert->pub->pkey_algo = "ecdsa-nist-p384"; 520 break; 521 case OID_id_ansip521r1: 522 ctx->cert->pub->pkey_algo = "ecdsa-nist-p521"; 523 break; 524 default: 525 return -ENOPKG; 526 } 527 break; 528 default: 529 return -ENOPKG; 530 } 531 532 /* Discard the BIT STRING metadata */ 533 if (vlen < 1 || *(const u8 *)value != 0) 534 return -EBADMSG; 535 ctx->key = value + 1; 536 ctx->key_size = vlen - 1; 537 return 0; 538 } 539 540 /* The keyIdentifier in AuthorityKeyIdentifier SEQUENCE is tag(CONT,PRIM,0) */ 541 #define SEQ_TAG_KEYID (ASN1_CONT << 6) 542 543 /* 544 * Process certificate extensions that are used to qualify the certificate. 545 */ x509_process_extension(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)546 int x509_process_extension(void *context, size_t hdrlen, 547 unsigned char tag, 548 const void *value, size_t vlen) 549 { 550 struct x509_parse_context *ctx = context; 551 struct asymmetric_key_id *kid; 552 const unsigned char *v = value; 553 554 pr_debug("Extension: %u\n", ctx->last_oid); 555 556 if (ctx->last_oid == OID_subjectKeyIdentifier) { 557 /* Get hold of the key fingerprint */ 558 if (ctx->cert->skid || vlen < 3) 559 return -EBADMSG; 560 if (v[0] != ASN1_OTS || v[1] != vlen - 2) 561 return -EBADMSG; 562 v += 2; 563 vlen -= 2; 564 565 ctx->cert->raw_skid_size = vlen; 566 ctx->cert->raw_skid = v; 567 kid = asymmetric_key_generate_id(v, vlen, "", 0); 568 if (IS_ERR(kid)) 569 return PTR_ERR(kid); 570 ctx->cert->skid = kid; 571 pr_debug("subjkeyid %*phN\n", kid->len, kid->data); 572 return 0; 573 } 574 575 if (ctx->last_oid == OID_keyUsage) { 576 /* 577 * Get hold of the keyUsage bit string 578 * v[1] is the encoding size 579 * (Expect either 0x02 or 0x03, making it 1 or 2 bytes) 580 * v[2] is the number of unused bits in the bit string 581 * (If >= 3 keyCertSign is missing when v[1] = 0x02) 582 * v[3] and possibly v[4] contain the bit string 583 * 584 * From RFC 5280 4.2.1.3: 585 * 0x04 is where keyCertSign lands in this bit string 586 * 0x80 is where digitalSignature lands in this bit string 587 */ 588 if (v[0] != ASN1_BTS) 589 return -EBADMSG; 590 if (vlen < 4) 591 return -EBADMSG; 592 if (v[2] >= 8) 593 return -EBADMSG; 594 if (v[3] & 0x80) 595 ctx->cert->pub->key_eflags |= 1 << KEY_EFLAG_DIGITALSIG; 596 if (v[1] == 0x02 && v[2] <= 2 && (v[3] & 0x04)) 597 ctx->cert->pub->key_eflags |= 1 << KEY_EFLAG_KEYCERTSIGN; 598 else if (vlen > 4 && v[1] == 0x03 && (v[3] & 0x04)) 599 ctx->cert->pub->key_eflags |= 1 << KEY_EFLAG_KEYCERTSIGN; 600 return 0; 601 } 602 603 if (ctx->last_oid == OID_authorityKeyIdentifier) { 604 /* Get hold of the CA key fingerprint */ 605 ctx->raw_akid = v; 606 ctx->raw_akid_size = vlen; 607 return 0; 608 } 609 610 if (ctx->last_oid == OID_basicConstraints) { 611 /* 612 * Get hold of the basicConstraints 613 * v[1] is the encoding size 614 * (Expect 0x2 or greater, making it 1 or more bytes) 615 * v[2] is the encoding type 616 * (Expect an ASN1_BOOL for the CA) 617 * v[3] is the contents of the ASN1_BOOL 618 * (Expect 1 if the CA is TRUE) 619 * vlen should match the entire extension size 620 */ 621 if (v[0] != (ASN1_CONS_BIT | ASN1_SEQ)) 622 return -EBADMSG; 623 if (vlen < 2) 624 return -EBADMSG; 625 if (v[1] != vlen - 2) 626 return -EBADMSG; 627 if (vlen >= 4 && v[1] != 0 && v[2] == ASN1_BOOL && v[3] == 1) 628 ctx->cert->pub->key_eflags |= 1 << KEY_EFLAG_CA; 629 return 0; 630 } 631 632 return 0; 633 } 634 635 /** 636 * x509_decode_time - Decode an X.509 time ASN.1 object 637 * @_t: The time to fill in 638 * @hdrlen: The length of the object header 639 * @tag: The object tag 640 * @value: The object value 641 * @vlen: The size of the object value 642 * 643 * Decode an ASN.1 universal time or generalised time field into a struct the 644 * kernel can handle and check it for validity. The time is decoded thus: 645 * 646 * [RFC5280 ยง4.1.2.5] 647 * CAs conforming to this profile MUST always encode certificate validity 648 * dates through the year 2049 as UTCTime; certificate validity dates in 649 * 2050 or later MUST be encoded as GeneralizedTime. Conforming 650 * applications MUST be able to process validity dates that are encoded in 651 * either UTCTime or GeneralizedTime. 652 */ x509_decode_time(time64_t * _t,size_t hdrlen,unsigned char tag,const unsigned char * value,size_t vlen)653 int x509_decode_time(time64_t *_t, size_t hdrlen, 654 unsigned char tag, 655 const unsigned char *value, size_t vlen) 656 { 657 static const unsigned char month_lengths[] = { 31, 28, 31, 30, 31, 30, 658 31, 31, 30, 31, 30, 31 }; 659 const unsigned char *p = value; 660 unsigned year, mon, day, hour, min, sec, mon_len; 661 662 #define dec2bin(X) ({ unsigned char x = (X) - '0'; if (x > 9) goto invalid_time; x; }) 663 #define DD2bin(P) ({ unsigned x = dec2bin(P[0]) * 10 + dec2bin(P[1]); P += 2; x; }) 664 665 if (tag == ASN1_UNITIM) { 666 /* UTCTime: YYMMDDHHMMSSZ */ 667 if (vlen != 13) 668 goto unsupported_time; 669 year = DD2bin(p); 670 if (year >= 50) 671 year += 1900; 672 else 673 year += 2000; 674 } else if (tag == ASN1_GENTIM) { 675 /* GenTime: YYYYMMDDHHMMSSZ */ 676 if (vlen != 15) 677 goto unsupported_time; 678 year = DD2bin(p) * 100 + DD2bin(p); 679 if (year >= 1950 && year <= 2049) 680 goto invalid_time; 681 } else { 682 goto unsupported_time; 683 } 684 685 mon = DD2bin(p); 686 day = DD2bin(p); 687 hour = DD2bin(p); 688 min = DD2bin(p); 689 sec = DD2bin(p); 690 691 if (*p != 'Z') 692 goto unsupported_time; 693 694 if (year < 1970 || 695 mon < 1 || mon > 12) 696 goto invalid_time; 697 698 mon_len = month_lengths[mon - 1]; 699 if (mon == 2) { 700 if (year % 4 == 0) { 701 mon_len = 29; 702 if (year % 100 == 0) { 703 mon_len = 28; 704 if (year % 400 == 0) 705 mon_len = 29; 706 } 707 } 708 } 709 710 if (day < 1 || day > mon_len || 711 hour > 24 || /* ISO 8601 permits 24:00:00 as midnight tomorrow */ 712 min > 59 || 713 sec > 60) /* ISO 8601 permits leap seconds [X.680 46.3] */ 714 goto invalid_time; 715 716 *_t = mktime64(year, mon, day, hour, min, sec); 717 return 0; 718 719 unsupported_time: 720 pr_debug("Got unsupported time [tag %02x]: '%*phN'\n", 721 tag, (int)vlen, value); 722 return -EBADMSG; 723 invalid_time: 724 pr_debug("Got invalid time [tag %02x]: '%*phN'\n", 725 tag, (int)vlen, value); 726 return -EBADMSG; 727 } 728 EXPORT_SYMBOL_GPL(x509_decode_time); 729 x509_note_not_before(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)730 int x509_note_not_before(void *context, size_t hdrlen, 731 unsigned char tag, 732 const void *value, size_t vlen) 733 { 734 struct x509_parse_context *ctx = context; 735 return x509_decode_time(&ctx->cert->valid_from, hdrlen, tag, value, vlen); 736 } 737 x509_note_not_after(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)738 int x509_note_not_after(void *context, size_t hdrlen, 739 unsigned char tag, 740 const void *value, size_t vlen) 741 { 742 struct x509_parse_context *ctx = context; 743 return x509_decode_time(&ctx->cert->valid_to, hdrlen, tag, value, vlen); 744 } 745 746 /* 747 * Note a key identifier-based AuthorityKeyIdentifier 748 */ x509_akid_note_kid(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)749 int x509_akid_note_kid(void *context, size_t hdrlen, 750 unsigned char tag, 751 const void *value, size_t vlen) 752 { 753 struct x509_parse_context *ctx = context; 754 struct asymmetric_key_id *kid; 755 756 pr_debug("AKID: keyid: %*phN\n", (int)vlen, value); 757 758 if (ctx->cert->sig->auth_ids[1]) 759 return 0; 760 761 kid = asymmetric_key_generate_id(value, vlen, "", 0); 762 if (IS_ERR(kid)) 763 return PTR_ERR(kid); 764 pr_debug("authkeyid %*phN\n", kid->len, kid->data); 765 ctx->cert->sig->auth_ids[1] = kid; 766 return 0; 767 } 768 769 /* 770 * Note a directoryName in an AuthorityKeyIdentifier 771 */ x509_akid_note_name(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)772 int x509_akid_note_name(void *context, size_t hdrlen, 773 unsigned char tag, 774 const void *value, size_t vlen) 775 { 776 struct x509_parse_context *ctx = context; 777 778 pr_debug("AKID: name: %*phN\n", (int)vlen, value); 779 780 ctx->akid_raw_issuer = value; 781 ctx->akid_raw_issuer_size = vlen; 782 return 0; 783 } 784 785 /* 786 * Note a serial number in an AuthorityKeyIdentifier 787 */ x509_akid_note_serial(void * context,size_t hdrlen,unsigned char tag,const void * value,size_t vlen)788 int x509_akid_note_serial(void *context, size_t hdrlen, 789 unsigned char tag, 790 const void *value, size_t vlen) 791 { 792 struct x509_parse_context *ctx = context; 793 struct asymmetric_key_id *kid; 794 795 pr_debug("AKID: serial: %*phN\n", (int)vlen, value); 796 797 if (!ctx->akid_raw_issuer || ctx->cert->sig->auth_ids[0]) 798 return 0; 799 800 kid = asymmetric_key_generate_id(value, 801 vlen, 802 ctx->akid_raw_issuer, 803 ctx->akid_raw_issuer_size); 804 if (IS_ERR(kid)) 805 return PTR_ERR(kid); 806 807 pr_debug("authkeyid %*phN\n", kid->len, kid->data); 808 ctx->cert->sig->auth_ids[0] = kid; 809 return 0; 810 } 811