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, 2016 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#define pr_fmt(fmt) "ASYM: "fmt
9#include <linux/module.h>
10#include <linux/kernel.h>
11#include <linux/err.h>
12#include <crypto/public_key.h>
13#include "asymmetric_keys.h"
14
15static bool use_builtin_keys;
16static struct asymmetric_key_id *ca_keyid;
17
18#ifndef MODULE
19static struct {
20	struct asymmetric_key_id id;
21	unsigned char data[10];
22} cakey;
23
24static int __init ca_keys_setup(char *str)
25{
26	if (!str)		/* default system keyring */
27		return 1;
28
29	if (strncmp(str, "id:", 3) == 0) {
30		struct asymmetric_key_id *p = &cakey.id;
31		size_t hexlen = (strlen(str) - 3) / 2;
32		int ret;
33
34		if (hexlen == 0 || hexlen > sizeof(cakey.data)) {
35			pr_err("Missing or invalid ca_keys id\n");
36			return 1;
37		}
38
39		ret = __asymmetric_key_hex_to_key_id(str + 3, p, hexlen);
40		if (ret < 0)
41			pr_err("Unparsable ca_keys id hex string\n");
42		else
43			ca_keyid = p;	/* owner key 'id:xxxxxx' */
44	} else if (strcmp(str, "builtin") == 0) {
45		use_builtin_keys = true;
46	}
47
48	return 1;
49}
50__setup("ca_keys=", ca_keys_setup);
51#endif
52
53/**
54 * restrict_link_by_signature - Restrict additions to a ring of public keys
55 * @dest_keyring: Keyring being linked to.
56 * @type: The type of key being added.
57 * @payload: The payload of the new key.
58 * @trust_keyring: A ring of keys that can be used to vouch for the new cert.
59 *
60 * Check the new certificate against the ones in the trust keyring.  If one of
61 * those is the signing key and validates the new certificate, then mark the
62 * new certificate as being trusted.
63 *
64 * Returns 0 if the new certificate was accepted, -ENOKEY if we couldn't find a
65 * matching parent certificate in the trusted list, -EKEYREJECTED if the
66 * signature check fails or the key is blacklisted, -ENOPKG if the signature
67 * uses unsupported crypto, or some other error if there is a matching
68 * certificate but the signature check cannot be performed.
69 */
70int restrict_link_by_signature(struct key *dest_keyring,
71			       const struct key_type *type,
72			       const union key_payload *payload,
73			       struct key *trust_keyring)
74{
75	const struct public_key_signature *sig;
76	struct key *key;
77	int ret;
78
79	pr_devel("==>%s()\n", __func__);
80
81	if (!trust_keyring)
82		return -ENOKEY;
83
84	if (type != &key_type_asymmetric)
85		return -EOPNOTSUPP;
86
87	sig = payload->data[asym_auth];
88	if (!sig)
89		return -ENOPKG;
90	if (!sig->auth_ids[0] && !sig->auth_ids[1] && !sig->auth_ids[2])
91		return -ENOKEY;
92
93	if (ca_keyid && !asymmetric_key_id_partial(sig->auth_ids[1], ca_keyid))
94		return -EPERM;
95
96	/* See if we have a key that signed this one. */
97	key = find_asymmetric_key(trust_keyring,
98				  sig->auth_ids[0], sig->auth_ids[1],
99				  sig->auth_ids[2], false);
100	if (IS_ERR(key))
101		return -ENOKEY;
102
103	if (use_builtin_keys && !test_bit(KEY_FLAG_BUILTIN, &key->flags))
104		ret = -ENOKEY;
105	else
106		ret = verify_signature(key, sig);
107	key_put(key);
108	return ret;
109}
110
111/**
112 * restrict_link_by_ca - Restrict additions to a ring of CA keys
113 * @dest_keyring: Keyring being linked to.
114 * @type: The type of key being added.
115 * @payload: The payload of the new key.
116 * @trust_keyring: Unused.
117 *
118 * Check if the new certificate is a CA. If it is a CA, then mark the new
119 * certificate as being ok to link.
120 *
121 * Returns 0 if the new certificate was accepted, -ENOKEY if the
122 * certificate is not a CA. -ENOPKG if the signature uses unsupported
123 * crypto, or some other error if there is a matching certificate but
124 * the signature check cannot be performed.
125 */
126int restrict_link_by_ca(struct key *dest_keyring,
127			const struct key_type *type,
128			const union key_payload *payload,
129			struct key *trust_keyring)
130{
131	const struct public_key *pkey;
132
133	if (type != &key_type_asymmetric)
134		return -EOPNOTSUPP;
135
136	pkey = payload->data[asym_crypto];
137	if (!pkey)
138		return -ENOPKG;
139	if (!test_bit(KEY_EFLAG_CA, &pkey->key_eflags))
140		return -ENOKEY;
141	if (!test_bit(KEY_EFLAG_KEYCERTSIGN, &pkey->key_eflags))
142		return -ENOKEY;
143	if (!IS_ENABLED(CONFIG_INTEGRITY_CA_MACHINE_KEYRING_MAX))
144		return 0;
145	if (test_bit(KEY_EFLAG_DIGITALSIG, &pkey->key_eflags))
146		return -ENOKEY;
147
148	return 0;
149}
150
151/**
152 * restrict_link_by_digsig - Restrict additions to a ring of digsig keys
153 * @dest_keyring: Keyring being linked to.
154 * @type: The type of key being added.
155 * @payload: The payload of the new key.
156 * @trust_keyring: A ring of keys that can be used to vouch for the new cert.
157 *
158 * Check if the new certificate has digitalSignature usage set. If it is,
159 * then mark the new certificate as being ok to link. Afterwards verify
160 * the new certificate against the ones in the trust_keyring.
161 *
162 * Returns 0 if the new certificate was accepted, -ENOKEY if the
163 * certificate is not a digsig. -ENOPKG if the signature uses unsupported
164 * crypto, or some other error if there is a matching certificate but
165 * the signature check cannot be performed.
166 */
167int restrict_link_by_digsig(struct key *dest_keyring,
168			    const struct key_type *type,
169			    const union key_payload *payload,
170			    struct key *trust_keyring)
171{
172	const struct public_key *pkey;
173
174	if (type != &key_type_asymmetric)
175		return -EOPNOTSUPP;
176
177	pkey = payload->data[asym_crypto];
178
179	if (!pkey)
180		return -ENOPKG;
181
182	if (!test_bit(KEY_EFLAG_DIGITALSIG, &pkey->key_eflags))
183		return -ENOKEY;
184
185	if (test_bit(KEY_EFLAG_CA, &pkey->key_eflags))
186		return -ENOKEY;
187
188	if (test_bit(KEY_EFLAG_KEYCERTSIGN, &pkey->key_eflags))
189		return -ENOKEY;
190
191	return restrict_link_by_signature(dest_keyring, type, payload,
192					  trust_keyring);
193}
194
195static bool match_either_id(const struct asymmetric_key_id **pair,
196			    const struct asymmetric_key_id *single)
197{
198	return (asymmetric_key_id_same(pair[0], single) ||
199		asymmetric_key_id_same(pair[1], single));
200}
201
202static int key_or_keyring_common(struct key *dest_keyring,
203				 const struct key_type *type,
204				 const union key_payload *payload,
205				 struct key *trusted, bool check_dest)
206{
207	const struct public_key_signature *sig;
208	struct key *key = NULL;
209	int ret;
210
211	pr_devel("==>%s()\n", __func__);
212
213	if (!dest_keyring)
214		return -ENOKEY;
215	else if (dest_keyring->type != &key_type_keyring)
216		return -EOPNOTSUPP;
217
218	if (!trusted && !check_dest)
219		return -ENOKEY;
220
221	if (type != &key_type_asymmetric)
222		return -EOPNOTSUPP;
223
224	sig = payload->data[asym_auth];
225	if (!sig)
226		return -ENOPKG;
227	if (!sig->auth_ids[0] && !sig->auth_ids[1] && !sig->auth_ids[2])
228		return -ENOKEY;
229
230	if (trusted) {
231		if (trusted->type == &key_type_keyring) {
232			/* See if we have a key that signed this one. */
233			key = find_asymmetric_key(trusted, sig->auth_ids[0],
234						  sig->auth_ids[1],
235						  sig->auth_ids[2], false);
236			if (IS_ERR(key))
237				key = NULL;
238		} else if (trusted->type == &key_type_asymmetric) {
239			const struct asymmetric_key_id **signer_ids;
240
241			signer_ids = (const struct asymmetric_key_id **)
242				asymmetric_key_ids(trusted)->id;
243
244			/*
245			 * The auth_ids come from the candidate key (the
246			 * one that is being considered for addition to
247			 * dest_keyring) and identify the key that was
248			 * used to sign.
249			 *
250			 * The signer_ids are identifiers for the
251			 * signing key specified for dest_keyring.
252			 *
253			 * The first auth_id is the preferred id, 2nd and
254			 * 3rd are the fallbacks. If exactly one of
255			 * auth_ids[0] and auth_ids[1] is present, it may
256			 * match either signer_ids[0] or signed_ids[1].
257			 * If both are present the first one may match
258			 * either signed_id but the second one must match
259			 * the second signer_id. If neither of them is
260			 * available, auth_ids[2] is matched against
261			 * signer_ids[2] as a fallback.
262			 */
263			if (!sig->auth_ids[0] && !sig->auth_ids[1]) {
264				if (asymmetric_key_id_same(signer_ids[2],
265							   sig->auth_ids[2]))
266					key = __key_get(trusted);
267
268			} else if (!sig->auth_ids[0] || !sig->auth_ids[1]) {
269				const struct asymmetric_key_id *auth_id;
270
271				auth_id = sig->auth_ids[0] ?: sig->auth_ids[1];
272				if (match_either_id(signer_ids, auth_id))
273					key = __key_get(trusted);
274
275			} else if (asymmetric_key_id_same(signer_ids[1],
276							  sig->auth_ids[1]) &&
277				   match_either_id(signer_ids,
278						   sig->auth_ids[0])) {
279				key = __key_get(trusted);
280			}
281		} else {
282			return -EOPNOTSUPP;
283		}
284	}
285
286	if (check_dest && !key) {
287		/* See if the destination has a key that signed this one. */
288		key = find_asymmetric_key(dest_keyring, sig->auth_ids[0],
289					  sig->auth_ids[1], sig->auth_ids[2],
290					  false);
291		if (IS_ERR(key))
292			key = NULL;
293	}
294
295	if (!key)
296		return -ENOKEY;
297
298	ret = key_validate(key);
299	if (ret == 0)
300		ret = verify_signature(key, sig);
301
302	key_put(key);
303	return ret;
304}
305
306/**
307 * restrict_link_by_key_or_keyring - Restrict additions to a ring of public
308 * keys using the restrict_key information stored in the ring.
309 * @dest_keyring: Keyring being linked to.
310 * @type: The type of key being added.
311 * @payload: The payload of the new key.
312 * @trusted: A key or ring of keys that can be used to vouch for the new cert.
313 *
314 * Check the new certificate only against the key or keys passed in the data
315 * parameter. If one of those is the signing key and validates the new
316 * certificate, then mark the new certificate as being ok to link.
317 *
318 * Returns 0 if the new certificate was accepted, -ENOKEY if we
319 * couldn't find a matching parent certificate in the trusted list,
320 * -EKEYREJECTED if the signature check fails, -ENOPKG if the signature uses
321 * unsupported crypto, or some other error if there is a matching certificate
322 * but the signature check cannot be performed.
323 */
324int restrict_link_by_key_or_keyring(struct key *dest_keyring,
325				    const struct key_type *type,
326				    const union key_payload *payload,
327				    struct key *trusted)
328{
329	return key_or_keyring_common(dest_keyring, type, payload, trusted,
330				     false);
331}
332
333/**
334 * restrict_link_by_key_or_keyring_chain - Restrict additions to a ring of
335 * public keys using the restrict_key information stored in the ring.
336 * @dest_keyring: Keyring being linked to.
337 * @type: The type of key being added.
338 * @payload: The payload of the new key.
339 * @trusted: A key or ring of keys that can be used to vouch for the new cert.
340 *
341 * Check the new certificate against the key or keys passed in the data
342 * parameter and against the keys already linked to the destination keyring. If
343 * one of those is the signing key and validates the new certificate, then mark
344 * the new certificate as being ok to link.
345 *
346 * Returns 0 if the new certificate was accepted, -ENOKEY if we
347 * couldn't find a matching parent certificate in the trusted list,
348 * -EKEYREJECTED if the signature check fails, -ENOPKG if the signature uses
349 * unsupported crypto, or some other error if there is a matching certificate
350 * but the signature check cannot be performed.
351 */
352int restrict_link_by_key_or_keyring_chain(struct key *dest_keyring,
353					  const struct key_type *type,
354					  const union key_payload *payload,
355					  struct key *trusted)
356{
357	return key_or_keyring_common(dest_keyring, type, payload, trusted,
358				     true);
359}
360