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");
181
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.