1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2013 Intel Corporation
4  *
5  * Author:
6  * Dmitry Kasatkin <dmitry.kasatkin@intel.com>
7  */
8 
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 
11 #include <linux/err.h>
12 #include <linux/ratelimit.h>
13 #include <linux/key-type.h>
14 #include <crypto/public_key.h>
15 #include <crypto/hash_info.h>
16 #include <keys/asymmetric-type.h>
17 #include <keys/system_keyring.h>
18 
19 #include "integrity.h"
20 
21 /*
22  * Request an asymmetric key.
23  */
24 static struct key *request_asymmetric_key(struct key *keyring, uint32_t keyid)
25 {
26 	struct key *key;
27 	char name[12];
28 
29 	sprintf(name, "id:%08x", keyid);
30 
31 	pr_debug("key search: \"%s\"\n", name);
32 
33 	key = get_ima_blacklist_keyring();
34 	if (key) {
35 		key_ref_t kref;
36 
37 		kref = keyring_search(make_key_ref(key, 1),
38 				      &key_type_asymmetric, name, true);
39 		if (!IS_ERR(kref)) {
40 			pr_err("Key '%s' is in ima_blacklist_keyring\n", name);
41 			return ERR_PTR(-EKEYREJECTED);
42 		}
43 	}
44 
45 	if (keyring) {
46 		/* search in specific keyring */
47 		key_ref_t kref;
48 
49 		kref = keyring_search(make_key_ref(keyring, 1),
50 				      &key_type_asymmetric, name, true);
51 		if (IS_ERR(kref))
52 			key = ERR_CAST(kref);
53 		else
54 			key = key_ref_to_ptr(kref);
55 	} else {
56 		key = request_key(&key_type_asymmetric, name, NULL);
57 	}
58 
59 	if (IS_ERR(key)) {
60 		pr_err_ratelimited("Request for unknown key '%s' err %ld\n",
61 				   name, PTR_ERR(key));
62 		switch (PTR_ERR(key)) {
63 			/* Hide some search errors */
64 		case -EACCES:
65 		case -ENOTDIR:
66 		case -EAGAIN:
67 			return ERR_PTR(-ENOKEY);
68 		default:
69 			return key;
70 		}
71 	}
72 
73 	pr_debug("%s() = 0 [%x]\n", __func__, key_serial(key));
74 
75 	return key;
76 }
77 
78 int asymmetric_verify(struct key *keyring, const char *sig,
79 		      int siglen, const char *data, int datalen)
80 {
81 	struct public_key_signature pks;
82 	struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
83 	struct key *key;
84 	int ret = -ENOMEM;
85 
86 	if (siglen <= sizeof(*hdr))
87 		return -EBADMSG;
88 
89 	siglen -= sizeof(*hdr);
90 
91 	if (siglen != be16_to_cpu(hdr->sig_size))
92 		return -EBADMSG;
93 
94 	if (hdr->hash_algo >= HASH_ALGO__LAST)
95 		return -ENOPKG;
96 
97 	key = request_asymmetric_key(keyring, be32_to_cpu(hdr->keyid));
98 	if (IS_ERR(key))
99 		return PTR_ERR(key);
100 
101 	memset(&pks, 0, sizeof(pks));
102 
103 	pks.hash_algo = hash_algo_name[hdr->hash_algo];
104 	if (hdr->hash_algo == HASH_ALGO_STREEBOG_256 ||
105 	    hdr->hash_algo == HASH_ALGO_STREEBOG_512) {
106 		/* EC-RDSA and Streebog should go together. */
107 		pks.pkey_algo = "ecrdsa";
108 		pks.encoding = "raw";
109 	} else {
110 		pks.pkey_algo = "rsa";
111 		pks.encoding = "pkcs1";
112 	}
113 	pks.digest = (u8 *)data;
114 	pks.digest_size = datalen;
115 	pks.s = hdr->sig;
116 	pks.s_size = siglen;
117 	ret = verify_signature(key, &pks);
118 	key_put(key);
119 	pr_debug("%s() = %d\n", __func__, ret);
120 	return ret;
121 }
122 
123 /**
124  * integrity_kernel_module_request - prevent crypto-pkcs1pad(rsa,*) requests
125  * @kmod_name: kernel module name
126  *
127  * We have situation, when public_key_verify_signature() in case of RSA
128  * algorithm use alg_name to store internal information in order to
129  * construct an algorithm on the fly, but crypto_larval_lookup() will try
130  * to use alg_name in order to load kernel module with same name.
131  * Since we don't have any real "crypto-pkcs1pad(rsa,*)" kernel modules,
132  * we are safe to fail such module request from crypto_larval_lookup().
133  *
134  * In this way we prevent modprobe execution during digsig verification
135  * and avoid possible deadlock if modprobe and/or it's dependencies
136  * also signed with digsig.
137  */
138 int integrity_kernel_module_request(char *kmod_name)
139 {
140 	if (strncmp(kmod_name, "crypto-pkcs1pad(rsa,", 20) == 0)
141 		return -EINVAL;
142 
143 	return 0;
144 }
145