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