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         case OID_md2WithRSAEncryption:
 199         case OID_md3WithRSAEncryption:
 200         default:
 201                 return -ENOPKG; /* Unsupported combination */
 202
 203         case OID_md4WithRSAEncryption:
 204                 ctx->cert->sig->hash_algo = "md4";
 205                 goto rsa_pkcs1;
 206
 207         case OID_sha1WithRSAEncryption:
 208                 ctx->cert->sig->hash_algo = "sha1";
 209                 goto rsa_pkcs1;
 210
 211         case OID_sha256WithRSAEncryption:
 212                 ctx->cert->sig->hash_algo = "sha256";
 213                 goto rsa_pkcs1;
 214
 215         case OID_sha384WithRSAEncryption:
 216                 ctx->cert->sig->hash_algo = "sha384";
 217                 goto rsa_pkcs1;
 218
 219         case OID_sha512WithRSAEncryption:
 220                 ctx->cert->sig->hash_algo = "sha512";
 221                 goto rsa_pkcs1;
 222
 223         case OID_sha224WithRSAEncryption:
 224                 ctx->cert->sig->hash_algo = "sha224";
 225                 goto rsa_pkcs1;
 226
 227         case OID_id_ecdsa_with_sha1:
 228                 ctx->cert->sig->hash_algo = "sha1";
 229                 goto ecdsa;
 230
 231         case OID_id_ecdsa_with_sha224:
 232                 ctx->cert->sig->hash_algo = "sha224";
 233                 goto ecdsa;
 234
 235         case OID_id_ecdsa_with_sha256:
 236                 ctx->cert->sig->hash_algo = "sha256";
 237                 goto ecdsa;
 238
 239         case OID_id_ecdsa_with_sha384:
 240                 ctx->cert->sig->hash_algo = "sha384";
 241                 goto ecdsa;
 242
 243         case OID_id_ecdsa_with_sha512:
 244                 ctx->cert->sig->hash_algo = "sha512";
 245                 goto ecdsa;
 246
 247         case OID_gost2012Signature256:
 248                 ctx->cert->sig->hash_algo = "streebog256";
 249                 goto ecrdsa;
 250
 251         case OID_gost2012Signature512:
 252                 ctx->cert->sig->hash_algo = "streebog512";
 253                 goto ecrdsa;
 254
 255         case OID_SM2_with_SM3:
 256                 ctx->cert->sig->hash_algo = "sm3";
 257                 goto sm2;
 258         }
 259
 260 rsa_pkcs1:
 261         ctx->cert->sig->pkey_algo = "rsa";
 262         ctx->cert->sig->encoding = "pkcs1";
 263         ctx->sig_algo = ctx->last_oid;
 264         return 0;
 265 ecrdsa:
 266         ctx->cert->sig->pkey_algo = "ecrdsa";
 267         ctx->cert->sig->encoding = "raw";
 268         ctx->sig_algo = ctx->last_oid;
 269         return 0;
 270 sm2:
 271         ctx->cert->sig->pkey_algo = "sm2";
 272         ctx->cert->sig->encoding = "raw";
 273         ctx->sig_algo = ctx->last_oid;
 274         return 0;
 275 ecdsa:
 276         ctx->cert->sig->pkey_algo = "ecdsa";
 277         ctx->cert->sig->encoding = "x962";
 278         ctx->sig_algo = ctx->last_oid;
 279         return 0;
 280 }
 281
 282 /*
 283  * Note the whereabouts and type of the signature.
 284  */
 285 int x509_note_signature(void *context, size_t hdrlen,
 286                         unsigned char tag,
 287                         const void *value, size_t vlen)
 288 {
 289         struct x509_parse_context *ctx = context;
 290
 291         pr_debug("Signature: alg=%u, size=%zu\n", ctx->last_oid, vlen);
 292
 293         /*
 294          * In X.509 certificates, the signature's algorithm is stored in two
 295          * places: inside the TBSCertificate (the data that is signed), and
 296          * alongside the signature.  These *must* match.
 297          */
 298         if (ctx->last_oid != ctx->sig_algo) {
 299                 pr_warn("signatureAlgorithm (%u) differs from tbsCertificate.signature (%u)\n",
 300                         ctx->last_oid, ctx->sig_algo);
 301                 return -EINVAL;
 302         }
 303
 304         if (strcmp(ctx->cert->sig->pkey_algo, "rsa") == 0 ||
 305             strcmp(ctx->cert->sig->pkey_algo, "ecrdsa") == 0 ||
 306             strcmp(ctx->cert->sig->pkey_algo, "sm2") == 0 ||
 307             strcmp(ctx->cert->sig->pkey_algo, "ecdsa") == 0) {
 308                 /* Discard the BIT STRING metadata */
 309                 if (vlen < 1 || *(const u8 *)value != 0)
 310                         return -EBADMSG;
 311
 312                 value++;
 313                 vlen--;
 314         }
 315
 316         ctx->cert->raw_sig = value;
 317         ctx->cert->raw_sig_size = vlen;
 318         return 0;
 319 }
 320
 321 /*
 322  * Note the certificate serial number
 323  */
 324 int x509_note_serial(void *context, size_t hdrlen,
 325                      unsigned char tag,
 326                      const void *value, size_t vlen)
 327 {
 328         struct x509_parse_context *ctx = context;
 329         ctx->cert->raw_serial = value;
 330         ctx->cert->raw_serial_size = vlen;
 331         return 0;
 332 }
 333
 334 /*
 335  * Note some of the name segments from which we'll fabricate a name.
 336  */
 337 int x509_extract_name_segment(void *context, size_t hdrlen,
 338                               unsigned char tag,
 339                               const void *value, size_t vlen)
 340 {
 341         struct x509_parse_context *ctx = context;
 342
 343         switch (ctx->last_oid) {
 344         case OID_commonName:
 345                 ctx->cn_size = vlen;
 346                 ctx->cn_offset = (unsigned long)value - ctx->data;
 347                 break;
 348         case OID_organizationName:
 349                 ctx->o_size = vlen;
 350                 ctx->o_offset = (unsigned long)value - ctx->data;
 351                 break;
 352         case OID_email_address:
 353                 ctx->email_size = vlen;
 354                 ctx->email_offset = (unsigned long)value - ctx->data;
 355                 break;
 356         default:
 357                 break;
 358         }
 359
 360         return 0;
 361 }
 362
 363 /*
 364  * Fabricate and save the issuer and subject names
 365  */
 366 static int x509_fabricate_name(struct x509_parse_context *ctx, size_t hdrlen,
 367                                unsigned char tag,
 368                                char **_name, size_t vlen)
 369 {
 370         const void *name, *data = (const void *)ctx->data;
 371         size_t namesize;
 372         char *buffer;
 373
 374         if (*_name)
 375                 return -EINVAL;
 376
 377         /* Empty name string if no material */
 378         if (!ctx->cn_size && !ctx->o_size && !ctx->email_size) {
 379                 buffer = kmalloc(1, GFP_KERNEL);
 380                 if (!buffer)
 381                         return -ENOMEM;
 382                 buffer[0] = 0;
 383                 goto done;
 384         }
 385
 386         if (ctx->cn_size && ctx->o_size) {
 387                 /* Consider combining O and CN, but use only the CN if it is
 388                  * prefixed by the O, or a significant portion thereof.
 389                  */
 390                 namesize = ctx->cn_size;
 391                 name = data + ctx->cn_offset;
 392                 if (ctx->cn_size >= ctx->o_size &&
 393                     memcmp(data + ctx->cn_offset, data + ctx->o_offset,
 394                            ctx->o_size) == 0)
 395                         goto single_component;
 396                 if (ctx->cn_size >= 7 &&
 397                     ctx->o_size >= 7 &&
 398                     memcmp(data + ctx->cn_offset, data + ctx->o_offset, 7) == 0)
 399                         goto single_component;
 400
 401                 buffer = kmalloc(ctx->o_size + 2 + ctx->cn_size + 1,
 402                                  GFP_KERNEL);
 403                 if (!buffer)
 404                         return -ENOMEM;
 405
 406                 memcpy(buffer,
 407                        data + ctx->o_offset, ctx->o_size);
 408                 buffer[ctx->o_size + 0] = ':';
 409                 buffer[ctx->o_size + 1] = ' ';
 410                 memcpy(buffer + ctx->o_size + 2,
 411                        data + ctx->cn_offset, ctx->cn_size);
 412                 buffer[ctx->o_size + 2 + ctx->cn_size] = 0;
 413                 goto done;
 414
 415         } else if (ctx->cn_size) {
 416                 namesize = ctx->cn_size;
 417                 name = data + ctx->cn_offset;
 418         } else if (ctx->o_size) {
 419                 namesize = ctx->o_size;
 420                 name = data + ctx->o_offset;
 421         } else {
 422                 namesize = ctx->email_size;
 423                 name = data + ctx->email_offset;
 424         }
 425
 426 single_component:
 427         buffer = kmalloc(namesize + 1, GFP_KERNEL);
 428         if (!buffer)
 429                 return -ENOMEM;
 430         memcpy(buffer, name, namesize);
 431         buffer[namesize] = 0;
 432
 433 done:
 434         *_name = buffer;
 435         ctx->cn_size = 0;
 436         ctx->o_size = 0;
 437         ctx->email_size = 0;
 438         return 0;
 439 }
 440
 441 int x509_note_issuer(void *context, size_t hdrlen,
 442                      unsigned char tag,
 443                      const void *value, size_t vlen)
 444 {
 445         struct x509_parse_context *ctx = context;
 446         struct asymmetric_key_id *kid;
 447
 448         ctx->cert->raw_issuer = value;
 449         ctx->cert->raw_issuer_size = vlen;
 450
 451         if (!ctx->cert->sig->auth_ids[2]) {
 452                 kid = asymmetric_key_generate_id(value, vlen, "", 0);
 453                 if (IS_ERR(kid))
 454                         return PTR_ERR(kid);
 455                 ctx->cert->sig->auth_ids[2] = kid;
 456         }
 457
 458         return x509_fabricate_name(ctx, hdrlen, tag, &ctx->cert->issuer, vlen);
 459 }
 460
 461 int x509_note_subject(void *context, size_t hdrlen,
 462                       unsigned char tag,
 463                       const void *value, size_t vlen)
 464 {
 465         struct x509_parse_context *ctx = context;
 466         ctx->cert->raw_subject = value;
 467         ctx->cert->raw_subject_size = vlen;
 468         return x509_fabricate_name(ctx, hdrlen, tag, &ctx->cert->subject, vlen);
 469 }
 470
 471 /*
 472  * Extract the parameters for the public key
 473  */
 474 int x509_note_params(void *context, size_t hdrlen,
 475                      unsigned char tag,
 476                      const void *value, size_t vlen)
 477 {
 478         struct x509_parse_context *ctx = context;
 479
 480         /*
 481          * AlgorithmIdentifier is used three times in the x509, we should skip
 482          * first and ignore third, using second one which is after subject and
 483          * before subjectPublicKey.
 484          */
 485         if (!ctx->cert->raw_subject || ctx->key)
 486                 return 0;
 487         ctx->params = value - hdrlen;
 488         ctx->params_size = vlen + hdrlen;
 489         return 0;
 490 }
 491
 492 /*
 493  * Extract the data for the public key algorithm
 494  */
 495 int x509_extract_key_data(void *context, size_t hdrlen,
 496                           unsigned char tag,
 497                           const void *value, size_t vlen)
 498 {
 499         struct x509_parse_context *ctx = context;
 500         enum OID oid;
 501
 502         ctx->key_algo = ctx->last_oid;
 503         switch (ctx->last_oid) {
 504         case OID_rsaEncryption:
 505                 ctx->cert->pub->pkey_algo = "rsa";
 506                 break;
 507         case OID_gost2012PKey256:
 508         case OID_gost2012PKey512:
 509                 ctx->cert->pub->pkey_algo = "ecrdsa";
 510                 break;
 511         case OID_sm2:
 512                 ctx->cert->pub->pkey_algo = "sm2";
 513                 break;
 514         case OID_id_ecPublicKey:
 515                 if (parse_OID(ctx->params, ctx->params_size, &oid) != 0)
 516                         return -EBADMSG;
 517
 518                 switch (oid) {
 519                 case OID_sm2:
 520                         ctx->cert->pub->pkey_algo = "sm2";
 521                         break;
 522                 case OID_id_prime192v1:
 523                         ctx->cert->pub->pkey_algo = "ecdsa-nist-p192";
 524                         break;
 525                 case OID_id_prime256v1:
 526                         ctx->cert->pub->pkey_algo = "ecdsa-nist-p256";
 527                         break;
 528                 case OID_id_ansip384r1:
 529                         ctx->cert->pub->pkey_algo = "ecdsa-nist-p384";
 530                         break;
 531                 default:
 532                         return -ENOPKG;
 533                 }
 534                 break;
 535         default:
 536                 return -ENOPKG;
 537         }
 538
 539         /* Discard the BIT STRING metadata */
 540         if (vlen < 1 || *(const u8 *)value != 0)
 541                 return -EBADMSG;
 542         ctx->key = value + 1;
 543         ctx->key_size = vlen - 1;
 544         return 0;
 545 }
 546
 547 /* The keyIdentifier in AuthorityKeyIdentifier SEQUENCE is tag(CONT,PRIM,0) */
 548 #define SEQ_TAG_KEYID (ASN1_CONT << 6)
 549
 550 /*
 551  * Process certificate extensions that are used to qualify the certificate.
 552  */
 553 int x509_process_extension(void *context, size_t hdrlen,
 554                            unsigned char tag,
 555                            const void *value, size_t vlen)
 556 {
 557         struct x509_parse_context *ctx = context;
 558         struct asymmetric_key_id *kid;
 559         const unsigned char *v = value;
 560
 561         pr_debug("Extension: %u\n", ctx->last_oid);
 562
 563         if (ctx->last_oid == OID_subjectKeyIdentifier) {
 564                 /* Get hold of the key fingerprint */
 565                 if (ctx->cert->skid || vlen < 3)
 566                         return -EBADMSG;
 567                 if (v[0] != ASN1_OTS || v[1] != vlen - 2)
 568                         return -EBADMSG;
 569                 v += 2;
 570                 vlen -= 2;
 571
 572                 ctx->cert->raw_skid_size = vlen;
 573                 ctx->cert->raw_skid = v;
 574                 kid = asymmetric_key_generate_id(v, vlen, "", 0);
 575                 if (IS_ERR(kid))
 576                         return PTR_ERR(kid);
 577                 ctx->cert->skid = kid;
 578                 pr_debug("subjkeyid %*phN\n", kid->len, kid->data);
 579                 return 0;
 580         }
 581
 582         if (ctx->last_oid == OID_authorityKeyIdentifier) {
 583                 /* Get hold of the CA key fingerprint */
 584                 ctx->raw_akid = v;
 585                 ctx->raw_akid_size = vlen;
 586                 return 0;
 587         }
 588
 589         return 0;
 590 }
 591
 592 /**
 593  * x509_decode_time - Decode an X.509 time ASN.1 object
 594  * @_t: The time to fill in
 595  * @hdrlen: The length of the object header
 596  * @tag: The object tag
 597  * @value: The object value
 598  * @vlen: The size of the object value
 599  *
 600  * Decode an ASN.1 universal time or generalised time field into a struct the
 601  * kernel can handle and check it for validity.  The time is decoded thus:
 602  *
 603  *      [RFC5280 §4.1.2.5]
 604  *      CAs conforming to this profile MUST always encode certificate validity
 605  *      dates through the year 2049 as UTCTime; certificate validity dates in
 606  *      2050 or later MUST be encoded as GeneralizedTime.  Conforming
 607  *      applications MUST be able to process validity dates that are encoded in
 608  *      either UTCTime or GeneralizedTime.
 609  */
 610 int x509_decode_time(time64_t *_t,  size_t hdrlen,
 611                      unsigned char tag,
 612                      const unsigned char *value, size_t vlen)
 613 {
 614         static const unsigned char month_lengths[] = { 31, 28, 31, 30, 31, 30,
 615                                                        31, 31, 30, 31, 30, 31 };
 616         const unsigned char *p = value;
 617         unsigned year, mon, day, hour, min, sec, mon_len;
 618
 619 #define dec2bin(X) ({ unsigned char x = (X) - '0'; if (x > 9) goto invalid_time; x; })
 620 #define DD2bin(P) ({ unsigned x = dec2bin(P[0]) * 10 + dec2bin(P[1]); P += 2; x; })
 621
 622         if (tag == ASN1_UNITIM) {
 623                 /* UTCTime: YYMMDDHHMMSSZ */
 624                 if (vlen != 13)
 625                         goto unsupported_time;
 626                 year = DD2bin(p);
 627                 if (year >= 50)
 628                         year += 1900;
 629                 else
 630                         year += 2000;
 631         } else if (tag == ASN1_GENTIM) {
 632                 /* GenTime: YYYYMMDDHHMMSSZ */
 633                 if (vlen != 15)
 634                         goto unsupported_time;
 635                 year = DD2bin(p) * 100 + DD2bin(p);
 636                 if (year >= 1950 && year <= 2049)
 637                         goto invalid_time;
 638         } else {
 639                 goto unsupported_time;
 640         }
 641
 642         mon  = DD2bin(p);
 643         day = DD2bin(p);
 644         hour = DD2bin(p);
 645         min  = DD2bin(p);
 646         sec  = DD2bin(p);
 647
 648         if (*p != 'Z')
 649                 goto unsupported_time;
 650
 651         if (year < 1970 ||
 652             mon < 1 || mon > 12)
 653                 goto invalid_time;
 654
 655         mon_len = month_lengths[mon - 1];
 656         if (mon == 2) {
 657                 if (year % 4 == 0) {
 658                         mon_len = 29;
 659                         if (year % 100 == 0) {
 660                                 mon_len = 28;
 661                                 if (year % 400 == 0)
 662                                         mon_len = 29;
 663                         }
 664                 }
 665         }
 666
 667         if (day < 1 || day > mon_len ||
 668             hour > 24 || /* ISO 8601 permits 24:00:00 as midnight tomorrow */
 669             min > 59 ||
 670             sec > 60) /* ISO 8601 permits leap seconds [X.680 46.3] */
 671                 goto invalid_time;
 672
 673         *_t = mktime64(year, mon, day, hour, min, sec);
 674         return 0;
 675
 676 unsupported_time:
 677         pr_debug("Got unsupported time [tag %02x]: '%*phN'\n",
 678                  tag, (int)vlen, value);
 679         return -EBADMSG;
 680 invalid_time:
 681         pr_debug("Got invalid time [tag %02x]: '%*phN'\n",
 682                  tag, (int)vlen, value);
 683         return -EBADMSG;
 684 }
 685 EXPORT_SYMBOL_GPL(x509_decode_time);
 686
 687 int x509_note_not_before(void *context, size_t hdrlen,
 688                          unsigned char tag,
 689                          const void *value, size_t vlen)
 690 {
 691         struct x509_parse_context *ctx = context;
 692         return x509_decode_time(&ctx->cert->valid_from, hdrlen, tag, value, vlen);
 693 }
 694
 695 int x509_note_not_after(void *context, size_t hdrlen,
 696                         unsigned char tag,
 697                         const void *value, size_t vlen)
 698 {
 699         struct x509_parse_context *ctx = context;
 700         return x509_decode_time(&ctx->cert->valid_to, hdrlen, tag, value, vlen);
 701 }
 702
 703 /*
 704  * Note a key identifier-based AuthorityKeyIdentifier
 705  */
 706 int x509_akid_note_kid(void *context, size_t hdrlen,
 707                        unsigned char tag,
 708                        const void *value, size_t vlen)
 709 {
 710         struct x509_parse_context *ctx = context;
 711         struct asymmetric_key_id *kid;
 712
 713         pr_debug("AKID: keyid: %*phN\n", (int)vlen, value);
 714
 715         if (ctx->cert->sig->auth_ids[1])
 716                 return 0;
 717
 718         kid = asymmetric_key_generate_id(value, vlen, "", 0);
 719         if (IS_ERR(kid))
 720                 return PTR_ERR(kid);
 721         pr_debug("authkeyid %*phN\n", kid->len, kid->data);
 722         ctx->cert->sig->auth_ids[1] = kid;
 723         return 0;
 724 }
 725
 726 /*
 727  * Note a directoryName in an AuthorityKeyIdentifier
 728  */
 729 int x509_akid_note_name(void *context, size_t hdrlen,
 730                         unsigned char tag,
 731                         const void *value, size_t vlen)
 732 {
 733         struct x509_parse_context *ctx = context;
 734
 735         pr_debug("AKID: name: %*phN\n", (int)vlen, value);
 736
 737         ctx->akid_raw_issuer = value;
 738         ctx->akid_raw_issuer_size = vlen;
 739         return 0;
 740 }
 741
 742 /*
 743  * Note a serial number in an AuthorityKeyIdentifier
 744  */
 745 int x509_akid_note_serial(void *context, size_t hdrlen,
 746                           unsigned char tag,
 747                           const void *value, size_t vlen)
 748 {
 749         struct x509_parse_context *ctx = context;
 750         struct asymmetric_key_id *kid;
 751
 752         pr_debug("AKID: serial: %*phN\n", (int)vlen, value);
 753
 754         if (!ctx->akid_raw_issuer || ctx->cert->sig->auth_ids[0])
 755                 return 0;
 756
 757         kid = asymmetric_key_generate_id(value,
 758                                          vlen,
 759                                          ctx->akid_raw_issuer,
 760                                          ctx->akid_raw_issuer_size);
 761         if (IS_ERR(kid))
 762                 return PTR_ERR(kid);
 763
 764         pr_debug("authkeyid %*phN\n", kid->len, kid->data);
 765         ctx->cert->sig->auth_ids[0] = kid;
 766         return 0;
 767 }