GNU Linux-libre 5.10.219-gnu1
[releases.git] / crypto / asymmetric_keys / pkcs8_parser.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* PKCS#8 Private Key parser [RFC 5208].
3  *
4  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7
8 #define pr_fmt(fmt) "PKCS8: "fmt
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/export.h>
12 #include <linux/slab.h>
13 #include <linux/err.h>
14 #include <linux/oid_registry.h>
15 #include <keys/asymmetric-subtype.h>
16 #include <keys/asymmetric-parser.h>
17 #include <crypto/public_key.h>
18 #include "pkcs8.asn1.h"
19
20 struct pkcs8_parse_context {
21         struct public_key *pub;
22         unsigned long   data;                   /* Start of data */
23         enum OID        last_oid;               /* Last OID encountered */
24         enum OID        algo_oid;               /* Algorithm OID */
25         u32             key_size;
26         const void      *key;
27 };
28
29 /*
30  * Note an OID when we find one for later processing when we know how to
31  * interpret it.
32  */
33 int pkcs8_note_OID(void *context, size_t hdrlen,
34                    unsigned char tag,
35                    const void *value, size_t vlen)
36 {
37         struct pkcs8_parse_context *ctx = context;
38
39         ctx->last_oid = look_up_OID(value, vlen);
40         if (ctx->last_oid == OID__NR) {
41                 char buffer[50];
42
43                 sprint_oid(value, vlen, buffer, sizeof(buffer));
44                 pr_info("Unknown OID: [%lu] %s\n",
45                         (unsigned long)value - ctx->data, buffer);
46         }
47         return 0;
48 }
49
50 /*
51  * Note the version number of the ASN.1 blob.
52  */
53 int pkcs8_note_version(void *context, size_t hdrlen,
54                        unsigned char tag,
55                        const void *value, size_t vlen)
56 {
57         if (vlen != 1 || ((const u8 *)value)[0] != 0) {
58                 pr_warn("Unsupported PKCS#8 version\n");
59                 return -EBADMSG;
60         }
61         return 0;
62 }
63
64 /*
65  * Note the public algorithm.
66  */
67 int pkcs8_note_algo(void *context, size_t hdrlen,
68                     unsigned char tag,
69                     const void *value, size_t vlen)
70 {
71         struct pkcs8_parse_context *ctx = context;
72
73         if (ctx->last_oid != OID_rsaEncryption)
74                 return -ENOPKG;
75
76         ctx->pub->pkey_algo = "rsa";
77         return 0;
78 }
79
80 /*
81  * Note the key data of the ASN.1 blob.
82  */
83 int pkcs8_note_key(void *context, size_t hdrlen,
84                    unsigned char tag,
85                    const void *value, size_t vlen)
86 {
87         struct pkcs8_parse_context *ctx = context;
88
89         ctx->key = value;
90         ctx->key_size = vlen;
91         return 0;
92 }
93
94 /*
95  * Parse a PKCS#8 private key blob.
96  */
97 static struct public_key *pkcs8_parse(const void *data, size_t datalen)
98 {
99         struct pkcs8_parse_context ctx;
100         struct public_key *pub;
101         long ret;
102
103         memset(&ctx, 0, sizeof(ctx));
104
105         ret = -ENOMEM;
106         ctx.pub = kzalloc(sizeof(struct public_key), GFP_KERNEL);
107         if (!ctx.pub)
108                 goto error;
109
110         ctx.data = (unsigned long)data;
111
112         /* Attempt to decode the private key */
113         ret = asn1_ber_decoder(&pkcs8_decoder, &ctx, data, datalen);
114         if (ret < 0)
115                 goto error_decode;
116
117         ret = -ENOMEM;
118         pub = ctx.pub;
119         pub->key = kmemdup(ctx.key, ctx.key_size, GFP_KERNEL);
120         if (!pub->key)
121                 goto error_decode;
122
123         pub->keylen = ctx.key_size;
124         pub->key_is_private = true;
125         return pub;
126
127 error_decode:
128         kfree(ctx.pub);
129 error:
130         return ERR_PTR(ret);
131 }
132
133 /*
134  * Attempt to parse a data blob for a key as a PKCS#8 private key.
135  */
136 static int pkcs8_key_preparse(struct key_preparsed_payload *prep)
137 {
138         struct public_key *pub;
139
140         pub = pkcs8_parse(prep->data, prep->datalen);
141         if (IS_ERR(pub))
142                 return PTR_ERR(pub);
143
144         pr_devel("Cert Key Algo: %s\n", pub->pkey_algo);
145         pub->id_type = "PKCS8";
146
147         /* We're pinning the module by being linked against it */
148         __module_get(public_key_subtype.owner);
149         prep->payload.data[asym_subtype] = &public_key_subtype;
150         prep->payload.data[asym_key_ids] = NULL;
151         prep->payload.data[asym_crypto] = pub;
152         prep->payload.data[asym_auth] = NULL;
153         prep->quotalen = 100;
154         return 0;
155 }
156
157 static struct asymmetric_key_parser pkcs8_key_parser = {
158         .owner  = THIS_MODULE,
159         .name   = "pkcs8",
160         .parse  = pkcs8_key_preparse,
161 };
162
163 /*
164  * Module stuff
165  */
166 static int __init pkcs8_key_init(void)
167 {
168         return register_asymmetric_key_parser(&pkcs8_key_parser);
169 }
170
171 static void __exit pkcs8_key_exit(void)
172 {
173         unregister_asymmetric_key_parser(&pkcs8_key_parser);
174 }
175
176 module_init(pkcs8_key_init);
177 module_exit(pkcs8_key_exit);
178
179 MODULE_DESCRIPTION("PKCS#8 certificate parser");
180 MODULE_LICENSE("GPL");