1// SPDX-License-Identifier: GPL-2.0-or-later
2/* Instantiate a public key crypto key from an X.509 Certificate
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/module.h>
10#include <linux/kernel.h>
11#include <linux/slab.h>
12#include <keys/asymmetric-subtype.h>
13#include <keys/asymmetric-parser.h>
14#include <keys/system_keyring.h>
15#include <crypto/hash.h>
16#include "asymmetric_keys.h"
17#include "x509_parser.h"
18
19/*
20 * Set up the signature parameters in an X.509 certificate.  This involves
21 * digesting the signed data and extracting the signature.
22 */
23int x509_get_sig_params(struct x509_certificate *cert)
24{
25	struct public_key_signature *sig = cert->sig;
26	struct crypto_shash *tfm;
27	struct shash_desc *desc;
28	size_t desc_size;
29	int ret;
30
31	pr_devel("==>%s()\n", __func__);
32
33	sig->data = cert->tbs;
34	sig->data_size = cert->tbs_size;
35
36	if (!cert->pub->pkey_algo)
37		cert->unsupported_key = true;
38
39	if (!sig->pkey_algo)
40		cert->unsupported_sig = true;
41
42	/* We check the hash if we can - even if we can't then verify it */
43	if (!sig->hash_algo) {
44		cert->unsupported_sig = true;
45		return 0;
46	}
47
48	sig->s = kmemdup(cert->raw_sig, cert->raw_sig_size, GFP_KERNEL);
49	if (!sig->s)
50		return -ENOMEM;
51
52	sig->s_size = cert->raw_sig_size;
53
54	/* Allocate the hashing algorithm we're going to need and find out how
55	 * big the hash operational data will be.
56	 */
57	tfm = crypto_alloc_shash(sig->hash_algo, 0, 0);
58	if (IS_ERR(tfm)) {
59		if (PTR_ERR(tfm) == -ENOENT) {
60			cert->unsupported_sig = true;
61			return 0;
62		}
63		return PTR_ERR(tfm);
64	}
65
66	desc_size = crypto_shash_descsize(tfm) + sizeof(*desc);
67	sig->digest_size = crypto_shash_digestsize(tfm);
68
69	ret = -ENOMEM;
70	sig->digest = kmalloc(sig->digest_size, GFP_KERNEL);
71	if (!sig->digest)
72		goto error;
73
74	desc = kzalloc(desc_size, GFP_KERNEL);
75	if (!desc)
76		goto error;
77
78	desc->tfm = tfm;
79
80	ret = crypto_shash_digest(desc, cert->tbs, cert->tbs_size, sig->digest);
81	if (ret < 0)
82		goto error_2;
83
84	ret = is_hash_blacklisted(sig->digest, sig->digest_size, "tbs");
85	if (ret == -EKEYREJECTED) {
86		pr_err("Cert %*phN is blacklisted\n",
87		       sig->digest_size, sig->digest);
88		cert->blacklisted = true;
89		ret = 0;
90	}
91
92error_2:
93	kfree(desc);
94error:
95	crypto_free_shash(tfm);
96	pr_devel("<==%s() = %d\n", __func__, ret);
97	return ret;
98}
99
100/*
101 * Check for self-signedness in an X.509 cert and if found, check the signature
102 * immediately if we can.
103 */
104int x509_check_for_self_signed(struct x509_certificate *cert)
105{
106	int ret = 0;
107
108	pr_devel("==>%s()\n", __func__);
109
110	if (cert->raw_subject_size != cert->raw_issuer_size ||
111	    memcmp(cert->raw_subject, cert->raw_issuer,
112		   cert->raw_issuer_size) != 0)
113		goto not_self_signed;
114
115	if (cert->sig->auth_ids[0] || cert->sig->auth_ids[1]) {
116		/* If the AKID is present it may have one or two parts.  If
117		 * both are supplied, both must match.
118		 */
119		bool a = asymmetric_key_id_same(cert->skid, cert->sig->auth_ids[1]);
120		bool b = asymmetric_key_id_same(cert->id, cert->sig->auth_ids[0]);
121
122		if (!a && !b)
123			goto not_self_signed;
124
125		ret = -EKEYREJECTED;
126		if (((a && !b) || (b && !a)) &&
127		    cert->sig->auth_ids[0] && cert->sig->auth_ids[1])
128			goto out;
129	}
130
131	if (cert->unsupported_sig) {
132		ret = 0;
133		goto out;
134	}
135
136	ret = public_key_verify_signature(cert->pub, cert->sig);
137	if (ret < 0) {
138		if (ret == -ENOPKG) {
139			cert->unsupported_sig = true;
140			ret = 0;
141		}
142		goto out;
143	}
144
145	pr_devel("Cert Self-signature verified");
146	cert->self_signed = true;
147
148out:
149	pr_devel("<==%s() = %d\n", __func__, ret);
150	return ret;
151
152not_self_signed:
153	pr_devel("<==%s() = 0 [not]\n", __func__);
154	return 0;
155}
156
157/*
158 * Attempt to parse a data blob for a key as an X509 certificate.
159 */
160static int x509_key_preparse(struct key_preparsed_payload *prep)
161{
162	struct asymmetric_key_ids *kids;
163	struct x509_certificate *cert;
164	const char *q;
165	size_t srlen, sulen;
166	char *desc = NULL, *p;
167	int ret;
168
169	cert = x509_cert_parse(prep->data, prep->datalen);
170	if (IS_ERR(cert))
171		return PTR_ERR(cert);
172
173	pr_devel("Cert Issuer: %s\n", cert->issuer);
174	pr_devel("Cert Subject: %s\n", cert->subject);
175
176	if (cert->unsupported_key) {
177		ret = -ENOPKG;
178		goto error_free_cert;
179	}
180
181	pr_devel("Cert Key Algo: %s\n", cert->pub->pkey_algo);
182	pr_devel("Cert Valid period: %lld-%lld\n", cert->valid_from, cert->valid_to);
183
184	cert->pub->id_type = "X509";
185
186	if (cert->unsupported_sig) {
187		public_key_signature_free(cert->sig);
188		cert->sig = NULL;
189	} else {
190		pr_devel("Cert Signature: %s + %s\n",
191			 cert->sig->pkey_algo, cert->sig->hash_algo);
192	}
193
194	/* Don't permit addition of blacklisted keys */
195	ret = -EKEYREJECTED;
196	if (cert->blacklisted)
197		goto error_free_cert;
198
199	/* Propose a description */
200	sulen = strlen(cert->subject);
201	if (cert->raw_skid) {
202		srlen = cert->raw_skid_size;
203		q = cert->raw_skid;
204	} else {
205		srlen = cert->raw_serial_size;
206		q = cert->raw_serial;
207	}
208
209	ret = -ENOMEM;
210	desc = kmalloc(sulen + 2 + srlen * 2 + 1, GFP_KERNEL);
211	if (!desc)
212		goto error_free_cert;
213	p = memcpy(desc, cert->subject, sulen);
214	p += sulen;
215	*p++ = ':';
216	*p++ = ' ';
217	p = bin2hex(p, q, srlen);
218	*p = 0;
219
220	kids = kmalloc(sizeof(struct asymmetric_key_ids), GFP_KERNEL);
221	if (!kids)
222		goto error_free_desc;
223	kids->id[0] = cert->id;
224	kids->id[1] = cert->skid;
225
226	/* We're pinning the module by being linked against it */
227	__module_get(public_key_subtype.owner);
228	prep->payload.data[asym_subtype] = &public_key_subtype;
229	prep->payload.data[asym_key_ids] = kids;
230	prep->payload.data[asym_crypto] = cert->pub;
231	prep->payload.data[asym_auth] = cert->sig;
232	prep->description = desc;
233	prep->quotalen = 100;
234
235	/* We've finished with the certificate */
236	cert->pub = NULL;
237	cert->id = NULL;
238	cert->skid = NULL;
239	cert->sig = NULL;
240	desc = NULL;
241	ret = 0;
242
243error_free_desc:
244	kfree(desc);
245error_free_cert:
246	x509_free_certificate(cert);
247	return ret;
248}
249
250static struct asymmetric_key_parser x509_key_parser = {
251	.owner	= THIS_MODULE,
252	.name	= "x509",
253	.parse	= x509_key_preparse,
254};
255
256/*
257 * Module stuff
258 */
259static int __init x509_key_init(void)
260{
261	return register_asymmetric_key_parser(&x509_key_parser);
262}
263
264static void __exit x509_key_exit(void)
265{
266	unregister_asymmetric_key_parser(&x509_key_parser);
267}
268
269module_init(x509_key_init);
270module_exit(x509_key_exit);
271
272MODULE_DESCRIPTION("X.509 certificate parser");
273MODULE_AUTHOR("Red Hat, Inc.");
274MODULE_LICENSE("GPL");
275