Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * FILS AEAD for (Re)Association Request/Response frames
4 : : * Copyright 2016, Qualcomm Atheros, Inc.
5 : : */
6 : :
7 : : #include <crypto/aes.h>
8 : : #include <crypto/algapi.h>
9 : : #include <crypto/hash.h>
10 : : #include <crypto/skcipher.h>
11 : :
12 : : #include "ieee80211_i.h"
13 : : #include "aes_cmac.h"
14 : : #include "fils_aead.h"
15 : :
16 : 0 : static void gf_mulx(u8 *pad)
17 : : {
18 : 0 : u64 a = get_unaligned_be64(pad);
19 : 0 : u64 b = get_unaligned_be64(pad + 8);
20 : :
21 [ # # # # ]: 0 : put_unaligned_be64((a << 1) | (b >> 63), pad);
22 [ # # # # ]: 0 : put_unaligned_be64((b << 1) ^ ((a >> 63) ? 0x87 : 0), pad + 8);
23 : : }
24 : :
25 : 0 : static int aes_s2v(struct crypto_shash *tfm,
26 : : size_t num_elem, const u8 *addr[], size_t len[], u8 *v)
27 : : {
28 : 0 : u8 d[AES_BLOCK_SIZE], tmp[AES_BLOCK_SIZE] = {};
29 : 0 : SHASH_DESC_ON_STACK(desc, tfm);
30 : 0 : size_t i;
31 : :
32 : 0 : desc->tfm = tfm;
33 : :
34 : : /* D = AES-CMAC(K, <zero>) */
35 : 0 : crypto_shash_digest(desc, tmp, AES_BLOCK_SIZE, d);
36 : :
37 [ # # ]: 0 : for (i = 0; i < num_elem - 1; i++) {
38 : : /* D = dbl(D) xor AES_CMAC(K, Si) */
39 [ # # ]: 0 : gf_mulx(d); /* dbl */
40 : 0 : crypto_shash_digest(desc, addr[i], len[i], tmp);
41 : 0 : crypto_xor(d, tmp, AES_BLOCK_SIZE);
42 : : }
43 : :
44 [ # # ]: 0 : crypto_shash_init(desc);
45 : :
46 [ # # ]: 0 : if (len[i] >= AES_BLOCK_SIZE) {
47 : : /* len(Sn) >= 128 */
48 : : /* T = Sn xorend D */
49 : 0 : crypto_shash_update(desc, addr[i], len[i] - AES_BLOCK_SIZE);
50 : 0 : crypto_xor(d, addr[i] + len[i] - AES_BLOCK_SIZE,
51 : : AES_BLOCK_SIZE);
52 : : } else {
53 : : /* len(Sn) < 128 */
54 : : /* T = dbl(D) xor pad(Sn) */
55 [ # # ]: 0 : gf_mulx(d); /* dbl */
56 : 0 : crypto_xor(d, addr[i], len[i]);
57 : 0 : d[len[i]] ^= 0x80;
58 : : }
59 : : /* V = AES-CMAC(K, T) */
60 : 0 : crypto_shash_finup(desc, d, AES_BLOCK_SIZE, v);
61 : :
62 : 0 : return 0;
63 : : }
64 : :
65 : : /* Note: addr[] and len[] needs to have one extra slot at the end. */
66 : 0 : static int aes_siv_encrypt(const u8 *key, size_t key_len,
67 : : const u8 *plain, size_t plain_len,
68 : : size_t num_elem, const u8 *addr[],
69 : : size_t len[], u8 *out)
70 : : {
71 : 0 : u8 v[AES_BLOCK_SIZE];
72 : 0 : struct crypto_shash *tfm;
73 : 0 : struct crypto_skcipher *tfm2;
74 : 0 : struct skcipher_request *req;
75 : 0 : int res;
76 : 0 : struct scatterlist src[1], dst[1];
77 : 0 : u8 *tmp;
78 : :
79 : 0 : key_len /= 2; /* S2V key || CTR key */
80 : :
81 : 0 : addr[num_elem] = plain;
82 : 0 : len[num_elem] = plain_len;
83 : 0 : num_elem++;
84 : :
85 : : /* S2V */
86 : :
87 : 0 : tfm = crypto_alloc_shash("cmac(aes)", 0, 0);
88 [ # # ]: 0 : if (IS_ERR(tfm))
89 : 0 : return PTR_ERR(tfm);
90 : : /* K1 for S2V */
91 : 0 : res = crypto_shash_setkey(tfm, key, key_len);
92 [ # # ]: 0 : if (!res)
93 : 0 : res = aes_s2v(tfm, num_elem, addr, len, v);
94 : 0 : crypto_free_shash(tfm);
95 [ # # ]: 0 : if (res)
96 : : return res;
97 : :
98 : : /* Use a temporary buffer of the plaintext to handle need for
99 : : * overwriting this during AES-CTR.
100 : : */
101 : 0 : tmp = kmemdup(plain, plain_len, GFP_KERNEL);
102 [ # # ]: 0 : if (!tmp)
103 : : return -ENOMEM;
104 : :
105 : : /* IV for CTR before encrypted data */
106 : 0 : memcpy(out, v, AES_BLOCK_SIZE);
107 : :
108 : : /* Synthetic IV to be used as the initial counter in CTR:
109 : : * Q = V bitand (1^64 || 0^1 || 1^31 || 0^1 || 1^31)
110 : : */
111 : 0 : v[8] &= 0x7f;
112 : 0 : v[12] &= 0x7f;
113 : :
114 : : /* CTR */
115 : :
116 : 0 : tfm2 = crypto_alloc_skcipher("ctr(aes)", 0, CRYPTO_ALG_ASYNC);
117 [ # # ]: 0 : if (IS_ERR(tfm2)) {
118 : 0 : kfree(tmp);
119 : 0 : return PTR_ERR(tfm2);
120 : : }
121 : : /* K2 for CTR */
122 : 0 : res = crypto_skcipher_setkey(tfm2, key + key_len, key_len);
123 [ # # ]: 0 : if (res)
124 : 0 : goto fail;
125 : :
126 : 0 : req = skcipher_request_alloc(tfm2, GFP_KERNEL);
127 [ # # ]: 0 : if (!req) {
128 : 0 : res = -ENOMEM;
129 : 0 : goto fail;
130 : : }
131 : :
132 : 0 : sg_init_one(src, tmp, plain_len);
133 : 0 : sg_init_one(dst, out + AES_BLOCK_SIZE, plain_len);
134 : 0 : skcipher_request_set_crypt(req, src, dst, plain_len, v);
135 : 0 : res = crypto_skcipher_encrypt(req);
136 : 0 : skcipher_request_free(req);
137 : 0 : fail:
138 : 0 : kfree(tmp);
139 : 0 : crypto_free_skcipher(tfm2);
140 : 0 : return res;
141 : : }
142 : :
143 : : /* Note: addr[] and len[] needs to have one extra slot at the end. */
144 : 0 : static int aes_siv_decrypt(const u8 *key, size_t key_len,
145 : : const u8 *iv_crypt, size_t iv_c_len,
146 : : size_t num_elem, const u8 *addr[], size_t len[],
147 : : u8 *out)
148 : : {
149 : 0 : struct crypto_shash *tfm;
150 : 0 : struct crypto_skcipher *tfm2;
151 : 0 : struct skcipher_request *req;
152 : 0 : struct scatterlist src[1], dst[1];
153 : 0 : size_t crypt_len;
154 : 0 : int res;
155 : 0 : u8 frame_iv[AES_BLOCK_SIZE], iv[AES_BLOCK_SIZE];
156 : 0 : u8 check[AES_BLOCK_SIZE];
157 : :
158 : 0 : crypt_len = iv_c_len - AES_BLOCK_SIZE;
159 : 0 : key_len /= 2; /* S2V key || CTR key */
160 : 0 : addr[num_elem] = out;
161 : 0 : len[num_elem] = crypt_len;
162 : 0 : num_elem++;
163 : :
164 : 0 : memcpy(iv, iv_crypt, AES_BLOCK_SIZE);
165 : 0 : memcpy(frame_iv, iv_crypt, AES_BLOCK_SIZE);
166 : :
167 : : /* Synthetic IV to be used as the initial counter in CTR:
168 : : * Q = V bitand (1^64 || 0^1 || 1^31 || 0^1 || 1^31)
169 : : */
170 : 0 : iv[8] &= 0x7f;
171 : 0 : iv[12] &= 0x7f;
172 : :
173 : : /* CTR */
174 : :
175 : 0 : tfm2 = crypto_alloc_skcipher("ctr(aes)", 0, CRYPTO_ALG_ASYNC);
176 [ # # ]: 0 : if (IS_ERR(tfm2))
177 : 0 : return PTR_ERR(tfm2);
178 : : /* K2 for CTR */
179 : 0 : res = crypto_skcipher_setkey(tfm2, key + key_len, key_len);
180 [ # # ]: 0 : if (res) {
181 : 0 : crypto_free_skcipher(tfm2);
182 : 0 : return res;
183 : : }
184 : :
185 : 0 : req = skcipher_request_alloc(tfm2, GFP_KERNEL);
186 [ # # ]: 0 : if (!req) {
187 : 0 : crypto_free_skcipher(tfm2);
188 : 0 : return -ENOMEM;
189 : : }
190 : :
191 : 0 : sg_init_one(src, iv_crypt + AES_BLOCK_SIZE, crypt_len);
192 : 0 : sg_init_one(dst, out, crypt_len);
193 : 0 : skcipher_request_set_crypt(req, src, dst, crypt_len, iv);
194 : 0 : res = crypto_skcipher_decrypt(req);
195 : 0 : skcipher_request_free(req);
196 : 0 : crypto_free_skcipher(tfm2);
197 [ # # ]: 0 : if (res)
198 : : return res;
199 : :
200 : : /* S2V */
201 : :
202 : 0 : tfm = crypto_alloc_shash("cmac(aes)", 0, 0);
203 [ # # ]: 0 : if (IS_ERR(tfm))
204 : 0 : return PTR_ERR(tfm);
205 : : /* K1 for S2V */
206 : 0 : res = crypto_shash_setkey(tfm, key, key_len);
207 [ # # ]: 0 : if (!res)
208 : 0 : res = aes_s2v(tfm, num_elem, addr, len, check);
209 : 0 : crypto_free_shash(tfm);
210 [ # # ]: 0 : if (res)
211 : : return res;
212 [ # # ]: 0 : if (memcmp(check, frame_iv, AES_BLOCK_SIZE) != 0)
213 : 0 : return -EINVAL;
214 : : return 0;
215 : : }
216 : :
217 : 0 : int fils_encrypt_assoc_req(struct sk_buff *skb,
218 : : struct ieee80211_mgd_assoc_data *assoc_data)
219 : : {
220 : 0 : struct ieee80211_mgmt *mgmt = (void *)skb->data;
221 : 0 : u8 *capab, *ies, *encr;
222 : 0 : const u8 *addr[5 + 1], *session;
223 : 0 : size_t len[5 + 1];
224 : 0 : size_t crypt_len;
225 : :
226 [ # # ]: 0 : if (ieee80211_is_reassoc_req(mgmt->frame_control)) {
227 : 0 : capab = (u8 *)&mgmt->u.reassoc_req.capab_info;
228 : 0 : ies = mgmt->u.reassoc_req.variable;
229 : : } else {
230 : 0 : capab = (u8 *)&mgmt->u.assoc_req.capab_info;
231 : 0 : ies = mgmt->u.assoc_req.variable;
232 : : }
233 : :
234 : 0 : session = cfg80211_find_ext_ie(WLAN_EID_EXT_FILS_SESSION,
235 : 0 : ies, skb->data + skb->len - ies);
236 [ # # # # ]: 0 : if (!session || session[1] != 1 + 8)
237 : : return -EINVAL;
238 : : /* encrypt after FILS Session element */
239 : 0 : encr = (u8 *)session + 2 + 1 + 8;
240 : :
241 : : /* AES-SIV AAD vectors */
242 : :
243 : : /* The STA's MAC address */
244 : 0 : addr[0] = mgmt->sa;
245 : 0 : len[0] = ETH_ALEN;
246 : : /* The AP's BSSID */
247 : 0 : addr[1] = mgmt->da;
248 : 0 : len[1] = ETH_ALEN;
249 : : /* The STA's nonce */
250 : 0 : addr[2] = assoc_data->fils_nonces;
251 : 0 : len[2] = FILS_NONCE_LEN;
252 : : /* The AP's nonce */
253 : 0 : addr[3] = &assoc_data->fils_nonces[FILS_NONCE_LEN];
254 : 0 : len[3] = FILS_NONCE_LEN;
255 : : /* The (Re)Association Request frame from the Capability Information
256 : : * field to the FILS Session element (both inclusive).
257 : : */
258 : 0 : addr[4] = capab;
259 : 0 : len[4] = encr - capab;
260 : :
261 : 0 : crypt_len = skb->data + skb->len - encr;
262 : 0 : skb_put(skb, AES_BLOCK_SIZE);
263 : 0 : return aes_siv_encrypt(assoc_data->fils_kek, assoc_data->fils_kek_len,
264 : : encr, crypt_len, 5, addr, len, encr);
265 : : }
266 : :
267 : 0 : int fils_decrypt_assoc_resp(struct ieee80211_sub_if_data *sdata,
268 : : u8 *frame, size_t *frame_len,
269 : : struct ieee80211_mgd_assoc_data *assoc_data)
270 : : {
271 : 0 : struct ieee80211_mgmt *mgmt = (void *)frame;
272 : 0 : u8 *capab, *ies, *encr;
273 : 0 : const u8 *addr[5 + 1], *session;
274 : 0 : size_t len[5 + 1];
275 : 0 : int res;
276 : 0 : size_t crypt_len;
277 : :
278 [ # # ]: 0 : if (*frame_len < 24 + 6)
279 : : return -EINVAL;
280 : :
281 : 0 : capab = (u8 *)&mgmt->u.assoc_resp.capab_info;
282 : 0 : ies = mgmt->u.assoc_resp.variable;
283 : 0 : session = cfg80211_find_ext_ie(WLAN_EID_EXT_FILS_SESSION,
284 : 0 : ies, frame + *frame_len - ies);
285 [ # # # # ]: 0 : if (!session || session[1] != 1 + 8) {
286 : : mlme_dbg(sdata,
287 : : "No (valid) FILS Session element in (Re)Association Response frame from %pM",
288 : : mgmt->sa);
289 : : return -EINVAL;
290 : : }
291 : : /* decrypt after FILS Session element */
292 : 0 : encr = (u8 *)session + 2 + 1 + 8;
293 : :
294 : : /* AES-SIV AAD vectors */
295 : :
296 : : /* The AP's BSSID */
297 : 0 : addr[0] = mgmt->sa;
298 : 0 : len[0] = ETH_ALEN;
299 : : /* The STA's MAC address */
300 : 0 : addr[1] = mgmt->da;
301 : 0 : len[1] = ETH_ALEN;
302 : : /* The AP's nonce */
303 : 0 : addr[2] = &assoc_data->fils_nonces[FILS_NONCE_LEN];
304 : 0 : len[2] = FILS_NONCE_LEN;
305 : : /* The STA's nonce */
306 : 0 : addr[3] = assoc_data->fils_nonces;
307 : 0 : len[3] = FILS_NONCE_LEN;
308 : : /* The (Re)Association Response frame from the Capability Information
309 : : * field to the FILS Session element (both inclusive).
310 : : */
311 : 0 : addr[4] = capab;
312 : 0 : len[4] = encr - capab;
313 : :
314 : 0 : crypt_len = frame + *frame_len - encr;
315 [ # # ]: 0 : if (crypt_len < AES_BLOCK_SIZE) {
316 : : mlme_dbg(sdata,
317 : : "Not enough room for AES-SIV data after FILS Session element in (Re)Association Response frame from %pM",
318 : : mgmt->sa);
319 : : return -EINVAL;
320 : : }
321 : 0 : res = aes_siv_decrypt(assoc_data->fils_kek, assoc_data->fils_kek_len,
322 : : encr, crypt_len, 5, addr, len, encr);
323 [ # # ]: 0 : if (res != 0) {
324 : : mlme_dbg(sdata,
325 : : "AES-SIV decryption of (Re)Association Response frame from %pM failed",
326 : : mgmt->sa);
327 : : return res;
328 : : }
329 : 0 : *frame_len -= AES_BLOCK_SIZE;
330 : 0 : return 0;
331 : : }
|
