1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /*
3 * Copyright (C) 2022 - 2023 Intel Corporation
4 */
5 #include <linux/kernel.h>
6 #include <net/mac80211.h>
7 #include "mvm.h"
8 #include "fw/api/context.h"
9 #include "fw/api/datapath.h"
10
iwl_mvm_get_sec_sta_mask(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * keyconf)11 static u32 iwl_mvm_get_sec_sta_mask(struct iwl_mvm *mvm,
12 struct ieee80211_vif *vif,
13 struct ieee80211_sta *sta,
14 struct ieee80211_key_conf *keyconf)
15 {
16 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
17 struct iwl_mvm_vif_link_info *link_info = &mvmvif->deflink;
18
19 lockdep_assert_held(&mvm->mutex);
20
21 if (keyconf->link_id >= 0) {
22 link_info = mvmvif->link[keyconf->link_id];
23 if (!link_info)
24 return 0;
25 }
26
27 /* AP group keys are per link and should be on the mcast STA */
28 if (vif->type == NL80211_IFTYPE_AP &&
29 !(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
30 return BIT(link_info->mcast_sta.sta_id);
31
32 /* for client mode use the AP STA also for group keys */
33 if (!sta && vif->type == NL80211_IFTYPE_STATION)
34 sta = mvmvif->ap_sta;
35
36 /* During remove the STA was removed and the group keys come later
37 * (which sounds like a bad sequence, but remember that to mac80211 the
38 * group keys have no sta pointer), so we don't have a STA now.
39 * Since this happens for group keys only, just use the link_info as
40 * the group keys are per link; make sure that is the case by checking
41 * we do have a link_id or are not doing MLO.
42 * Of course the same can be done during add as well, but we must do
43 * it during remove, since we don't have the mvmvif->ap_sta pointer.
44 */
45 if (!sta && (keyconf->link_id >= 0 || !ieee80211_vif_is_mld(vif)))
46 return BIT(link_info->ap_sta_id);
47
48 /* STA should be non-NULL now, but iwl_mvm_sta_fw_id_mask() checks */
49
50 /* pass link_id to filter by it if not -1 (GTK on client) */
51 return iwl_mvm_sta_fw_id_mask(mvm, sta, keyconf->link_id);
52 }
53
iwl_mvm_get_sec_flags(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * keyconf)54 u32 iwl_mvm_get_sec_flags(struct iwl_mvm *mvm,
55 struct ieee80211_vif *vif,
56 struct ieee80211_sta *sta,
57 struct ieee80211_key_conf *keyconf)
58 {
59 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
60 u32 flags = 0;
61
62 lockdep_assert_held(&mvm->mutex);
63
64 if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
65 flags |= IWL_SEC_KEY_FLAG_MCAST_KEY;
66
67 switch (keyconf->cipher) {
68 case WLAN_CIPHER_SUITE_WEP104:
69 flags |= IWL_SEC_KEY_FLAG_KEY_SIZE;
70 fallthrough;
71 case WLAN_CIPHER_SUITE_WEP40:
72 flags |= IWL_SEC_KEY_FLAG_CIPHER_WEP;
73 break;
74 case WLAN_CIPHER_SUITE_TKIP:
75 flags |= IWL_SEC_KEY_FLAG_CIPHER_TKIP;
76 break;
77 case WLAN_CIPHER_SUITE_AES_CMAC:
78 case WLAN_CIPHER_SUITE_CCMP:
79 flags |= IWL_SEC_KEY_FLAG_CIPHER_CCMP;
80 break;
81 case WLAN_CIPHER_SUITE_GCMP_256:
82 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
83 flags |= IWL_SEC_KEY_FLAG_KEY_SIZE;
84 fallthrough;
85 case WLAN_CIPHER_SUITE_GCMP:
86 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
87 flags |= IWL_SEC_KEY_FLAG_CIPHER_GCMP;
88 break;
89 }
90
91 if (!sta && vif->type == NL80211_IFTYPE_STATION)
92 sta = mvmvif->ap_sta;
93
94 if (!IS_ERR_OR_NULL(sta) && sta->mfp)
95 flags |= IWL_SEC_KEY_FLAG_MFP;
96
97 return flags;
98 }
99
100 struct iwl_mvm_sta_key_update_data {
101 struct ieee80211_sta *sta;
102 u32 old_sta_mask;
103 u32 new_sta_mask;
104 int err;
105 };
106
iwl_mvm_mld_update_sta_key(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key,void * _data)107 static void iwl_mvm_mld_update_sta_key(struct ieee80211_hw *hw,
108 struct ieee80211_vif *vif,
109 struct ieee80211_sta *sta,
110 struct ieee80211_key_conf *key,
111 void *_data)
112 {
113 u32 cmd_id = WIDE_ID(DATA_PATH_GROUP, SEC_KEY_CMD);
114 struct iwl_mvm_sta_key_update_data *data = _data;
115 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
116 struct iwl_sec_key_cmd cmd = {
117 .action = cpu_to_le32(FW_CTXT_ACTION_MODIFY),
118 .u.modify.old_sta_mask = cpu_to_le32(data->old_sta_mask),
119 .u.modify.new_sta_mask = cpu_to_le32(data->new_sta_mask),
120 .u.modify.key_id = cpu_to_le32(key->keyidx),
121 .u.modify.key_flags =
122 cpu_to_le32(iwl_mvm_get_sec_flags(mvm, vif, sta, key)),
123 };
124 int err;
125
126 /* only need to do this for pairwise keys (link_id == -1) */
127 if (sta != data->sta || key->link_id >= 0)
128 return;
129
130 err = iwl_mvm_send_cmd_pdu(mvm, cmd_id, CMD_ASYNC, sizeof(cmd), &cmd);
131
132 if (err)
133 data->err = err;
134 }
135
iwl_mvm_mld_update_sta_keys(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 old_sta_mask,u32 new_sta_mask)136 int iwl_mvm_mld_update_sta_keys(struct iwl_mvm *mvm,
137 struct ieee80211_vif *vif,
138 struct ieee80211_sta *sta,
139 u32 old_sta_mask,
140 u32 new_sta_mask)
141 {
142 struct iwl_mvm_sta_key_update_data data = {
143 .sta = sta,
144 .old_sta_mask = old_sta_mask,
145 .new_sta_mask = new_sta_mask,
146 };
147
148 ieee80211_iter_keys_rcu(mvm->hw, vif, iwl_mvm_mld_update_sta_key,
149 &data);
150 return data.err;
151 }
152
__iwl_mvm_sec_key_del(struct iwl_mvm * mvm,u32 sta_mask,u32 key_flags,u32 keyidx,u32 flags)153 static int __iwl_mvm_sec_key_del(struct iwl_mvm *mvm, u32 sta_mask,
154 u32 key_flags, u32 keyidx, u32 flags)
155 {
156 u32 cmd_id = WIDE_ID(DATA_PATH_GROUP, SEC_KEY_CMD);
157 struct iwl_sec_key_cmd cmd = {
158 .action = cpu_to_le32(FW_CTXT_ACTION_REMOVE),
159 .u.remove.sta_mask = cpu_to_le32(sta_mask),
160 .u.remove.key_id = cpu_to_le32(keyidx),
161 .u.remove.key_flags = cpu_to_le32(key_flags),
162 };
163
164 return iwl_mvm_send_cmd_pdu(mvm, cmd_id, flags, sizeof(cmd), &cmd);
165 }
166
iwl_mvm_mld_send_key(struct iwl_mvm * mvm,u32 sta_mask,u32 key_flags,struct ieee80211_key_conf * keyconf)167 int iwl_mvm_mld_send_key(struct iwl_mvm *mvm, u32 sta_mask, u32 key_flags,
168 struct ieee80211_key_conf *keyconf)
169 {
170 u32 cmd_id = WIDE_ID(DATA_PATH_GROUP, SEC_KEY_CMD);
171 struct iwl_sec_key_cmd cmd = {
172 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
173 .u.add.sta_mask = cpu_to_le32(sta_mask),
174 .u.add.key_id = cpu_to_le32(keyconf->keyidx),
175 .u.add.key_flags = cpu_to_le32(key_flags),
176 .u.add.tx_seq = cpu_to_le64(atomic64_read(&keyconf->tx_pn)),
177 };
178 int max_key_len = sizeof(cmd.u.add.key);
179 int ret;
180
181 if (keyconf->cipher == WLAN_CIPHER_SUITE_WEP40 ||
182 keyconf->cipher == WLAN_CIPHER_SUITE_WEP104)
183 max_key_len -= IWL_SEC_WEP_KEY_OFFSET;
184
185 if (WARN_ON(keyconf->keylen > max_key_len))
186 return -EINVAL;
187
188 if (WARN_ON(!sta_mask))
189 return -EINVAL;
190
191 if (keyconf->cipher == WLAN_CIPHER_SUITE_WEP40 ||
192 keyconf->cipher == WLAN_CIPHER_SUITE_WEP104)
193 memcpy(cmd.u.add.key + IWL_SEC_WEP_KEY_OFFSET, keyconf->key,
194 keyconf->keylen);
195 else
196 memcpy(cmd.u.add.key, keyconf->key, keyconf->keylen);
197
198 if (keyconf->cipher == WLAN_CIPHER_SUITE_TKIP) {
199 memcpy(cmd.u.add.tkip_mic_rx_key,
200 keyconf->key + NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY,
201 8);
202 memcpy(cmd.u.add.tkip_mic_tx_key,
203 keyconf->key + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY,
204 8);
205 }
206
207 ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, sizeof(cmd), &cmd);
208 if (ret)
209 return ret;
210
211 /*
212 * For WEP, the same key is used for multicast and unicast so need to
213 * upload it again. If this fails, remove the original as well.
214 */
215 if (keyconf->cipher == WLAN_CIPHER_SUITE_WEP40 ||
216 keyconf->cipher == WLAN_CIPHER_SUITE_WEP104) {
217 cmd.u.add.key_flags ^= cpu_to_le32(IWL_SEC_KEY_FLAG_MCAST_KEY);
218 ret = iwl_mvm_send_cmd_pdu(mvm, cmd_id, 0, sizeof(cmd), &cmd);
219 if (ret)
220 __iwl_mvm_sec_key_del(mvm, sta_mask, key_flags,
221 keyconf->keyidx, 0);
222 }
223
224 return ret;
225 }
226
iwl_mvm_sec_key_add(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * keyconf)227 int iwl_mvm_sec_key_add(struct iwl_mvm *mvm,
228 struct ieee80211_vif *vif,
229 struct ieee80211_sta *sta,
230 struct ieee80211_key_conf *keyconf)
231 {
232 u32 sta_mask = iwl_mvm_get_sec_sta_mask(mvm, vif, sta, keyconf);
233 u32 key_flags = iwl_mvm_get_sec_flags(mvm, vif, sta, keyconf);
234 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
235 struct iwl_mvm_vif_link_info *mvm_link = NULL;
236 int ret;
237
238 if (keyconf->keyidx == 4 || keyconf->keyidx == 5) {
239 unsigned int link_id = 0;
240
241 /* set to -1 for non-MLO right now */
242 if (keyconf->link_id >= 0)
243 link_id = keyconf->link_id;
244
245 mvm_link = mvmvif->link[link_id];
246 if (WARN_ON(!mvm_link))
247 return -EINVAL;
248
249 if (mvm_link->igtk) {
250 IWL_DEBUG_MAC80211(mvm, "remove old IGTK %d\n",
251 mvm_link->igtk->keyidx);
252 ret = iwl_mvm_sec_key_del(mvm, vif, sta,
253 mvm_link->igtk);
254 if (ret)
255 IWL_ERR(mvm,
256 "failed to remove old IGTK (ret=%d)\n",
257 ret);
258 }
259
260 WARN_ON(mvm_link->igtk);
261 }
262
263 ret = iwl_mvm_mld_send_key(mvm, sta_mask, key_flags, keyconf);
264 if (ret)
265 return ret;
266
267 if (mvm_link)
268 mvm_link->igtk = keyconf;
269
270 /* We don't really need this, but need it to be not invalid,
271 * and if we switch links multiple times it might go to be
272 * invalid when removed.
273 */
274 keyconf->hw_key_idx = 0;
275
276 return 0;
277 }
278
_iwl_mvm_sec_key_del(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * keyconf,u32 flags)279 static int _iwl_mvm_sec_key_del(struct iwl_mvm *mvm,
280 struct ieee80211_vif *vif,
281 struct ieee80211_sta *sta,
282 struct ieee80211_key_conf *keyconf,
283 u32 flags)
284 {
285 u32 sta_mask = iwl_mvm_get_sec_sta_mask(mvm, vif, sta, keyconf);
286 u32 key_flags = iwl_mvm_get_sec_flags(mvm, vif, sta, keyconf);
287 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
288 int ret;
289
290 if (WARN_ON(!sta_mask))
291 return -EINVAL;
292
293 if (keyconf->keyidx == 4 || keyconf->keyidx == 5) {
294 struct iwl_mvm_vif_link_info *mvm_link;
295 unsigned int link_id = 0;
296
297 /* set to -1 for non-MLO right now */
298 if (keyconf->link_id >= 0)
299 link_id = keyconf->link_id;
300
301 mvm_link = mvmvif->link[link_id];
302 if (WARN_ON(!mvm_link))
303 return -EINVAL;
304
305 if (mvm_link->igtk == keyconf) {
306 /* no longer in HW - mark for later */
307 mvm_link->igtk->hw_key_idx = STA_KEY_IDX_INVALID;
308 mvm_link->igtk = NULL;
309 }
310 }
311
312 ret = __iwl_mvm_sec_key_del(mvm, sta_mask, key_flags, keyconf->keyidx,
313 flags);
314 if (ret)
315 return ret;
316
317 /* For WEP, delete the key again as unicast */
318 if (keyconf->cipher == WLAN_CIPHER_SUITE_WEP40 ||
319 keyconf->cipher == WLAN_CIPHER_SUITE_WEP104) {
320 key_flags ^= IWL_SEC_KEY_FLAG_MCAST_KEY;
321 ret = __iwl_mvm_sec_key_del(mvm, sta_mask, key_flags,
322 keyconf->keyidx, flags);
323 }
324
325 return ret;
326 }
327
iwl_mvm_sec_key_del(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * keyconf)328 int iwl_mvm_sec_key_del(struct iwl_mvm *mvm,
329 struct ieee80211_vif *vif,
330 struct ieee80211_sta *sta,
331 struct ieee80211_key_conf *keyconf)
332 {
333 return _iwl_mvm_sec_key_del(mvm, vif, sta, keyconf, 0);
334 }
335
iwl_mvm_sec_key_remove_ap_iter(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key,void * data)336 static void iwl_mvm_sec_key_remove_ap_iter(struct ieee80211_hw *hw,
337 struct ieee80211_vif *vif,
338 struct ieee80211_sta *sta,
339 struct ieee80211_key_conf *key,
340 void *data)
341 {
342 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
343 unsigned int link_id = (uintptr_t)data;
344
345 if (key->hw_key_idx == STA_KEY_IDX_INVALID)
346 return;
347
348 if (sta)
349 return;
350
351 if (key->link_id >= 0 && key->link_id != link_id)
352 return;
353
354 _iwl_mvm_sec_key_del(mvm, vif, NULL, key, CMD_ASYNC);
355 key->hw_key_idx = STA_KEY_IDX_INVALID;
356 }
357
iwl_mvm_sec_key_remove_ap(struct iwl_mvm * mvm,struct ieee80211_vif * vif,struct iwl_mvm_vif_link_info * link,unsigned int link_id)358 void iwl_mvm_sec_key_remove_ap(struct iwl_mvm *mvm,
359 struct ieee80211_vif *vif,
360 struct iwl_mvm_vif_link_info *link,
361 unsigned int link_id)
362 {
363 u32 sec_key_id = WIDE_ID(DATA_PATH_GROUP, SEC_KEY_CMD);
364 u8 sec_key_ver = iwl_fw_lookup_cmd_ver(mvm->fw, sec_key_id, 0);
365
366 if (WARN_ON_ONCE(vif->type != NL80211_IFTYPE_STATION ||
367 link->ap_sta_id == IWL_MVM_INVALID_STA))
368 return;
369
370 if (!sec_key_ver)
371 return;
372
373 ieee80211_iter_keys_rcu(mvm->hw, vif,
374 iwl_mvm_sec_key_remove_ap_iter,
375 (void *)(uintptr_t)link_id);
376 }
377
