crypto/asymmetric_keys/x509_cert_parser.c

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