1 /*
2 * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
3 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for
6 * any purpose with or without fee is hereby granted, provided that the
7 * above copyright notice and this permission notice appear in all
8 * copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17 * PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 /**
21 * DOC: Private definitions for handling crypto params
22 */
23 #ifndef _WLAN_CRYPTO_DEF_I_H_
24 #define _WLAN_CRYPTO_DEF_I_H_
25
26 #include <wlan_cmn_ieee80211.h>
27 #include "wlan_objmgr_pdev_obj.h"
28 #include "wlan_crypto_global_def.h"
29 #ifdef WLAN_CRYPTO_AES
30 #include "wlan_crypto_aes_i.h"
31 #endif
32
33 /* Number of bits per byte */
34 #define CRYPTO_NBBY 8
35 /* Default link id for legacy connection */
36 #define CRYPTO_MAX_LINK_IDX 0xFF
37
38 /* Macros for handling unaligned memory accesses */
39
wlan_crypto_get_be16(const uint8_t * a)40 static inline uint16_t wlan_crypto_get_be16(const uint8_t *a)
41 {
42 return (a[0] << 8) | a[1];
43 }
44
wlan_crypto_put_be16(uint8_t * a,uint16_t val)45 static inline void wlan_crypto_put_be16(uint8_t *a, uint16_t val)
46 {
47 a[0] = val >> 8;
48 a[1] = val & 0xff;
49 }
50
wlan_crypto_get_le16(const uint8_t * a)51 static inline uint16_t wlan_crypto_get_le16(const uint8_t *a)
52 {
53 return (a[1] << 8) | a[0];
54 }
55
wlan_crypto_put_le16(uint8_t * a,uint16_t val)56 static inline void wlan_crypto_put_le16(uint8_t *a, uint16_t val)
57 {
58 a[1] = val >> 8;
59 a[0] = val & 0xff;
60 }
61
wlan_crypto_get_be32(const uint8_t * a)62 static inline uint32_t wlan_crypto_get_be32(const uint8_t *a)
63 {
64 return ((u32) a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3];
65 }
66
wlan_crypto_put_be32(uint8_t * a,uint32_t val)67 static inline void wlan_crypto_put_be32(uint8_t *a, uint32_t val)
68 {
69 a[0] = (val >> 24) & 0xff;
70 a[1] = (val >> 16) & 0xff;
71 a[2] = (val >> 8) & 0xff;
72 a[3] = val & 0xff;
73 }
74
wlan_crypto_get_le32(const uint8_t * a)75 static inline uint32_t wlan_crypto_get_le32(const uint8_t *a)
76 {
77 return ((u32) a[3] << 24) | (a[2] << 16) | (a[1] << 8) | a[0];
78 }
79
wlan_crypto_put_le32(uint8_t * a,uint32_t val)80 static inline void wlan_crypto_put_le32(uint8_t *a, uint32_t val)
81 {
82 a[3] = (val >> 24) & 0xff;
83 a[2] = (val >> 16) & 0xff;
84 a[1] = (val >> 8) & 0xff;
85 a[0] = val & 0xff;
86 }
87
wlan_crypto_put_be64(u8 * a,u64 val)88 static inline void wlan_crypto_put_be64(u8 *a, u64 val)
89 {
90 a[0] = val >> 56;
91 a[1] = val >> 48;
92 a[2] = val >> 40;
93 a[3] = val >> 32;
94 a[4] = val >> 24;
95 a[5] = val >> 16;
96 a[6] = val >> 8;
97 a[7] = val & 0xff;
98 }
99
100 #define WLAN_CRYPTO_TX_OPS_ALLOCKEY(tx_ops) \
101 ((tx_ops)->crypto_tx_ops.allockey)
102 #define WLAN_CRYPTO_TX_OPS_SETKEY(tx_ops) \
103 ((tx_ops)->crypto_tx_ops.setkey)
104 #define WLAN_CRYPTO_TX_OPS_DELKEY(tx_ops) \
105 ((tx_ops)->crypto_tx_ops.delkey)
106 #define WLAN_CRYPTO_TX_OPS_DEFAULTKEY(tx_ops) \
107 ((tx_ops)->crypto_tx_ops.defaultkey)
108 #define WLAN_CRYPTO_TX_OPS_SET_KEY(tx_ops) \
109 ((tx_ops)->crypto_tx_ops.set_key)
110 #define WLAN_CRYPTO_TX_OPS_SET_VDEV_PARAM(tx_ops) \
111 ((tx_ops)->crypto_tx_ops.set_vdev_param)
112 #define WLAN_CRYPTO_TX_OPS_GETPN(tx_ops) \
113 ((tx_ops)->crypto_tx_ops.getpn)
114 #define WLAN_CRYPTO_TX_OPS_SET_LTF_KEYSEED(tx_ops) \
115 ((tx_ops)->crypto_tx_ops.set_ltf_keyseed)
116 #define WLAN_CRYPTO_TX_OPS_REGISTER_EVENTS(tx_ops) \
117 ((tx_ops)->crypto_tx_ops.register_events)
118 #define WLAN_CRYPTO_TX_OPS_DEREGISTER_EVENTS(tx_ops) \
119 ((tx_ops)->crypto_tx_ops.deregister_events)
120
121 /* unaligned little endian access */
122 #ifndef LE_READ_2
123 #define LE_READ_2(p) \
124 ((uint16_t) \
125 ((((const uint8_t *)(p))[0]) | \
126 (((const uint8_t *)(p))[1] << 8)))
127 #endif
128
129 #ifndef LE_READ_4
130 #define LE_READ_4(p) \
131 ((uint32_t) \
132 ((((const uint8_t *)(p))[0]) | \
133 (((const uint8_t *)(p))[1] << 8) | \
134 (((const uint8_t *)(p))[2] << 16) | \
135 (((const uint8_t *)(p))[3] << 24)))
136 #endif
137
138 #ifndef BE_READ_4
139 #define BE_READ_4(p) \
140 ((uint32_t) \
141 ((((const uint8_t *)(p))[0] << 24) | \
142 (((const uint8_t *)(p))[1] << 16) | \
143 (((const uint8_t *)(p))[2] << 8) | \
144 (((const uint8_t *)(p))[3])))
145 #endif
146
147 #ifndef READ_6
148 #define READ_6(b0, b1, b2, b3, b4, b5) ({ \
149 uint32_t iv32 = (b0 << 0) | (b1 << 8) | (b2 << 16) | (b3 << 24);\
150 uint16_t iv16 = (b4 << 0) | (b5 << 8);\
151 (((uint64_t)iv16) << 32) | iv32;\
152 })
153 #endif
154
155 #define OUI_SIZE (4)
156 #define WLAN_CRYPTO_ADDSHORT(frm, v) \
157 do {frm[0] = (v) & 0xff; frm[1] = (v) >> 8; frm += 2; } while (0)
158
159 #define WLAN_CRYPTO_ADDSELECTOR(frm, sel) \
160 do { \
161 uint32_t value = sel;\
162 qdf_mem_copy(frm, (uint8_t *)&value, OUI_SIZE); \
163 frm += OUI_SIZE; } while (0)
164
165 #define WLAN_CRYPTO_SELECTOR(a, b, c, d) \
166 ((((uint32_t) (a)) << 24) | \
167 (((uint32_t) (b)) << 16) | \
168 (((uint32_t) (c)) << 8) | \
169 (uint32_t) (d))
170
171 #define WPA_TYPE_OUI WLAN_WPA_SEL(WLAN_WPA_OUI_TYPE)
172
173 #define WLAN_CRYPTO_WAPI_IE_LEN 20
174 #define WLAN_CRYPTO_WAPI_SMS4_CIPHER 0x01
175
176 #define WPA_AUTH_KEY_MGMT_NONE WLAN_WPA_SEL(WLAN_ASE_NONE)
177 #define WPA_AUTH_KEY_MGMT_UNSPEC_802_1X WLAN_WPA_SEL(WLAN_ASE_8021X_UNSPEC)
178 #define WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X \
179 WLAN_WPA_SEL(WLAN_ASE_8021X_PSK)
180 #define WPA_AUTH_KEY_MGMT_CCKM WLAN_WPA_CCKM_AKM
181
182 #define WPA_CIPHER_SUITE_NONE WLAN_WPA_SEL(WLAN_CSE_NONE)
183 #define WPA_CIPHER_SUITE_WEP40 WLAN_WPA_SEL(WLAN_CSE_WEP40)
184 #define WPA_CIPHER_SUITE_WEP104 WLAN_WPA_SEL(WLAN_CSE_WEP104)
185 #define WPA_CIPHER_SUITE_TKIP WLAN_WPA_SEL(WLAN_CSE_TKIP)
186 #define WPA_CIPHER_SUITE_CCMP WLAN_WPA_SEL(WLAN_CSE_CCMP)
187
188 #define RSN_AUTH_KEY_MGMT_NONE WLAN_RSN_SEL(0)
189 #define RSN_AUTH_KEY_MGMT_UNSPEC_802_1X WLAN_RSN_SEL(1)
190 #define RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X\
191 WLAN_RSN_SEL(2)
192 #define RSN_AUTH_KEY_MGMT_FT_802_1X WLAN_RSN_SEL(3)
193 #define RSN_AUTH_KEY_MGMT_FT_PSK WLAN_RSN_SEL(4)
194 #define RSN_AUTH_KEY_MGMT_802_1X_SHA256\
195 WLAN_RSN_SEL(5)
196 #define RSN_AUTH_KEY_MGMT_PSK_SHA256 WLAN_RSN_SEL(6)
197 #define RSN_AUTH_KEY_MGMT_WPS WLAN_RSN_SEL(7)
198 #define RSN_AUTH_KEY_MGMT_SAE WLAN_RSN_SEL(8)
199 #define RSN_AUTH_KEY_MGMT_FT_SAE WLAN_RSN_SEL(9)
200 #define RSN_AUTH_KEY_MGMT_802_1X_SUITE_B\
201 WLAN_RSN_SEL(11)
202 #define RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192\
203 WLAN_RSN_SEL(12)
204 #define RSN_AUTH_KEY_MGMT_FT_802_1X_SUITE_B_384\
205 WLAN_RSN_SEL(13)
206 #define RSN_AUTH_KEY_MGMT_FILS_SHA256 WLAN_RSN_SEL(14)
207 #define RSN_AUTH_KEY_MGMT_FILS_SHA384 WLAN_RSN_SEL(15)
208 #define RSN_AUTH_KEY_MGMT_FT_FILS_SHA256\
209 WLAN_RSN_SEL(16)
210 #define RSN_AUTH_KEY_MGMT_FT_FILS_SHA384\
211 WLAN_RSN_SEL(17)
212 #define RSN_AUTH_KEY_MGMT_OWE WLAN_RSN_SEL(18)
213 #define RSN_AUTH_KEY_MGMT_FT_PSK_SHA384 WLAN_RSN_SEL(19)
214 #define RSN_AUTH_KEY_MGMT_PSK_SHA384 WLAN_RSN_SEL(20)
215 #define RSN_AUTH_KEY_MGMT_SAE_EXT_KEY WLAN_RSN_SEL(24)
216 #define RSN_AUTH_KEY_MGMT_FT_SAE_EXT_KEY WLAN_RSN_SEL(25)
217
218 #define RSN_AUTH_KEY_MGMT_CCKM (WLAN_RSN_CCKM_AKM)
219 #define RSN_AUTH_KEY_MGMT_OSEN (0x019a6f50)
220 #define RSN_AUTH_KEY_MGMT_DPP (WLAN_RSN_DPP_AKM)
221
222 #define RSN_CIPHER_SUITE_NONE WLAN_RSN_SEL(WLAN_CSE_NONE)
223 #define RSN_CIPHER_SUITE_WEP40 WLAN_RSN_SEL(WLAN_CSE_WEP40)
224 #define RSN_CIPHER_SUITE_TKIP WLAN_RSN_SEL(WLAN_CSE_TKIP)
225 #define RSN_CIPHER_SUITE_WEP104 WLAN_RSN_SEL(WLAN_CSE_WEP104)
226 #define RSN_CIPHER_SUITE_CCMP WLAN_RSN_SEL(WLAN_CSE_CCMP)
227 #define RSN_CIPHER_SUITE_AES_CMAC WLAN_RSN_SEL(WLAN_CSE_AES_CMAC)
228 #define RSN_CIPHER_SUITE_GCMP WLAN_RSN_SEL(WLAN_CSE_GCMP_128)
229 #define RSN_CIPHER_SUITE_GCMP_256 WLAN_RSN_SEL(WLAN_CSE_GCMP_256)
230 #define RSN_CIPHER_SUITE_CCMP_256 WLAN_RSN_SEL(WLAN_CSE_CCMP_256)
231 #define RSN_CIPHER_SUITE_BIP_GMAC_128 WLAN_RSN_SEL(WLAN_CSE_BIP_GMAC_128)
232 #define RSN_CIPHER_SUITE_BIP_GMAC_256 WLAN_RSN_SEL(WLAN_CSE_BIP_GMAC_256)
233 #define RSN_CIPHER_SUITE_BIP_CMAC_256 WLAN_RSN_SEL(WLAN_CSE_BIP_CMAC_256)
234
235 #define RESET_PARAM(__param) ((__param) = 0)
236 #define SET_PARAM(__param, __val) ((__param) |= (1 << (__val)))
237 #define HAS_PARAM(__param, __val) ((__param) & (1 << (__val)))
238 #define CLEAR_PARAM(__param, __val) ((__param) &= (~(1 << (__val))))
239
240
241 #define RESET_AUTHMODE(_param) ((_param)->authmodeset = 0)
242
243 #define SET_AUTHMODE(_param, _mode) ((_param)->authmodeset |= (1 << (_mode)))
244 #define HAS_AUTHMODE(_param, _mode) ((_param)->authmodeset & (1 << (_mode)))
245
246 #define AUTH_IS_OPEN(_param) HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_OPEN)
247 #define AUTH_IS_SHARED_KEY(_param) \
248 HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_SHARED)
249 #define AUTH_IS_8021X(_param) HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_8021X)
250 #define AUTH_IS_WPA(_param) HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_WPA)
251 #define AUTH_IS_RSNA(_param) HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_RSNA)
252 #define AUTH_IS_CCKM(_param) HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_CCKM)
253 #define AUTH_IS_WAI(_param) HAS_AUTHMODE((_param), WLAN_CRYPTO_AUTH_WAPI)
254 #define AUTH_IS_WPA2(_param) AUTH_IS_RSNA(_param)
255
256 #define AUTH_MATCH(_param1, _param2) \
257 (((_param1)->authmodeset & (_param2)->authmodeset) != 0)
258
259
260 #define RESET_UCAST_CIPHERS(_param) ((_param)->ucastcipherset = 0)
261 #define SET_UCAST_CIPHER(_param, _c) ((_param)->ucastcipherset |= (1 << (_c)))
262 #define HAS_UCAST_CIPHER(_param, _c) ((_param)->ucastcipherset & (1 << (_c)))
263
264 #define UCIPHER_IS_CLEAR(_param) \
265 ((_param)->ucastcipherset == 0)
266 #define UCIPHER_IS_WEP(_param) \
267 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_WEP)
268 #define UCIPHER_IS_TKIP(_param) \
269 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_TKIP)
270 #define UCIPHER_IS_CCMP128(_param) \
271 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_CCM)
272 #define UCIPHER_IS_CCMP256(_param) \
273 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_CCM_256)
274 #define UCIPHER_IS_GCMP128(_param) \
275 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_GCM)
276 #define UCIPHER_IS_GCMP256(_param) \
277 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_GCM_256)
278 #define UCIPHER_IS_SMS4(_param) \
279 HAS_UCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_WAPI_SMS4)
280
281 #define RESET_MCAST_CIPHERS(_param) ((_param)->mcastcipherset = 0)
282 #define SET_MCAST_CIPHER(_param, _c) ((_param)->mcastcipherset |= (1 << (_c)))
283 #define HAS_MCAST_CIPHER(_param, _c) ((_param)->mcastcipherset & (1 << (_c)))
284 #define HAS_ANY_MCAST_CIPHER(_param) ((_param)->mcastcipherset)
285 #define CLEAR_MCAST_CIPHER(_param, _c) \
286 ((_param)->mcastcipherset &= (~(1)<<(_c)))
287
288 #define MCIPHER_IS_CLEAR(_param) \
289 ((_param)->mcastcipherset == 0)
290 #define MCIPHER_IS_WEP(_param) \
291 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_WEP)
292 #define MCIPHER_IS_TKIP(_param) \
293 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_TKIP)
294 #define MCIPHER_IS_CCMP128(_param) \
295 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_CCM)
296 #define MCIPHER_IS_CCMP256(_param) \
297 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_CCM_256)
298 #define MCIPHER_IS_GCMP128(_param) \
299 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_GCM)
300 #define MCIPHER_IS_GCMP256(_param) \
301 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_GCM_256)
302 #define MCIPHER_IS_SMS4(_param) \
303 HAS_MCAST_CIPHER((_param), WLAN_CRYPTO_CIPHER_WAPI_SMS4)
304
305 #define RESET_MGMT_CIPHERS(_param) ((_param)->mgmtcipherset = 0)
306 #define SET_MGMT_CIPHER(_param, _c) ((_param)->mgmtcipherset |= (1 << (_c)))
307 #define HAS_MGMT_CIPHER(_param, _c) ((_param)->mgmtcipherset & (1 << (_c)))
308 #define IS_MGMT_CIPHER(_c) ((_c == WLAN_CRYPTO_CIPHER_AES_CMAC) || \
309 (_c == WLAN_CRYPTO_CIPHER_AES_CMAC_256) || \
310 (_c == WLAN_CRYPTO_CIPHER_AES_GMAC) || \
311 (_c == WLAN_CRYPTO_CIPHER_AES_GMAC_256))
312
313 #define IS_FILS_CIPHER(_c) ((_c) == WLAN_CRYPTO_CIPHER_FILS_AEAD)
314
315 #define MGMT_CIPHER_IS_CLEAR(_param) \
316 ((_param)->mgmtcipherset == 0)
317 #define MGMT_CIPHER_IS_CMAC(_param) \
318 HAS_MGMT_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_CMAC)
319 #define MGMT_CIPHER_IS_CMAC256(_param) \
320 HAS_MGMT_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_CMAC_256)
321 #define MGMT_CIPHER_IS_GMAC(_param) \
322 HAS_MGMT_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_GMAC)
323 #define MGMT_CIPHER_IS_GMAC256(_param) \
324 HAS_MGMT_CIPHER((_param), WLAN_CRYPTO_CIPHER_AES_GMAC_256)
325
326 #define RESET_KEY_MGMT(_param) ((_param)->key_mgmt = 0)
327 #define SET_KEY_MGMT(_param, _c) ((_param)->key_mgmt |= (1 << (_c)))
328 #define HAS_KEY_MGMT(_param, _c) ((_param)->key_mgmt & (1 << (_c)))
329
330 #define UCAST_CIPHER_MATCH(_param1, _param2) \
331 (((_param1)->ucastcipherset & (_param2)->ucastcipherset) != 0)
332
333 #define MCAST_CIPHER_MATCH(_param1, _param2) \
334 (((_param1)->mcastcipherset & (_param2)->mcastcipherset) != 0)
335
336 #define MGMT_CIPHER_MATCH(_param1, _param2) \
337 (((_param1)->mgmtcipherset & (_param2)->mgmtcipherset) != 0)
338
339 #define KEY_MGMTSET_MATCH(_param1, _param2) \
340 (((_param1)->key_mgmt & (_param2)->key_mgmt) != 0 || \
341 (!(_param1)->key_mgmt && !(_param2)->key_mgmt))
342
343 #define RESET_CIPHER_CAP(_param) ((_param)->cipher_caps = 0)
344 #define SET_CIPHER_CAP(_param, _c) ((_param)->cipher_caps |= (1 << (_c)))
345 #define HAS_CIPHER_CAP(_param, _c) ((_param)->cipher_caps & (1 << (_c)))
346 #define HAS_ANY_CIPHER_CAP(_param) ((_param)->cipher_caps)
347
348 #define crypto_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_CRYPTO, params)
349 #define crypto_info(params...) QDF_TRACE_INFO(QDF_MODULE_ID_CRYPTO, params)
350 #define crypto_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_CRYPTO, params)
351
352 /**
353 * struct wlan_crypto_mmie - MMIE IE
354 * @element_id: element id
355 * @length: length of the ie
356 * @key_id: igtk key_id used
357 * @sequence_number: igtk PN number
358 * @mic: MIC for the frame
359 *
360 * This structure represents Management MIC information element (IEEE 802.11w)
361 */
362 struct wlan_crypto_mmie {
363 uint8_t element_id;
364 uint8_t length;
365 uint16_t key_id;
366 uint8_t sequence_number[6];
367 uint8_t mic[16];
368 } __packed;
369
370 /**
371 * struct crypto_add_key_result - add key result structure
372 * @vdev_id: unique id identifying the VDEV
373 * @key_ix: key index
374 * @key_flags: key flags
375 * @status: status of add key
376 * @peer_macaddr: MAC address of the peer
377 *
378 * Structure used for add key result.
379 */
380 struct crypto_add_key_result {
381 uint32_t vdev_id;
382 uint32_t key_ix;
383 uint32_t key_flags;
384 uint32_t status;
385 uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
386 };
387
388 /**
389 * typedef crypto_add_key_callback - add key callback
390 * @context: opaque context that the client can use to associate the
391 * callback with the request
392 * @result: result of add key
393 */
394 typedef void (*crypto_add_key_callback)(void *context,
395 struct crypto_add_key_result *result);
396
397 /**
398 * struct wlan_crypto_comp_priv - crypto component private structure
399 * @crypto_params: crypto params for the peer
400 * @crypto_key: crypto keys structure for the peer
401 * @fils_aead_set: fils params for this peer
402 * @add_key_ctx: Opaque context to be used by the caller to associate the
403 * add key request with the response
404 * @add_key_cb: Callback function to be called with the add key result
405 *
406 */
407 struct wlan_crypto_comp_priv {
408 struct wlan_crypto_params crypto_params;
409 struct wlan_crypto_keys crypto_key;
410 uint8_t fils_aead_set;
411 void *add_key_ctx;
412 crypto_add_key_callback add_key_cb;
413 };
414
415 /**
416 * struct wlan_crypto_cipher - crypto cipher table
417 * @cipher_name: printable name
418 * @cipher: cipher type WLAN_CRYPTO_CIPHER_*
419 * @header: size of privacy header (bytes)
420 * @trailer: size of privacy trailer (bytes)
421 * @miclen: size of mic trailer (bytes)
422 * @keylen: max key length
423 * @setkey: function pointer for setkey
424 * @encap: function pointer for encap
425 * @decap: function pointer for decap
426 * @enmic: function pointer for enmic
427 * @demic: function pointer for demic
428 *
429 */
430 struct wlan_crypto_cipher {
431 const char *cipher_name;
432 wlan_crypto_cipher_type cipher;
433 const uint8_t header;
434 const uint8_t trailer;
435 const uint8_t miclen;
436 const uint32_t keylen;
437 QDF_STATUS(*setkey)(struct wlan_crypto_key *);
438 QDF_STATUS(*encap)(struct wlan_crypto_key *,
439 qdf_nbuf_t, uint8_t, uint8_t);
440 QDF_STATUS(*decap)(struct wlan_crypto_key *,
441 qdf_nbuf_t, uint8_t, uint8_t);
442 QDF_STATUS(*enmic)(struct wlan_crypto_key *,
443 qdf_nbuf_t, uint8_t, uint8_t);
444 QDF_STATUS(*demic)(struct wlan_crypto_key *,
445 qdf_nbuf_t, uint8_t, uint8_t);
446 };
447
448
449 /**
450 * wlan_crypto_is_data_protected - check is frame is protected or not
451 * @data: frame
452 *
453 * This function check is frame is protected or not
454 *
455 * Return: TRUE/FALSE
456 */
wlan_crypto_is_data_protected(const void * data)457 static inline bool wlan_crypto_is_data_protected(const void *data)
458 {
459 const struct wlan_frame_hdr *hdr = (const struct wlan_frame_hdr *)data;
460 if (hdr->i_fc[1] & WLAN_FC1_ISWEP)
461 return true;
462 else
463 return false;
464 }
465
466 /**
467 * ieee80211_hdrsize - calculate frame header size
468 * @data: frame
469 *
470 * This function calculate frame header size
471 *
472 * Return: header size of the frame
473 */
ieee80211_hdrsize(const void * data)474 static inline uint8_t ieee80211_hdrsize(const void *data)
475 {
476 const struct wlan_frame_hdr *hdr = (const struct wlan_frame_hdr *)data;
477 uint8_t size = sizeof(struct wlan_frame_hdr);
478
479 if ((hdr->i_fc[1] & WLAN_FC1_DIR_MASK)
480 == (WLAN_FC1_DSTODS)) {
481 size += QDF_MAC_ADDR_SIZE;
482 }
483
484 if (((WLAN_FC0_GET_STYPE(hdr->i_fc[0])
485 == WLAN_FC0_STYPE_QOS_DATA))) {
486 size += sizeof(uint16_t);
487 /* Qos frame with Order bit set indicates an HTC frame */
488 if (hdr->i_fc[1] & WLAN_FC1_ORDER)
489 size += (sizeof(uint8_t)*4);
490 }
491 if (((WLAN_FC0_GET_STYPE(hdr->i_fc[0])
492 == WLAN_FC0_STYPE_ACTION))) {
493 /* Action frame with Order bit set indicates an HTC frame */
494 if (hdr->i_fc[1] & WLAN_FC1_ORDER)
495 size += (sizeof(uint8_t)*4);
496 }
497 return size;
498 }
499
500 /**
501 * ieee80211_hdrspace - calculate frame header size with padding
502 * @pdev: pdev
503 * @data: frame header
504 *
505 * This function returns the space occupied by the 802.11 header
506 * and any padding required by the driver. This works for a management
507 * or data frame.
508 *
509 * Return: header size of the frame with padding
510 */
511 static inline uint8_t
ieee80211_hdrspace(struct wlan_objmgr_pdev * pdev,const void * data)512 ieee80211_hdrspace(struct wlan_objmgr_pdev *pdev, const void *data)
513 {
514 uint8_t size = ieee80211_hdrsize(data);
515
516 if (wlan_pdev_nif_feat_cap_get(pdev, WLAN_PDEV_F_DATAPAD))
517 size = roundup(size, sizeof(u_int32_t));
518
519 return size;
520 }
521
522 /**
523 * wlan_get_tid - get tid of the frame
524 * @data: frame
525 *
526 * This function get tid of the frame
527 *
528 * Return: tid of the frame
529 */
wlan_get_tid(const void * data)530 static inline int wlan_get_tid(const void *data)
531 {
532 const struct wlan_frame_hdr *hdr = (const struct wlan_frame_hdr *)data;
533
534 if (((WLAN_FC0_GET_STYPE(hdr->i_fc[0])
535 == WLAN_FC0_STYPE_QOS_DATA))) {
536 if ((hdr->i_fc[1] & WLAN_FC1_DIR_MASK)
537 == (WLAN_FC1_DSTODS)) {
538 return ((struct wlan_frame_hdr_qos_addr4 *)data)->i_qos[0]
539 & WLAN_QOS_TID_MASK;
540 } else {
541 return ((struct wlan_frame_hdr_qos *)data)->i_qos[0]
542 & WLAN_QOS_TID_MASK;
543 }
544 } else
545 return WLAN_NONQOS_SEQ;
546 }
547
548 struct crypto_psoc_priv_obj {
549 /** @crypto_key_lock: lock for crypto key table */
550 qdf_mutex_t crypto_key_lock;
551 /** @crypto_key_lock: lock for crypto key table */
552 qdf_atomic_t crypto_key_cnt;
553 struct {
554 /** @mask: mask bits */
555 uint32_t mask;
556 /** @idx_bits: index to shift bits */
557 uint32_t idx_bits;
558 /** @bins: crypto key table */
559 TAILQ_HEAD(, wlan_crypto_key_entry) * bins;
560 } crypto_key_holder;
561 };
562
563 /**
564 * struct pdev_crypto - pdev object structure for crypto
565 * @pdev_obj: pdev object
566 */
567 struct pdev_crypto {
568 struct wlan_objmgr_pdev *pdev_obj;
569 };
570
571 /**
572 * wlan_crypto_add_key_entry() - Add a filled key entry to the hashing
573 * framework
574 * @psoc: PSOC pointer
575 * @new_entry: New entry
576 *
577 * Return: QDF_STATUS
578 */
579 QDF_STATUS wlan_crypto_add_key_entry(struct wlan_objmgr_psoc *psoc,
580 struct wlan_crypto_key_entry *new_entry);
581
582 /**
583 * crypto_add_entry - add key entry to hashing framework
584 * @psoc: psoc handler
585 * @link_id: link id
586 * @mac_addr: mac addr
587 * @crypto_key: crypto key
588 * @key_index: key index
589 * Return: zero on success
590 */
591 QDF_STATUS crypto_add_entry(struct crypto_psoc_priv_obj *psoc,
592 uint8_t link_id,
593 uint8_t *mac_addr,
594 struct wlan_crypto_key *crypto_key,
595 uint8_t key_index);
596 /**
597 * crypto_hash_find_by_linkid_and_macaddr - find crypto entry by link id
598 * @psoc: psoc handler
599 * @link_id: link id
600 * @mac_addr: mac addr
601 * Return: crypto key entry on success
602 */
603 struct
604 wlan_crypto_key_entry * crypto_hash_find_by_linkid_and_macaddr(
605 struct crypto_psoc_priv_obj *psoc,
606 uint8_t link_id,
607 uint8_t *mac_addr);
608
609 #ifdef WLAN_FEATURE_11BE_MLO_ADV_FEATURE
610 /**
611 * wlan_crypto_free_key_by_link_id - free key by link id
612 * @psoc: psoc handler
613 * @link_addr: link address
614 * @link_id: link id
615 */
616 void wlan_crypto_free_key_by_link_id(struct wlan_objmgr_psoc *psoc,
617 struct qdf_mac_addr *link_addr,
618 uint8_t link_id);
619 #else
620 static inline
wlan_crypto_free_key_by_link_id(struct wlan_objmgr_psoc * psoc,struct qdf_mac_addr * link_addr,uint8_t link_id)621 void wlan_crypto_free_key_by_link_id(struct wlan_objmgr_psoc *psoc,
622 struct qdf_mac_addr *link_addr,
623 uint8_t link_id)
624 {}
625 #endif /* WLAN_FEATURE_11BE_MLO_ADV_FEATURE */
626 #endif /* end of _WLAN_CRYPTO_DEF_I_H_ */
627