Merge tag '9p-for-5.20' of https://github.com/martinetd/linux
[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_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 }