1 /* X.509 certificate parser 2 * 3 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public Licence 8 * as published by the Free Software Foundation; either version 9 * 2 of the Licence, or (at your option) any later version. 10 */ 11 12 #define pr_fmt(fmt) "X.509: "fmt 13 #include <linux/kernel.h> 14 #include <linux/export.h> 15 #include <linux/slab.h> 16 #include <linux/err.h> 17 #include <linux/oid_registry.h> 18 #include "public_key.h" 19 #include "x509_parser.h" 20 #include "x509-asn1.h" 21 #include "x509_akid-asn1.h" 22 #include "x509_rsakey-asn1.h" 23 24 struct x509_parse_context { 25 struct x509_certificate *cert; /* Certificate being constructed */ 26 unsigned long data; /* Start of data */ 27 const void *cert_start; /* Start of cert content */ 28 const void *key; /* Key data */ 29 size_t key_size; /* Size of key data */ 30 enum OID last_oid; /* Last OID encountered */ 31 enum OID algo_oid; /* Algorithm OID */ 32 unsigned char nr_mpi; /* Number of MPIs stored */ 33 u8 o_size; /* Size of organizationName (O) */ 34 u8 cn_size; /* Size of commonName (CN) */ 35 u8 email_size; /* Size of emailAddress */ 36 u16 o_offset; /* Offset of organizationName (O) */ 37 u16 cn_offset; /* Offset of commonName (CN) */ 38 u16 email_offset; /* Offset of emailAddress */ 39 unsigned raw_akid_size; 40 const void *raw_akid; /* Raw authorityKeyId in ASN.1 */ 41 const void *akid_raw_issuer; /* Raw directoryName in authorityKeyId */ 42 unsigned akid_raw_issuer_size; 43 }; 44 45 /* 46 * Free an X.509 certificate 47 */ 48 void x509_free_certificate(struct x509_certificate *cert) 49 { 50 if (cert) { 51 public_key_destroy(cert->pub); 52 kfree(cert->issuer); 53 kfree(cert->subject); 54 kfree(cert->id); 55 kfree(cert->skid); 56 kfree(cert->akid_id); 57 kfree(cert->akid_skid); 58 kfree(cert->sig.digest); 59 mpi_free(cert->sig.rsa.s); 60 kfree(cert); 61 } 62 } 63 EXPORT_SYMBOL_GPL(x509_free_certificate); 64 65 /* 66 * Parse an X.509 certificate 67 */ 68 struct x509_certificate *x509_cert_parse(const void *data, size_t datalen) 69 { 70 struct x509_certificate *cert; 71 struct x509_parse_context *ctx; 72 struct asymmetric_key_id *kid; 73 long ret; 74 75 ret = -ENOMEM; 76 cert = kzalloc(sizeof(struct x509_certificate), GFP_KERNEL); 77 if (!cert) 78 goto error_no_cert; 79 cert->pub = kzalloc(sizeof(struct public_key), GFP_KERNEL); 80 if (!cert->pub) 81 goto error_no_ctx; 82 ctx = kzalloc(sizeof(struct x509_parse_context), GFP_KERNEL); 83 if (!ctx) 84 goto error_no_ctx; 85 86 ctx->cert = cert; 87 ctx->data = (unsigned long)data; 88 89 /* Attempt to decode the certificate */ 90 ret = asn1_ber_decoder(&x509_decoder, ctx, data, datalen); 91 if (ret < 0) 92 goto error_decode; 93 94 /* Decode the AuthorityKeyIdentifier */ 95 if (ctx->raw_akid) { 96 pr_devel("AKID: %u %*phN\n", 97 ctx->raw_akid_size, ctx->raw_akid_size, ctx->raw_akid); 98 ret = asn1_ber_decoder(&x509_akid_decoder, ctx, 99 ctx->raw_akid, ctx->raw_akid_size); 100 if (ret < 0) { 101 pr_warn("Couldn't decode AuthKeyIdentifier\n"); 102 goto error_decode; 103 } 104 } 105 106 /* Decode the public key */ 107 ret = asn1_ber_decoder(&x509_rsakey_decoder, ctx, 108 ctx->key, ctx->key_size); 109 if (ret < 0) 110 goto error_decode; 111 112 /* Generate cert issuer + serial number key ID */ 113 kid = asymmetric_key_generate_id(cert->raw_serial, 114 cert->raw_serial_size, 115 cert->raw_issuer, 116 cert->raw_issuer_size); 117 if (IS_ERR(kid)) { 118 ret = PTR_ERR(kid); 119 goto error_decode; 120 } 121 cert->id = kid; 122 123 kfree(ctx); 124 return cert; 125 126 error_decode: 127 kfree(ctx); 128 error_no_ctx: 129 x509_free_certificate(cert); 130 error_no_cert: 131 return ERR_PTR(ret); 132 } 133 EXPORT_SYMBOL_GPL(x509_cert_parse); 134 135 /* 136 * Note an OID when we find one for later processing when we know how 137 * to interpret it. 138 */ 139 int x509_note_OID(void *context, size_t hdrlen, 140 unsigned char tag, 141 const void *value, size_t vlen) 142 { 143 struct x509_parse_context *ctx = context; 144 145 ctx->last_oid = look_up_OID(value, vlen); 146 if (ctx->last_oid == OID__NR) { 147 char buffer[50]; 148 sprint_oid(value, vlen, buffer, sizeof(buffer)); 149 pr_debug("Unknown OID: [%lu] %s\n", 150 (unsigned long)value - ctx->data, buffer); 151 } 152 return 0; 153 } 154 155 /* 156 * Save the position of the TBS data so that we can check the signature over it 157 * later. 158 */ 159 int x509_note_tbs_certificate(void *context, size_t hdrlen, 160 unsigned char tag, 161 const void *value, size_t vlen) 162 { 163 struct x509_parse_context *ctx = context; 164 165 pr_debug("x509_note_tbs_certificate(,%zu,%02x,%ld,%zu)!\n", 166 hdrlen, tag, (unsigned long)value - ctx->data, vlen); 167 168 ctx->cert->tbs = value - hdrlen; 169 ctx->cert->tbs_size = vlen + hdrlen; 170 return 0; 171 } 172 173 /* 174 * Record the public key algorithm 175 */ 176 int x509_note_pkey_algo(void *context, size_t hdrlen, 177 unsigned char tag, 178 const void *value, size_t vlen) 179 { 180 struct x509_parse_context *ctx = context; 181 182 pr_debug("PubKey Algo: %u\n", ctx->last_oid); 183 184 switch (ctx->last_oid) { 185 case OID_md2WithRSAEncryption: 186 case OID_md3WithRSAEncryption: 187 default: 188 return -ENOPKG; /* Unsupported combination */ 189 190 case OID_md4WithRSAEncryption: 191 ctx->cert->sig.pkey_hash_algo = HASH_ALGO_MD5; 192 ctx->cert->sig.pkey_algo = PKEY_ALGO_RSA; 193 break; 194 195 case OID_sha1WithRSAEncryption: 196 ctx->cert->sig.pkey_hash_algo = HASH_ALGO_SHA1; 197 ctx->cert->sig.pkey_algo = PKEY_ALGO_RSA; 198 break; 199 200 case OID_sha256WithRSAEncryption: 201 ctx->cert->sig.pkey_hash_algo = HASH_ALGO_SHA256; 202 ctx->cert->sig.pkey_algo = PKEY_ALGO_RSA; 203 break; 204 205 case OID_sha384WithRSAEncryption: 206 ctx->cert->sig.pkey_hash_algo = HASH_ALGO_SHA384; 207 ctx->cert->sig.pkey_algo = PKEY_ALGO_RSA; 208 break; 209 210 case OID_sha512WithRSAEncryption: 211 ctx->cert->sig.pkey_hash_algo = HASH_ALGO_SHA512; 212 ctx->cert->sig.pkey_algo = PKEY_ALGO_RSA; 213 break; 214 215 case OID_sha224WithRSAEncryption: 216 ctx->cert->sig.pkey_hash_algo = HASH_ALGO_SHA224; 217 ctx->cert->sig.pkey_algo = PKEY_ALGO_RSA; 218 break; 219 } 220 221 ctx->algo_oid = ctx->last_oid; 222 return 0; 223 } 224 225 /* 226 * Note the whereabouts and type of the signature. 227 */ 228 int x509_note_signature(void *context, size_t hdrlen, 229 unsigned char tag, 230 const void *value, size_t vlen) 231 { 232 struct x509_parse_context *ctx = context; 233 234 pr_debug("Signature type: %u size %zu\n", ctx->last_oid, vlen); 235 236 if (ctx->last_oid != ctx->algo_oid) { 237 pr_warn("Got cert with pkey (%u) and sig (%u) algorithm OIDs\n", 238 ctx->algo_oid, ctx->last_oid); 239 return -EINVAL; 240 } 241 242 ctx->cert->raw_sig = value; 243 ctx->cert->raw_sig_size = vlen; 244 return 0; 245 } 246 247 /* 248 * Note the certificate serial number 249 */ 250 int x509_note_serial(void *context, size_t hdrlen, 251 unsigned char tag, 252 const void *value, size_t vlen) 253 { 254 struct x509_parse_context *ctx = context; 255 ctx->cert->raw_serial = value; 256 ctx->cert->raw_serial_size = vlen; 257 return 0; 258 } 259 260 /* 261 * Note some of the name segments from which we'll fabricate a name. 262 */ 263 int x509_extract_name_segment(void *context, size_t hdrlen, 264 unsigned char tag, 265 const void *value, size_t vlen) 266 { 267 struct x509_parse_context *ctx = context; 268 269 switch (ctx->last_oid) { 270 case OID_commonName: 271 ctx->cn_size = vlen; 272 ctx->cn_offset = (unsigned long)value - ctx->data; 273 break; 274 case OID_organizationName: 275 ctx->o_size = vlen; 276 ctx->o_offset = (unsigned long)value - ctx->data; 277 break; 278 case OID_email_address: 279 ctx->email_size = vlen; 280 ctx->email_offset = (unsigned long)value - ctx->data; 281 break; 282 default: 283 break; 284 } 285 286 return 0; 287 } 288 289 /* 290 * Fabricate and save the issuer and subject names 291 */ 292 static int x509_fabricate_name(struct x509_parse_context *ctx, size_t hdrlen, 293 unsigned char tag, 294 char **_name, size_t vlen) 295 { 296 const void *name, *data = (const void *)ctx->data; 297 size_t namesize; 298 char *buffer; 299 300 if (*_name) 301 return -EINVAL; 302 303 /* Empty name string if no material */ 304 if (!ctx->cn_size && !ctx->o_size && !ctx->email_size) { 305 buffer = kmalloc(1, GFP_KERNEL); 306 if (!buffer) 307 return -ENOMEM; 308 buffer[0] = 0; 309 goto done; 310 } 311 312 if (ctx->cn_size && ctx->o_size) { 313 /* Consider combining O and CN, but use only the CN if it is 314 * prefixed by the O, or a significant portion thereof. 315 */ 316 namesize = ctx->cn_size; 317 name = data + ctx->cn_offset; 318 if (ctx->cn_size >= ctx->o_size && 319 memcmp(data + ctx->cn_offset, data + ctx->o_offset, 320 ctx->o_size) == 0) 321 goto single_component; 322 if (ctx->cn_size >= 7 && 323 ctx->o_size >= 7 && 324 memcmp(data + ctx->cn_offset, data + ctx->o_offset, 7) == 0) 325 goto single_component; 326 327 buffer = kmalloc(ctx->o_size + 2 + ctx->cn_size + 1, 328 GFP_KERNEL); 329 if (!buffer) 330 return -ENOMEM; 331 332 memcpy(buffer, 333 data + ctx->o_offset, ctx->o_size); 334 buffer[ctx->o_size + 0] = ':'; 335 buffer[ctx->o_size + 1] = ' '; 336 memcpy(buffer + ctx->o_size + 2, 337 data + ctx->cn_offset, ctx->cn_size); 338 buffer[ctx->o_size + 2 + ctx->cn_size] = 0; 339 goto done; 340 341 } else if (ctx->cn_size) { 342 namesize = ctx->cn_size; 343 name = data + ctx->cn_offset; 344 } else if (ctx->o_size) { 345 namesize = ctx->o_size; 346 name = data + ctx->o_offset; 347 } else { 348 namesize = ctx->email_size; 349 name = data + ctx->email_offset; 350 } 351 352 single_component: 353 buffer = kmalloc(namesize + 1, GFP_KERNEL); 354 if (!buffer) 355 return -ENOMEM; 356 memcpy(buffer, name, namesize); 357 buffer[namesize] = 0; 358 359 done: 360 *_name = buffer; 361 ctx->cn_size = 0; 362 ctx->o_size = 0; 363 ctx->email_size = 0; 364 return 0; 365 } 366 367 int x509_note_issuer(void *context, size_t hdrlen, 368 unsigned char tag, 369 const void *value, size_t vlen) 370 { 371 struct x509_parse_context *ctx = context; 372 ctx->cert->raw_issuer = value; 373 ctx->cert->raw_issuer_size = vlen; 374 return x509_fabricate_name(ctx, hdrlen, tag, &ctx->cert->issuer, vlen); 375 } 376 377 int x509_note_subject(void *context, size_t hdrlen, 378 unsigned char tag, 379 const void *value, size_t vlen) 380 { 381 struct x509_parse_context *ctx = context; 382 ctx->cert->raw_subject = value; 383 ctx->cert->raw_subject_size = vlen; 384 return x509_fabricate_name(ctx, hdrlen, tag, &ctx->cert->subject, vlen); 385 } 386 387 /* 388 * Extract the data for the public key algorithm 389 */ 390 int x509_extract_key_data(void *context, size_t hdrlen, 391 unsigned char tag, 392 const void *value, size_t vlen) 393 { 394 struct x509_parse_context *ctx = context; 395 396 if (ctx->last_oid != OID_rsaEncryption) 397 return -ENOPKG; 398 399 ctx->cert->pub->pkey_algo = PKEY_ALGO_RSA; 400 401 /* Discard the BIT STRING metadata */ 402 ctx->key = value + 1; 403 ctx->key_size = vlen - 1; 404 return 0; 405 } 406 407 /* 408 * Extract a RSA public key value 409 */ 410 int rsa_extract_mpi(void *context, size_t hdrlen, 411 unsigned char tag, 412 const void *value, size_t vlen) 413 { 414 struct x509_parse_context *ctx = context; 415 MPI mpi; 416 417 if (ctx->nr_mpi >= ARRAY_SIZE(ctx->cert->pub->mpi)) { 418 pr_err("Too many public key MPIs in certificate\n"); 419 return -EBADMSG; 420 } 421 422 mpi = mpi_read_raw_data(value, vlen); 423 if (!mpi) 424 return -ENOMEM; 425 426 ctx->cert->pub->mpi[ctx->nr_mpi++] = mpi; 427 return 0; 428 } 429 430 /* The keyIdentifier in AuthorityKeyIdentifier SEQUENCE is tag(CONT,PRIM,0) */ 431 #define SEQ_TAG_KEYID (ASN1_CONT << 6) 432 433 /* 434 * Process certificate extensions that are used to qualify the certificate. 435 */ 436 int x509_process_extension(void *context, size_t hdrlen, 437 unsigned char tag, 438 const void *value, size_t vlen) 439 { 440 struct x509_parse_context *ctx = context; 441 struct asymmetric_key_id *kid; 442 const unsigned char *v = value; 443 444 pr_debug("Extension: %u\n", ctx->last_oid); 445 446 if (ctx->last_oid == OID_subjectKeyIdentifier) { 447 /* Get hold of the key fingerprint */ 448 if (ctx->cert->skid || vlen < 3) 449 return -EBADMSG; 450 if (v[0] != ASN1_OTS || v[1] != vlen - 2) 451 return -EBADMSG; 452 v += 2; 453 vlen -= 2; 454 455 ctx->cert->raw_skid_size = vlen; 456 ctx->cert->raw_skid = v; 457 kid = asymmetric_key_generate_id(v, vlen, "", 0); 458 if (IS_ERR(kid)) 459 return PTR_ERR(kid); 460 ctx->cert->skid = kid; 461 pr_debug("subjkeyid %*phN\n", kid->len, kid->data); 462 return 0; 463 } 464 465 if (ctx->last_oid == OID_authorityKeyIdentifier) { 466 /* Get hold of the CA key fingerprint */ 467 ctx->raw_akid = v; 468 ctx->raw_akid_size = vlen; 469 return 0; 470 } 471 472 return 0; 473 } 474 475 /** 476 * x509_decode_time - Decode an X.509 time ASN.1 object 477 * @_t: The time to fill in 478 * @hdrlen: The length of the object header 479 * @tag: The object tag 480 * @value: The object value 481 * @vlen: The size of the object value 482 * 483 * Decode an ASN.1 universal time or generalised time field into a struct the 484 * kernel can handle and check it for validity. The time is decoded thus: 485 * 486 * [RFC5280 §4.1.2.5] 487 * CAs conforming to this profile MUST always encode certificate validity 488 * dates through the year 2049 as UTCTime; certificate validity dates in 489 * 2050 or later MUST be encoded as GeneralizedTime. Conforming 490 * applications MUST be able to process validity dates that are encoded in 491 * either UTCTime or GeneralizedTime. 492 */ 493 int x509_decode_time(time64_t *_t, size_t hdrlen, 494 unsigned char tag, 495 const unsigned char *value, size_t vlen) 496 { 497 static const unsigned char month_lengths[] = { 31, 29, 31, 30, 31, 30, 498 31, 31, 30, 31, 30, 31 }; 499 const unsigned char *p = value; 500 unsigned year, mon, day, hour, min, sec, mon_len; 501 502 #define dec2bin(X) ({ unsigned char x = (X) - '0'; if (x > 9) goto invalid_time; x; }) 503 #define DD2bin(P) ({ unsigned x = dec2bin(P[0]) * 10 + dec2bin(P[1]); P += 2; x; }) 504 505 if (tag == ASN1_UNITIM) { 506 /* UTCTime: YYMMDDHHMMSSZ */ 507 if (vlen != 13) 508 goto unsupported_time; 509 year = DD2bin(p); 510 if (year >= 50) 511 year += 1900; 512 else 513 year += 2000; 514 } else if (tag == ASN1_GENTIM) { 515 /* GenTime: YYYYMMDDHHMMSSZ */ 516 if (vlen != 15) 517 goto unsupported_time; 518 year = DD2bin(p) * 100 + DD2bin(p); 519 if (year >= 1950 && year <= 2049) 520 goto invalid_time; 521 } else { 522 goto unsupported_time; 523 } 524 525 mon = DD2bin(p); 526 day = DD2bin(p); 527 hour = DD2bin(p); 528 min = DD2bin(p); 529 sec = DD2bin(p); 530 531 if (*p != 'Z') 532 goto unsupported_time; 533 534 mon_len = month_lengths[mon]; 535 if (mon == 2) { 536 if (year % 4 == 0) { 537 mon_len = 29; 538 if (year % 100 == 0) { 539 year /= 100; 540 if (year % 4 != 0) 541 mon_len = 28; 542 } 543 } 544 } 545 546 if (year < 1970 || 547 mon < 1 || mon > 12 || 548 day < 1 || day > mon_len || 549 hour < 0 || hour > 23 || 550 min < 0 || min > 59 || 551 sec < 0 || sec > 59) 552 goto invalid_time; 553 554 *_t = mktime64(year, mon, day, hour, min, sec); 555 return 0; 556 557 unsupported_time: 558 pr_debug("Got unsupported time [tag %02x]: '%*phN'\n", 559 tag, (int)vlen, value); 560 return -EBADMSG; 561 invalid_time: 562 pr_debug("Got invalid time [tag %02x]: '%*phN'\n", 563 tag, (int)vlen, value); 564 return -EBADMSG; 565 } 566 EXPORT_SYMBOL_GPL(x509_decode_time); 567 568 int x509_note_not_before(void *context, size_t hdrlen, 569 unsigned char tag, 570 const void *value, size_t vlen) 571 { 572 struct x509_parse_context *ctx = context; 573 return x509_decode_time(&ctx->cert->valid_from, hdrlen, tag, value, vlen); 574 } 575 576 int x509_note_not_after(void *context, size_t hdrlen, 577 unsigned char tag, 578 const void *value, size_t vlen) 579 { 580 struct x509_parse_context *ctx = context; 581 return x509_decode_time(&ctx->cert->valid_to, hdrlen, tag, value, vlen); 582 } 583 584 /* 585 * Note a key identifier-based AuthorityKeyIdentifier 586 */ 587 int x509_akid_note_kid(void *context, size_t hdrlen, 588 unsigned char tag, 589 const void *value, size_t vlen) 590 { 591 struct x509_parse_context *ctx = context; 592 struct asymmetric_key_id *kid; 593 594 pr_debug("AKID: keyid: %*phN\n", (int)vlen, value); 595 596 if (ctx->cert->akid_skid) 597 return 0; 598 599 kid = asymmetric_key_generate_id(value, vlen, "", 0); 600 if (IS_ERR(kid)) 601 return PTR_ERR(kid); 602 pr_debug("authkeyid %*phN\n", kid->len, kid->data); 603 ctx->cert->akid_skid = kid; 604 return 0; 605 } 606 607 /* 608 * Note a directoryName in an AuthorityKeyIdentifier 609 */ 610 int x509_akid_note_name(void *context, size_t hdrlen, 611 unsigned char tag, 612 const void *value, size_t vlen) 613 { 614 struct x509_parse_context *ctx = context; 615 616 pr_debug("AKID: name: %*phN\n", (int)vlen, value); 617 618 ctx->akid_raw_issuer = value; 619 ctx->akid_raw_issuer_size = vlen; 620 return 0; 621 } 622 623 /* 624 * Note a serial number in an AuthorityKeyIdentifier 625 */ 626 int x509_akid_note_serial(void *context, size_t hdrlen, 627 unsigned char tag, 628 const void *value, size_t vlen) 629 { 630 struct x509_parse_context *ctx = context; 631 struct asymmetric_key_id *kid; 632 633 pr_debug("AKID: serial: %*phN\n", (int)vlen, value); 634 635 if (!ctx->akid_raw_issuer || ctx->cert->akid_id) 636 return 0; 637 638 kid = asymmetric_key_generate_id(value, 639 vlen, 640 ctx->akid_raw_issuer, 641 ctx->akid_raw_issuer_size); 642 if (IS_ERR(kid)) 643 return PTR_ERR(kid); 644 645 pr_debug("authkeyid %*phN\n", kid->len, kid->data); 646 ctx->cert->akid_id = kid; 647 return 0; 648 } 649