Merge tag 'amd-drm-next-5.19-2022-04-22' of https://gitlab.freedesktop.org/agd5f...
[linux-2.6-microblaze.git] / 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_id_ecPublicKey:
512                 if (parse_OID(ctx->params, ctx->params_size, &oid) != 0)
513                         return -EBADMSG;
514
515                 switch (oid) {
516                 case OID_sm2:
517                         ctx->cert->pub->pkey_algo = "sm2";
518                         break;
519                 case OID_id_prime192v1:
520                         ctx->cert->pub->pkey_algo = "ecdsa-nist-p192";
521                         break;
522                 case OID_id_prime256v1:
523                         ctx->cert->pub->pkey_algo = "ecdsa-nist-p256";
524                         break;
525                 case OID_id_ansip384r1:
526                         ctx->cert->pub->pkey_algo = "ecdsa-nist-p384";
527                         break;
528                 default:
529                         return -ENOPKG;
530                 }
531                 break;
532         default:
533                 return -ENOPKG;
534         }
535
536         /* Discard the BIT STRING metadata */
537         if (vlen < 1 || *(const u8 *)value != 0)
538                 return -EBADMSG;
539         ctx->key = value + 1;
540         ctx->key_size = vlen - 1;
541         return 0;
542 }
543
544 /* The keyIdentifier in AuthorityKeyIdentifier SEQUENCE is tag(CONT,PRIM,0) */
545 #define SEQ_TAG_KEYID (ASN1_CONT << 6)
546
547 /*
548  * Process certificate extensions that are used to qualify the certificate.
549  */
550 int x509_process_extension(void *context, size_t hdrlen,
551                            unsigned char tag,
552                            const void *value, size_t vlen)
553 {
554         struct x509_parse_context *ctx = context;
555         struct asymmetric_key_id *kid;
556         const unsigned char *v = value;
557
558         pr_debug("Extension: %u\n", ctx->last_oid);
559
560         if (ctx->last_oid == OID_subjectKeyIdentifier) {
561                 /* Get hold of the key fingerprint */
562                 if (ctx->cert->skid || vlen < 3)
563                         return -EBADMSG;
564                 if (v[0] != ASN1_OTS || v[1] != vlen - 2)
565                         return -EBADMSG;
566                 v += 2;
567                 vlen -= 2;
568
569                 ctx->cert->raw_skid_size = vlen;
570                 ctx->cert->raw_skid = v;
571                 kid = asymmetric_key_generate_id(v, vlen, "", 0);
572                 if (IS_ERR(kid))
573                         return PTR_ERR(kid);
574                 ctx->cert->skid = kid;
575                 pr_debug("subjkeyid %*phN\n", kid->len, kid->data);
576                 return 0;
577         }
578
579         if (ctx->last_oid == OID_authorityKeyIdentifier) {
580                 /* Get hold of the CA key fingerprint */
581                 ctx->raw_akid = v;
582                 ctx->raw_akid_size = vlen;
583                 return 0;
584         }
585
586         return 0;
587 }
588
589 /**
590  * x509_decode_time - Decode an X.509 time ASN.1 object
591  * @_t: The time to fill in
592  * @hdrlen: The length of the object header
593  * @tag: The object tag
594  * @value: The object value
595  * @vlen: The size of the object value
596  *
597  * Decode an ASN.1 universal time or generalised time field into a struct the
598  * kernel can handle and check it for validity.  The time is decoded thus:
599  *
600  *      [RFC5280 ยง4.1.2.5]
601  *      CAs conforming to this profile MUST always encode certificate validity
602  *      dates through the year 2049 as UTCTime; certificate validity dates in
603  *      2050 or later MUST be encoded as GeneralizedTime.  Conforming
604  *      applications MUST be able to process validity dates that are encoded in
605  *      either UTCTime or GeneralizedTime.
606  */
607 int x509_decode_time(time64_t *_t,  size_t hdrlen,
608                      unsigned char tag,
609                      const unsigned char *value, size_t vlen)
610 {
611         static const unsigned char month_lengths[] = { 31, 28, 31, 30, 31, 30,
612                                                        31, 31, 30, 31, 30, 31 };
613         const unsigned char *p = value;
614         unsigned year, mon, day, hour, min, sec, mon_len;
615
616 #define dec2bin(X) ({ unsigned char x = (X) - '0'; if (x > 9) goto invalid_time; x; })
617 #define DD2bin(P) ({ unsigned x = dec2bin(P[0]) * 10 + dec2bin(P[1]); P += 2; x; })
618
619         if (tag == ASN1_UNITIM) {
620                 /* UTCTime: YYMMDDHHMMSSZ */
621                 if (vlen != 13)
622                         goto unsupported_time;
623                 year = DD2bin(p);
624                 if (year >= 50)
625                         year += 1900;
626                 else
627                         year += 2000;
628         } else if (tag == ASN1_GENTIM) {
629                 /* GenTime: YYYYMMDDHHMMSSZ */
630                 if (vlen != 15)
631                         goto unsupported_time;
632                 year = DD2bin(p) * 100 + DD2bin(p);
633                 if (year >= 1950 && year <= 2049)
634                         goto invalid_time;
635         } else {
636                 goto unsupported_time;
637         }
638
639         mon  = DD2bin(p);
640         day = DD2bin(p);
641         hour = DD2bin(p);
642         min  = DD2bin(p);
643         sec  = DD2bin(p);
644
645         if (*p != 'Z')
646                 goto unsupported_time;
647
648         if (year < 1970 ||
649             mon < 1 || mon > 12)
650                 goto invalid_time;
651
652         mon_len = month_lengths[mon - 1];
653         if (mon == 2) {
654                 if (year % 4 == 0) {
655                         mon_len = 29;
656                         if (year % 100 == 0) {
657                                 mon_len = 28;
658                                 if (year % 400 == 0)
659                                         mon_len = 29;
660                         }
661                 }
662         }
663
664         if (day < 1 || day > mon_len ||
665             hour > 24 || /* ISO 8601 permits 24:00:00 as midnight tomorrow */
666             min > 59 ||
667             sec > 60) /* ISO 8601 permits leap seconds [X.680 46.3] */
668                 goto invalid_time;
669
670         *_t = mktime64(year, mon, day, hour, min, sec);
671         return 0;
672
673 unsupported_time:
674         pr_debug("Got unsupported time [tag %02x]: '%*phN'\n",
675                  tag, (int)vlen, value);
676         return -EBADMSG;
677 invalid_time:
678         pr_debug("Got invalid time [tag %02x]: '%*phN'\n",
679                  tag, (int)vlen, value);
680         return -EBADMSG;
681 }
682 EXPORT_SYMBOL_GPL(x509_decode_time);
683
684 int x509_note_not_before(void *context, size_t hdrlen,
685                          unsigned char tag,
686                          const void *value, size_t vlen)
687 {
688         struct x509_parse_context *ctx = context;
689         return x509_decode_time(&ctx->cert->valid_from, hdrlen, tag, value, vlen);
690 }
691
692 int x509_note_not_after(void *context, size_t hdrlen,
693                         unsigned char tag,
694                         const void *value, size_t vlen)
695 {
696         struct x509_parse_context *ctx = context;
697         return x509_decode_time(&ctx->cert->valid_to, hdrlen, tag, value, vlen);
698 }
699
700 /*
701  * Note a key identifier-based AuthorityKeyIdentifier
702  */
703 int x509_akid_note_kid(void *context, size_t hdrlen,
704                        unsigned char tag,
705                        const void *value, size_t vlen)
706 {
707         struct x509_parse_context *ctx = context;
708         struct asymmetric_key_id *kid;
709
710         pr_debug("AKID: keyid: %*phN\n", (int)vlen, value);
711
712         if (ctx->cert->sig->auth_ids[1])
713                 return 0;
714
715         kid = asymmetric_key_generate_id(value, vlen, "", 0);
716         if (IS_ERR(kid))
717                 return PTR_ERR(kid);
718         pr_debug("authkeyid %*phN\n", kid->len, kid->data);
719         ctx->cert->sig->auth_ids[1] = kid;
720         return 0;
721 }
722
723 /*
724  * Note a directoryName in an AuthorityKeyIdentifier
725  */
726 int x509_akid_note_name(void *context, size_t hdrlen,
727                         unsigned char tag,
728                         const void *value, size_t vlen)
729 {
730         struct x509_parse_context *ctx = context;
731
732         pr_debug("AKID: name: %*phN\n", (int)vlen, value);
733
734         ctx->akid_raw_issuer = value;
735         ctx->akid_raw_issuer_size = vlen;
736         return 0;
737 }
738
739 /*
740  * Note a serial number in an AuthorityKeyIdentifier
741  */
742 int x509_akid_note_serial(void *context, size_t hdrlen,
743                           unsigned char tag,
744                           const void *value, size_t vlen)
745 {
746         struct x509_parse_context *ctx = context;
747         struct asymmetric_key_id *kid;
748
749         pr_debug("AKID: serial: %*phN\n", (int)vlen, value);
750
751         if (!ctx->akid_raw_issuer || ctx->cert->sig->auth_ids[0])
752                 return 0;
753
754         kid = asymmetric_key_generate_id(value,
755                                          vlen,
756                                          ctx->akid_raw_issuer,
757                                          ctx->akid_raw_issuer_size);
758         if (IS_ERR(kid))
759                 return PTR_ERR(kid);
760
761         pr_debug("authkeyid %*phN\n", kid->len, kid->data);
762         ctx->cert->sig->auth_ids[0] = kid;
763         return 0;
764 }