1 /*
2 * hostapd / WPA authenticator glue code
3 * Copyright (c) 2002-2012, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "utils/includes.h"
10
11 #include "utils/common.h"
12 #include "utils/eloop.h"
13 #include "utils/list.h"
14 #include "common/ieee802_11_defs.h"
15 #include "common/sae.h"
16 #include "common/wpa_ctrl.h"
17 #include "common/ptksa_cache.h"
18 #include "crypto/sha1.h"
19 #include "eapol_auth/eapol_auth_sm.h"
20 #include "eapol_auth/eapol_auth_sm_i.h"
21 #include "eap_server/eap.h"
22 #include "l2_packet/l2_packet.h"
23 #include "eth_p_oui.h"
24 #include "hostapd.h"
25 #include "ieee802_1x.h"
26 #include "preauth_auth.h"
27 #include "sta_info.h"
28 #include "tkip_countermeasures.h"
29 #include "ap_drv_ops.h"
30 #include "ap_config.h"
31 #include "ieee802_11.h"
32 #include "pmksa_cache_auth.h"
33 #include "wpa_auth.h"
34 #include "wpa_auth_glue.h"
35
36
hostapd_wpa_auth_conf(struct hostapd_bss_config * conf,struct hostapd_config * iconf,struct wpa_auth_config * wconf)37 static void hostapd_wpa_auth_conf(struct hostapd_bss_config *conf,
38 struct hostapd_config *iconf,
39 struct wpa_auth_config *wconf)
40 {
41 int sae_pw_id;
42
43 os_memset(wconf, 0, sizeof(*wconf));
44 wconf->wpa = conf->wpa;
45 wconf->extended_key_id = conf->extended_key_id;
46 wconf->wpa_key_mgmt = conf->wpa_key_mgmt;
47 wconf->wpa_pairwise = conf->wpa_pairwise;
48 wconf->wpa_group = conf->wpa_group;
49 wconf->wpa_group_rekey = conf->wpa_group_rekey;
50 wconf->wpa_strict_rekey = conf->wpa_strict_rekey;
51 wconf->wpa_gmk_rekey = conf->wpa_gmk_rekey;
52 wconf->wpa_ptk_rekey = conf->wpa_ptk_rekey;
53 wconf->wpa_group_update_count = conf->wpa_group_update_count;
54 wconf->wpa_disable_eapol_key_retries =
55 conf->wpa_disable_eapol_key_retries;
56 wconf->wpa_pairwise_update_count = conf->wpa_pairwise_update_count;
57 wconf->rsn_pairwise = conf->rsn_pairwise;
58 wconf->rsn_preauth = conf->rsn_preauth;
59 wconf->eapol_version = conf->eapol_version;
60 #ifdef CONFIG_MACSEC
61 if (wconf->eapol_version > 2)
62 wconf->eapol_version = 2;
63 #endif /* CONFIG_MACSEC */
64 wconf->wmm_enabled = conf->wmm_enabled;
65 wconf->wmm_uapsd = conf->wmm_uapsd;
66 wconf->disable_pmksa_caching = conf->disable_pmksa_caching;
67 #ifdef CONFIG_OCV
68 wconf->ocv = conf->ocv;
69 #endif /* CONFIG_OCV */
70 wconf->okc = conf->okc;
71 wconf->ieee80211w = conf->ieee80211w;
72 wconf->beacon_prot = conf->beacon_prot;
73 wconf->group_mgmt_cipher = conf->group_mgmt_cipher;
74 wconf->sae_require_mfp = conf->sae_require_mfp;
75 #ifdef CONFIG_IEEE80211R_AP
76 wconf->ssid_len = conf->ssid.ssid_len;
77 if (wconf->ssid_len > SSID_MAX_LEN)
78 wconf->ssid_len = SSID_MAX_LEN;
79 os_memcpy(wconf->ssid, conf->ssid.ssid, wconf->ssid_len);
80 os_memcpy(wconf->mobility_domain, conf->mobility_domain,
81 MOBILITY_DOMAIN_ID_LEN);
82 if (conf->nas_identifier &&
83 os_strlen(conf->nas_identifier) <= FT_R0KH_ID_MAX_LEN) {
84 wconf->r0_key_holder_len = os_strlen(conf->nas_identifier);
85 os_memcpy(wconf->r0_key_holder, conf->nas_identifier,
86 wconf->r0_key_holder_len);
87 }
88 os_memcpy(wconf->r1_key_holder, conf->r1_key_holder, FT_R1KH_ID_LEN);
89 wconf->r0_key_lifetime = conf->r0_key_lifetime;
90 wconf->r1_max_key_lifetime = conf->r1_max_key_lifetime;
91 wconf->reassociation_deadline = conf->reassociation_deadline;
92 wconf->rkh_pos_timeout = conf->rkh_pos_timeout;
93 wconf->rkh_neg_timeout = conf->rkh_neg_timeout;
94 wconf->rkh_pull_timeout = conf->rkh_pull_timeout;
95 wconf->rkh_pull_retries = conf->rkh_pull_retries;
96 wconf->r0kh_list = &conf->r0kh_list;
97 wconf->r1kh_list = &conf->r1kh_list;
98 wconf->pmk_r1_push = conf->pmk_r1_push;
99 wconf->ft_over_ds = conf->ft_over_ds;
100 wconf->ft_psk_generate_local = conf->ft_psk_generate_local;
101 #endif /* CONFIG_IEEE80211R_AP */
102 #ifdef CONFIG_HS20
103 wconf->disable_gtk = conf->disable_dgaf;
104 if (conf->osen) {
105 wconf->disable_gtk = 1;
106 wconf->wpa = WPA_PROTO_OSEN;
107 wconf->wpa_key_mgmt = WPA_KEY_MGMT_OSEN;
108 wconf->wpa_pairwise = 0;
109 wconf->wpa_group = WPA_CIPHER_CCMP;
110 wconf->rsn_pairwise = WPA_CIPHER_CCMP;
111 wconf->rsn_preauth = 0;
112 wconf->disable_pmksa_caching = 1;
113 wconf->ieee80211w = 1;
114 }
115 #endif /* CONFIG_HS20 */
116 #ifdef CONFIG_TESTING_OPTIONS
117 wconf->corrupt_gtk_rekey_mic_probability =
118 iconf->corrupt_gtk_rekey_mic_probability;
119 if (conf->own_ie_override &&
120 wpabuf_len(conf->own_ie_override) <= MAX_OWN_IE_OVERRIDE) {
121 wconf->own_ie_override_len = wpabuf_len(conf->own_ie_override);
122 os_memcpy(wconf->own_ie_override,
123 wpabuf_head(conf->own_ie_override),
124 wconf->own_ie_override_len);
125 }
126 if (conf->rsne_override_eapol &&
127 wpabuf_len(conf->rsne_override_eapol) <= MAX_OWN_IE_OVERRIDE) {
128 wconf->rsne_override_eapol_set = 1;
129 wconf->rsne_override_eapol_len =
130 wpabuf_len(conf->rsne_override_eapol);
131 os_memcpy(wconf->rsne_override_eapol,
132 wpabuf_head(conf->rsne_override_eapol),
133 wconf->rsne_override_eapol_len);
134 }
135 if (conf->rsnxe_override_eapol &&
136 wpabuf_len(conf->rsnxe_override_eapol) <= MAX_OWN_IE_OVERRIDE) {
137 wconf->rsnxe_override_eapol_set = 1;
138 wconf->rsnxe_override_eapol_len =
139 wpabuf_len(conf->rsnxe_override_eapol);
140 os_memcpy(wconf->rsnxe_override_eapol,
141 wpabuf_head(conf->rsnxe_override_eapol),
142 wconf->rsnxe_override_eapol_len);
143 }
144 if (conf->rsne_override_ft &&
145 wpabuf_len(conf->rsne_override_ft) <= MAX_OWN_IE_OVERRIDE) {
146 wconf->rsne_override_ft_set = 1;
147 wconf->rsne_override_ft_len =
148 wpabuf_len(conf->rsne_override_ft);
149 os_memcpy(wconf->rsne_override_ft,
150 wpabuf_head(conf->rsne_override_ft),
151 wconf->rsne_override_ft_len);
152 }
153 if (conf->rsnxe_override_ft &&
154 wpabuf_len(conf->rsnxe_override_ft) <= MAX_OWN_IE_OVERRIDE) {
155 wconf->rsnxe_override_ft_set = 1;
156 wconf->rsnxe_override_ft_len =
157 wpabuf_len(conf->rsnxe_override_ft);
158 os_memcpy(wconf->rsnxe_override_ft,
159 wpabuf_head(conf->rsnxe_override_ft),
160 wconf->rsnxe_override_ft_len);
161 }
162 if (conf->gtk_rsc_override &&
163 wpabuf_len(conf->gtk_rsc_override) > 0 &&
164 wpabuf_len(conf->gtk_rsc_override) <= WPA_KEY_RSC_LEN) {
165 os_memcpy(wconf->gtk_rsc_override,
166 wpabuf_head(conf->gtk_rsc_override),
167 wpabuf_len(conf->gtk_rsc_override));
168 wconf->gtk_rsc_override_set = 1;
169 }
170 if (conf->igtk_rsc_override &&
171 wpabuf_len(conf->igtk_rsc_override) > 0 &&
172 wpabuf_len(conf->igtk_rsc_override) <= WPA_KEY_RSC_LEN) {
173 os_memcpy(wconf->igtk_rsc_override,
174 wpabuf_head(conf->igtk_rsc_override),
175 wpabuf_len(conf->igtk_rsc_override));
176 wconf->igtk_rsc_override_set = 1;
177 }
178 wconf->ft_rsnxe_used = conf->ft_rsnxe_used;
179 wconf->oci_freq_override_eapol_m3 = conf->oci_freq_override_eapol_m3;
180 wconf->oci_freq_override_eapol_g1 = conf->oci_freq_override_eapol_g1;
181 wconf->oci_freq_override_ft_assoc = conf->oci_freq_override_ft_assoc;
182 wconf->oci_freq_override_fils_assoc =
183 conf->oci_freq_override_fils_assoc;
184 #endif /* CONFIG_TESTING_OPTIONS */
185 #ifdef CONFIG_P2P
186 os_memcpy(wconf->ip_addr_go, conf->ip_addr_go, 4);
187 os_memcpy(wconf->ip_addr_mask, conf->ip_addr_mask, 4);
188 os_memcpy(wconf->ip_addr_start, conf->ip_addr_start, 4);
189 os_memcpy(wconf->ip_addr_end, conf->ip_addr_end, 4);
190 #endif /* CONFIG_P2P */
191 #ifdef CONFIG_FILS
192 wconf->fils_cache_id_set = conf->fils_cache_id_set;
193 os_memcpy(wconf->fils_cache_id, conf->fils_cache_id,
194 FILS_CACHE_ID_LEN);
195 #endif /* CONFIG_FILS */
196 wconf->sae_pwe = conf->sae_pwe;
197 sae_pw_id = hostapd_sae_pw_id_in_use(conf);
198 if (sae_pw_id == 2 && wconf->sae_pwe != 3)
199 wconf->sae_pwe = 1;
200 else if (sae_pw_id == 1 && wconf->sae_pwe == 0)
201 wconf->sae_pwe = 2;
202 #ifdef CONFIG_SAE_PK
203 wconf->sae_pk = hostapd_sae_pk_in_use(conf);
204 #endif /* CONFIG_SAE_PK */
205 #ifdef CONFIG_OWE
206 wconf->owe_ptk_workaround = conf->owe_ptk_workaround;
207 #endif /* CONFIG_OWE */
208 wconf->transition_disable = conf->transition_disable;
209 #ifdef CONFIG_DPP2
210 wconf->dpp_pfs = conf->dpp_pfs;
211 #endif /* CONFIG_DPP2 */
212 #ifdef CONFIG_PASN
213 #ifdef CONFIG_TESTING_OPTIONS
214 wconf->force_kdk_derivation = conf->force_kdk_derivation;
215 #endif /* CONFIG_TESTING_OPTIONS */
216 #endif /* CONFIG_PASN */
217 }
218
219
hostapd_wpa_auth_logger(void * ctx,const u8 * addr,logger_level level,const char * txt)220 static void hostapd_wpa_auth_logger(void *ctx, const u8 *addr,
221 logger_level level, const char *txt)
222 {
223 #ifndef CONFIG_NO_HOSTAPD_LOGGER
224 struct hostapd_data *hapd = ctx;
225 int hlevel;
226
227 switch (level) {
228 case LOGGER_WARNING:
229 hlevel = HOSTAPD_LEVEL_WARNING;
230 break;
231 case LOGGER_INFO:
232 hlevel = HOSTAPD_LEVEL_INFO;
233 break;
234 case LOGGER_DEBUG:
235 default:
236 hlevel = HOSTAPD_LEVEL_DEBUG;
237 break;
238 }
239
240 hostapd_logger(hapd, addr, HOSTAPD_MODULE_WPA, hlevel, "%s", txt);
241 #endif /* CONFIG_NO_HOSTAPD_LOGGER */
242 }
243
244
hostapd_wpa_auth_disconnect(void * ctx,const u8 * addr,u16 reason)245 static void hostapd_wpa_auth_disconnect(void *ctx, const u8 *addr,
246 u16 reason)
247 {
248 struct hostapd_data *hapd = ctx;
249 wpa_printf(MSG_DEBUG, "%s: WPA authenticator requests disconnect: "
250 "STA " MACSTR " reason %d",
251 __func__, MAC2STR(addr), reason);
252 ap_sta_disconnect(hapd, NULL, addr, reason);
253 }
254
255
hostapd_wpa_auth_mic_failure_report(void * ctx,const u8 * addr)256 static int hostapd_wpa_auth_mic_failure_report(void *ctx, const u8 *addr)
257 {
258 struct hostapd_data *hapd = ctx;
259 return michael_mic_failure(hapd, addr, 0);
260 }
261
262
hostapd_wpa_auth_psk_failure_report(void * ctx,const u8 * addr)263 static void hostapd_wpa_auth_psk_failure_report(void *ctx, const u8 *addr)
264 {
265 struct hostapd_data *hapd = ctx;
266 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_STA_POSSIBLE_PSK_MISMATCH MACSTR,
267 MAC2STR(addr));
268 }
269
270
hostapd_wpa_auth_set_eapol(void * ctx,const u8 * addr,wpa_eapol_variable var,int value)271 static void hostapd_wpa_auth_set_eapol(void *ctx, const u8 *addr,
272 wpa_eapol_variable var, int value)
273 {
274 struct hostapd_data *hapd = ctx;
275 struct sta_info *sta = ap_get_sta(hapd, addr);
276 if (sta == NULL)
277 return;
278 switch (var) {
279 case WPA_EAPOL_portEnabled:
280 ieee802_1x_notify_port_enabled(sta->eapol_sm, value);
281 break;
282 case WPA_EAPOL_portValid:
283 ieee802_1x_notify_port_valid(sta->eapol_sm, value);
284 break;
285 case WPA_EAPOL_authorized:
286 ieee802_1x_set_sta_authorized(hapd, sta, value);
287 break;
288 case WPA_EAPOL_portControl_Auto:
289 if (sta->eapol_sm)
290 sta->eapol_sm->portControl = Auto;
291 break;
292 case WPA_EAPOL_keyRun:
293 if (sta->eapol_sm)
294 sta->eapol_sm->keyRun = value;
295 break;
296 case WPA_EAPOL_keyAvailable:
297 if (sta->eapol_sm)
298 sta->eapol_sm->eap_if->eapKeyAvailable = value;
299 break;
300 case WPA_EAPOL_keyDone:
301 if (sta->eapol_sm)
302 sta->eapol_sm->keyDone = value;
303 break;
304 case WPA_EAPOL_inc_EapolFramesTx:
305 if (sta->eapol_sm)
306 sta->eapol_sm->dot1xAuthEapolFramesTx++;
307 break;
308 }
309 }
310
311
hostapd_wpa_auth_get_eapol(void * ctx,const u8 * addr,wpa_eapol_variable var)312 static int hostapd_wpa_auth_get_eapol(void *ctx, const u8 *addr,
313 wpa_eapol_variable var)
314 {
315 struct hostapd_data *hapd = ctx;
316 struct sta_info *sta = ap_get_sta(hapd, addr);
317 if (sta == NULL || sta->eapol_sm == NULL)
318 return -1;
319 switch (var) {
320 case WPA_EAPOL_keyRun:
321 return sta->eapol_sm->keyRun;
322 case WPA_EAPOL_keyAvailable:
323 return sta->eapol_sm->eap_if->eapKeyAvailable;
324 default:
325 return -1;
326 }
327 }
328
329
hostapd_wpa_auth_get_psk(void * ctx,const u8 * addr,const u8 * p2p_dev_addr,const u8 * prev_psk,size_t * psk_len,int * vlan_id)330 static const u8 * hostapd_wpa_auth_get_psk(void *ctx, const u8 *addr,
331 const u8 *p2p_dev_addr,
332 const u8 *prev_psk, size_t *psk_len,
333 int *vlan_id)
334 {
335 struct hostapd_data *hapd = ctx;
336 struct sta_info *sta = ap_get_sta(hapd, addr);
337 const u8 *psk;
338
339 if (vlan_id)
340 *vlan_id = 0;
341 if (psk_len)
342 *psk_len = PMK_LEN;
343
344 #ifdef CONFIG_SAE
345 if (sta && sta->auth_alg == WLAN_AUTH_SAE) {
346 if (!sta->sae || prev_psk)
347 return NULL;
348 return sta->sae->pmk;
349 }
350 if (sta && wpa_auth_uses_sae(sta->wpa_sm)) {
351 wpa_printf(MSG_DEBUG,
352 "No PSK for STA trying to use SAE with PMKSA caching");
353 return NULL;
354 }
355 #endif /* CONFIG_SAE */
356
357 #ifdef CONFIG_OWE
358 if ((hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_OWE) &&
359 sta && sta->owe_pmk) {
360 if (psk_len)
361 *psk_len = sta->owe_pmk_len;
362 return sta->owe_pmk;
363 }
364 if ((hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_OWE) && sta) {
365 struct rsn_pmksa_cache_entry *sa;
366
367 sa = wpa_auth_sta_get_pmksa(sta->wpa_sm);
368 if (sa && sa->akmp == WPA_KEY_MGMT_OWE) {
369 if (psk_len)
370 *psk_len = sa->pmk_len;
371 return sa->pmk;
372 }
373 }
374 #endif /* CONFIG_OWE */
375
376 psk = hostapd_get_psk(hapd->conf, addr, p2p_dev_addr, prev_psk,
377 vlan_id);
378 /*
379 * This is about to iterate over all psks, prev_psk gives the last
380 * returned psk which should not be returned again.
381 * logic list (all hostapd_get_psk; all sta->psk)
382 */
383 if (sta && sta->psk && !psk) {
384 struct hostapd_sta_wpa_psk_short *pos;
385
386 if (vlan_id)
387 *vlan_id = 0;
388 psk = sta->psk->psk;
389 for (pos = sta->psk; pos; pos = pos->next) {
390 if (pos->is_passphrase) {
391 pbkdf2_sha1(pos->passphrase,
392 hapd->conf->ssid.ssid,
393 hapd->conf->ssid.ssid_len, 4096,
394 pos->psk, PMK_LEN);
395 pos->is_passphrase = 0;
396 }
397 if (pos->psk == prev_psk) {
398 psk = pos->next ? pos->next->psk : NULL;
399 break;
400 }
401 }
402 }
403 return psk;
404 }
405
406
hostapd_wpa_auth_get_msk(void * ctx,const u8 * addr,u8 * msk,size_t * len)407 static int hostapd_wpa_auth_get_msk(void *ctx, const u8 *addr, u8 *msk,
408 size_t *len)
409 {
410 struct hostapd_data *hapd = ctx;
411 const u8 *key;
412 size_t keylen;
413 struct sta_info *sta;
414
415 sta = ap_get_sta(hapd, addr);
416 if (sta == NULL) {
417 wpa_printf(MSG_DEBUG, "AUTH_GET_MSK: Cannot find STA");
418 return -1;
419 }
420
421 key = ieee802_1x_get_key(sta->eapol_sm, &keylen);
422 if (key == NULL) {
423 wpa_printf(MSG_DEBUG, "AUTH_GET_MSK: Key is null, eapol_sm: %p",
424 sta->eapol_sm);
425 return -1;
426 }
427
428 if (keylen > *len)
429 keylen = *len;
430 os_memcpy(msk, key, keylen);
431 *len = keylen;
432
433 return 0;
434 }
435
436
hostapd_wpa_auth_set_key(void * ctx,int vlan_id,enum wpa_alg alg,const u8 * addr,int idx,u8 * key,size_t key_len,enum key_flag key_flag)437 static int hostapd_wpa_auth_set_key(void *ctx, int vlan_id, enum wpa_alg alg,
438 const u8 *addr, int idx, u8 *key,
439 size_t key_len, enum key_flag key_flag)
440 {
441 struct hostapd_data *hapd = ctx;
442 const char *ifname = hapd->conf->iface;
443
444 if (vlan_id > 0) {
445 ifname = hostapd_get_vlan_id_ifname(hapd->conf->vlan, vlan_id);
446 if (!ifname) {
447 if (!(hapd->iface->drv_flags &
448 WPA_DRIVER_FLAGS_VLAN_OFFLOAD))
449 return -1;
450 ifname = hapd->conf->iface;
451 }
452 }
453
454 #ifdef CONFIG_TESTING_OPTIONS
455 if (key_flag & KEY_FLAG_MODIFY) {
456 /* We are updating an already installed key. Don't overwrite
457 * the already stored key information with zeros.
458 */
459 } else if (addr && !is_broadcast_ether_addr(addr)) {
460 struct sta_info *sta;
461
462 sta = ap_get_sta(hapd, addr);
463 if (sta) {
464 sta->last_tk_alg = alg;
465 sta->last_tk_key_idx = idx;
466 if (key)
467 os_memcpy(sta->last_tk, key, key_len);
468 sta->last_tk_len = key_len;
469 }
470 } else if (alg == WPA_ALG_BIP_CMAC_128 ||
471 alg == WPA_ALG_BIP_GMAC_128 ||
472 alg == WPA_ALG_BIP_GMAC_256 ||
473 alg == WPA_ALG_BIP_CMAC_256) {
474 if (idx == 4 || idx == 5) {
475 hapd->last_igtk_alg = alg;
476 hapd->last_igtk_key_idx = idx;
477 if (key)
478 os_memcpy(hapd->last_igtk, key, key_len);
479 hapd->last_igtk_len = key_len;
480 } else if (idx == 6 || idx == 7) {
481 hapd->last_bigtk_alg = alg;
482 hapd->last_bigtk_key_idx = idx;
483 if (key)
484 os_memcpy(hapd->last_bigtk, key, key_len);
485 hapd->last_bigtk_len = key_len;
486 }
487 } else {
488 hapd->last_gtk_alg = alg;
489 hapd->last_gtk_key_idx = idx;
490 if (key)
491 os_memcpy(hapd->last_gtk, key, key_len);
492 hapd->last_gtk_len = key_len;
493 }
494 #endif /* CONFIG_TESTING_OPTIONS */
495 return hostapd_drv_set_key(ifname, hapd, alg, addr, idx, vlan_id, 1,
496 NULL, 0, key, key_len, key_flag);
497 }
498
499
hostapd_wpa_auth_get_seqnum(void * ctx,const u8 * addr,int idx,u8 * seq)500 static int hostapd_wpa_auth_get_seqnum(void *ctx, const u8 *addr, int idx,
501 u8 *seq)
502 {
503 struct hostapd_data *hapd = ctx;
504 return hostapd_get_seqnum(hapd->conf->iface, hapd, addr, idx, seq);
505 }
506
507
hostapd_wpa_auth_send_eapol(void * ctx,const u8 * addr,const u8 * data,size_t data_len,int encrypt)508 int hostapd_wpa_auth_send_eapol(void *ctx, const u8 *addr,
509 const u8 *data, size_t data_len,
510 int encrypt)
511 {
512 struct hostapd_data *hapd = ctx;
513 struct sta_info *sta;
514 u32 flags = 0;
515
516 #ifdef CONFIG_TESTING_OPTIONS
517 if (hapd->ext_eapol_frame_io) {
518 size_t hex_len = 2 * data_len + 1;
519 char *hex = os_malloc(hex_len);
520
521 if (hex == NULL)
522 return -1;
523 wpa_snprintf_hex(hex, hex_len, data, data_len);
524 wpa_msg(hapd->msg_ctx, MSG_INFO, "EAPOL-TX " MACSTR " %s",
525 MAC2STR(addr), hex);
526 os_free(hex);
527 return 0;
528 }
529 #endif /* CONFIG_TESTING_OPTIONS */
530
531 sta = ap_get_sta(hapd, addr);
532 if (sta)
533 flags = hostapd_sta_flags_to_drv(sta->flags);
534
535 return hostapd_drv_hapd_send_eapol(hapd, addr, data, data_len,
536 encrypt, flags);
537 }
538
539
hostapd_wpa_auth_for_each_sta(void * ctx,int (* cb)(struct wpa_state_machine * sm,void * ctx),void * cb_ctx)540 static int hostapd_wpa_auth_for_each_sta(
541 void *ctx, int (*cb)(struct wpa_state_machine *sm, void *ctx),
542 void *cb_ctx)
543 {
544 struct hostapd_data *hapd = ctx;
545 struct sta_info *sta;
546
547 for (sta = hapd->sta_list; sta; sta = sta->next) {
548 if (sta->wpa_sm && cb(sta->wpa_sm, cb_ctx))
549 return 1;
550 }
551 return 0;
552 }
553
554
555 struct wpa_auth_iface_iter_data {
556 int (*cb)(struct wpa_authenticator *sm, void *ctx);
557 void *cb_ctx;
558 };
559
wpa_auth_iface_iter(struct hostapd_iface * iface,void * ctx)560 static int wpa_auth_iface_iter(struct hostapd_iface *iface, void *ctx)
561 {
562 struct wpa_auth_iface_iter_data *data = ctx;
563 size_t i;
564 for (i = 0; i < iface->num_bss; i++) {
565 if (iface->bss[i]->wpa_auth &&
566 data->cb(iface->bss[i]->wpa_auth, data->cb_ctx))
567 return 1;
568 }
569 return 0;
570 }
571
572
hostapd_wpa_auth_for_each_auth(void * ctx,int (* cb)(struct wpa_authenticator * sm,void * ctx),void * cb_ctx)573 static int hostapd_wpa_auth_for_each_auth(
574 void *ctx, int (*cb)(struct wpa_authenticator *sm, void *ctx),
575 void *cb_ctx)
576 {
577 struct hostapd_data *hapd = ctx;
578 struct wpa_auth_iface_iter_data data;
579 if (hapd->iface->interfaces == NULL ||
580 hapd->iface->interfaces->for_each_interface == NULL)
581 return -1;
582 data.cb = cb;
583 data.cb_ctx = cb_ctx;
584 return hapd->iface->interfaces->for_each_interface(
585 hapd->iface->interfaces, wpa_auth_iface_iter, &data);
586 }
587
588
589 #ifdef CONFIG_IEEE80211R_AP
590
591 struct wpa_ft_rrb_rx_later_data {
592 struct dl_list list;
593 u8 addr[ETH_ALEN];
594 size_t data_len;
595 /* followed by data_len octets of data */
596 };
597
hostapd_wpa_ft_rrb_rx_later(void * eloop_ctx,void * timeout_ctx)598 static void hostapd_wpa_ft_rrb_rx_later(void *eloop_ctx, void *timeout_ctx)
599 {
600 struct hostapd_data *hapd = eloop_ctx;
601 struct wpa_ft_rrb_rx_later_data *data, *n;
602
603 dl_list_for_each_safe(data, n, &hapd->l2_queue,
604 struct wpa_ft_rrb_rx_later_data, list) {
605 if (hapd->wpa_auth) {
606 wpa_ft_rrb_rx(hapd->wpa_auth, data->addr,
607 (const u8 *) (data + 1),
608 data->data_len);
609 }
610 dl_list_del(&data->list);
611 os_free(data);
612 }
613 }
614
615
616 struct wpa_auth_ft_iface_iter_data {
617 struct hostapd_data *src_hapd;
618 const u8 *dst;
619 const u8 *data;
620 size_t data_len;
621 };
622
623
hostapd_wpa_auth_ft_iter(struct hostapd_iface * iface,void * ctx)624 static int hostapd_wpa_auth_ft_iter(struct hostapd_iface *iface, void *ctx)
625 {
626 struct wpa_auth_ft_iface_iter_data *idata = ctx;
627 struct wpa_ft_rrb_rx_later_data *data;
628 struct hostapd_data *hapd;
629 size_t j;
630
631 for (j = 0; j < iface->num_bss; j++) {
632 hapd = iface->bss[j];
633 if (hapd == idata->src_hapd ||
634 !hapd->wpa_auth ||
635 os_memcmp(hapd->own_addr, idata->dst, ETH_ALEN) != 0)
636 continue;
637
638 wpa_printf(MSG_DEBUG,
639 "FT: Send RRB data directly to locally managed BSS "
640 MACSTR "@%s -> " MACSTR "@%s",
641 MAC2STR(idata->src_hapd->own_addr),
642 idata->src_hapd->conf->iface,
643 MAC2STR(hapd->own_addr), hapd->conf->iface);
644
645 /* Defer wpa_ft_rrb_rx() until next eloop step as this is
646 * when it would be triggered when reading from a socket.
647 * This avoids
648 * hapd0:send -> hapd1:recv -> hapd1:send -> hapd0:recv,
649 * that is calling hapd0:recv handler from within
650 * hapd0:send directly.
651 */
652 data = os_zalloc(sizeof(*data) + idata->data_len);
653 if (!data)
654 return 1;
655
656 os_memcpy(data->addr, idata->src_hapd->own_addr, ETH_ALEN);
657 os_memcpy(data + 1, idata->data, idata->data_len);
658 data->data_len = idata->data_len;
659
660 dl_list_add(&hapd->l2_queue, &data->list);
661
662 if (!eloop_is_timeout_registered(hostapd_wpa_ft_rrb_rx_later,
663 hapd, NULL))
664 eloop_register_timeout(0, 0,
665 hostapd_wpa_ft_rrb_rx_later,
666 hapd, NULL);
667
668 return 1;
669 }
670
671 return 0;
672 }
673
674 #endif /* CONFIG_IEEE80211R_AP */
675
676
hostapd_wpa_auth_send_ether(void * ctx,const u8 * dst,u16 proto,const u8 * data,size_t data_len)677 static int hostapd_wpa_auth_send_ether(void *ctx, const u8 *dst, u16 proto,
678 const u8 *data, size_t data_len)
679 {
680 struct hostapd_data *hapd = ctx;
681 struct l2_ethhdr *buf;
682 int ret;
683
684 #ifdef CONFIG_TESTING_OPTIONS
685 if (hapd->ext_eapol_frame_io && proto == ETH_P_EAPOL) {
686 size_t hex_len = 2 * data_len + 1;
687 char *hex = os_malloc(hex_len);
688
689 if (hex == NULL)
690 return -1;
691 wpa_snprintf_hex(hex, hex_len, data, data_len);
692 wpa_msg(hapd->msg_ctx, MSG_INFO, "EAPOL-TX " MACSTR " %s",
693 MAC2STR(dst), hex);
694 os_free(hex);
695 return 0;
696 }
697 #endif /* CONFIG_TESTING_OPTIONS */
698
699 #ifdef CONFIG_IEEE80211R_AP
700 if (proto == ETH_P_RRB && hapd->iface->interfaces &&
701 hapd->iface->interfaces->for_each_interface) {
702 int res;
703 struct wpa_auth_ft_iface_iter_data idata;
704 idata.src_hapd = hapd;
705 idata.dst = dst;
706 idata.data = data;
707 idata.data_len = data_len;
708 res = hapd->iface->interfaces->for_each_interface(
709 hapd->iface->interfaces, hostapd_wpa_auth_ft_iter,
710 &idata);
711 if (res == 1)
712 return data_len;
713 }
714 #endif /* CONFIG_IEEE80211R_AP */
715
716 if (hapd->l2 == NULL)
717 return -1;
718
719 buf = os_malloc(sizeof(*buf) + data_len);
720 if (buf == NULL)
721 return -1;
722 os_memcpy(buf->h_dest, dst, ETH_ALEN);
723 os_memcpy(buf->h_source, hapd->own_addr, ETH_ALEN);
724 buf->h_proto = host_to_be16(proto);
725 os_memcpy(buf + 1, data, data_len);
726 ret = l2_packet_send(hapd->l2, dst, proto, (u8 *) buf,
727 sizeof(*buf) + data_len);
728 os_free(buf);
729 return ret;
730 }
731
732
733 #ifdef CONFIG_ETH_P_OUI
hostapd_wpa_get_oui(struct hostapd_data * hapd,u8 oui_suffix)734 static struct eth_p_oui_ctx * hostapd_wpa_get_oui(struct hostapd_data *hapd,
735 u8 oui_suffix)
736 {
737 switch (oui_suffix) {
738 #ifdef CONFIG_IEEE80211R_AP
739 case FT_PACKET_R0KH_R1KH_PULL:
740 return hapd->oui_pull;
741 case FT_PACKET_R0KH_R1KH_RESP:
742 return hapd->oui_resp;
743 case FT_PACKET_R0KH_R1KH_PUSH:
744 return hapd->oui_push;
745 case FT_PACKET_R0KH_R1KH_SEQ_REQ:
746 return hapd->oui_sreq;
747 case FT_PACKET_R0KH_R1KH_SEQ_RESP:
748 return hapd->oui_sresp;
749 #endif /* CONFIG_IEEE80211R_AP */
750 default:
751 return NULL;
752 }
753 }
754 #endif /* CONFIG_ETH_P_OUI */
755
756
757 #ifdef CONFIG_IEEE80211R_AP
758
759 struct oui_deliver_later_data {
760 struct dl_list list;
761 u8 src_addr[ETH_ALEN];
762 u8 dst_addr[ETH_ALEN];
763 size_t data_len;
764 u8 oui_suffix;
765 /* followed by data_len octets of data */
766 };
767
hostapd_oui_deliver_later(void * eloop_ctx,void * timeout_ctx)768 static void hostapd_oui_deliver_later(void *eloop_ctx, void *timeout_ctx)
769 {
770 struct hostapd_data *hapd = eloop_ctx;
771 struct oui_deliver_later_data *data, *n;
772 struct eth_p_oui_ctx *oui_ctx;
773
774 dl_list_for_each_safe(data, n, &hapd->l2_oui_queue,
775 struct oui_deliver_later_data, list) {
776 oui_ctx = hostapd_wpa_get_oui(hapd, data->oui_suffix);
777 wpa_printf(MSG_DEBUG, "RRB(%s): %s src=" MACSTR " dst=" MACSTR
778 " oui_suffix=%u data_len=%u data=%p",
779 hapd->conf->iface, __func__,
780 MAC2STR(data->src_addr), MAC2STR(data->dst_addr),
781 data->oui_suffix, (unsigned int) data->data_len,
782 data);
783 if (hapd->wpa_auth && oui_ctx) {
784 eth_p_oui_deliver(oui_ctx, data->src_addr,
785 data->dst_addr,
786 (const u8 *) (data + 1),
787 data->data_len);
788 }
789 dl_list_del(&data->list);
790 os_free(data);
791 }
792 }
793
794
795 struct wpa_auth_oui_iface_iter_data {
796 struct hostapd_data *src_hapd;
797 const u8 *dst_addr;
798 const u8 *data;
799 size_t data_len;
800 u8 oui_suffix;
801 };
802
hostapd_wpa_auth_oui_iter(struct hostapd_iface * iface,void * ctx)803 static int hostapd_wpa_auth_oui_iter(struct hostapd_iface *iface, void *ctx)
804 {
805 struct wpa_auth_oui_iface_iter_data *idata = ctx;
806 struct oui_deliver_later_data *data;
807 struct hostapd_data *hapd, *src_hapd = idata->src_hapd;
808 size_t j;
809
810 for (j = 0; j < iface->num_bss; j++) {
811 hapd = iface->bss[j];
812 if (hapd == src_hapd)
813 continue; /* don't deliver back to same interface */
814 if (!wpa_key_mgmt_ft(hapd->conf->wpa_key_mgmt) ||
815 hapd->conf->ssid.ssid_len !=
816 src_hapd->conf->ssid.ssid_len ||
817 os_memcmp(hapd->conf->ssid.ssid,
818 src_hapd->conf->ssid.ssid,
819 hapd->conf->ssid.ssid_len) != 0 ||
820 os_memcmp(hapd->conf->mobility_domain,
821 src_hapd->conf->mobility_domain,
822 MOBILITY_DOMAIN_ID_LEN) != 0)
823 continue; /* no matching FT SSID/mobility domain */
824 if (!is_multicast_ether_addr(idata->dst_addr) &&
825 os_memcmp(hapd->own_addr, idata->dst_addr, ETH_ALEN) != 0)
826 continue; /* destination address does not match */
827
828 /* defer eth_p_oui_deliver until next eloop step as this is
829 * when it would be triggerd from reading from sock
830 * This avoids
831 * hapd0:send -> hapd1:recv -> hapd1:send -> hapd0:recv,
832 * that is calling hapd0:recv handler from within
833 * hapd0:send directly.
834 */
835 data = os_zalloc(sizeof(*data) + idata->data_len);
836 if (!data)
837 return 1;
838 wpa_printf(MSG_DEBUG,
839 "RRB(%s): local delivery to %s dst=" MACSTR
840 " oui_suffix=%u data_len=%u data=%p",
841 src_hapd->conf->iface, hapd->conf->iface,
842 MAC2STR(idata->dst_addr), idata->oui_suffix,
843 (unsigned int) idata->data_len, data);
844
845 os_memcpy(data->src_addr, src_hapd->own_addr, ETH_ALEN);
846 os_memcpy(data->dst_addr, idata->dst_addr, ETH_ALEN);
847 os_memcpy(data + 1, idata->data, idata->data_len);
848 data->data_len = idata->data_len;
849 data->oui_suffix = idata->oui_suffix;
850
851 dl_list_add_tail(&hapd->l2_oui_queue, &data->list);
852
853 if (!eloop_is_timeout_registered(hostapd_oui_deliver_later,
854 hapd, NULL))
855 eloop_register_timeout(0, 0,
856 hostapd_oui_deliver_later,
857 hapd, NULL);
858
859 /* If dst_addr is a multicast address, do not return any
860 * non-zero value here. Otherwise, the iteration of
861 * for_each_interface() will be stopped. */
862 if (!is_multicast_ether_addr(idata->dst_addr))
863 return 1;
864 }
865
866 return 0;
867 }
868
869 #endif /* CONFIG_IEEE80211R_AP */
870
871
hostapd_wpa_auth_send_oui(void * ctx,const u8 * dst,u8 oui_suffix,const u8 * data,size_t data_len)872 static int hostapd_wpa_auth_send_oui(void *ctx, const u8 *dst, u8 oui_suffix,
873 const u8 *data, size_t data_len)
874 {
875 #ifdef CONFIG_ETH_P_OUI
876 struct hostapd_data *hapd = ctx;
877 struct eth_p_oui_ctx *oui_ctx;
878
879 wpa_printf(MSG_DEBUG, "RRB(%s): send to dst=" MACSTR
880 " oui_suffix=%u data_len=%u",
881 hapd->conf->iface, MAC2STR(dst), oui_suffix,
882 (unsigned int) data_len);
883 #ifdef CONFIG_IEEE80211R_AP
884 if (hapd->iface->interfaces &&
885 hapd->iface->interfaces->for_each_interface) {
886 struct wpa_auth_oui_iface_iter_data idata;
887 int res;
888
889 idata.src_hapd = hapd;
890 idata.dst_addr = dst;
891 idata.data = data;
892 idata.data_len = data_len;
893 idata.oui_suffix = oui_suffix;
894 res = hapd->iface->interfaces->for_each_interface(
895 hapd->iface->interfaces, hostapd_wpa_auth_oui_iter,
896 &idata);
897 if (res == 1)
898 return data_len;
899 }
900 #endif /* CONFIG_IEEE80211R_AP */
901
902 oui_ctx = hostapd_wpa_get_oui(hapd, oui_suffix);
903 if (!oui_ctx)
904 return -1;
905
906 return eth_p_oui_send(oui_ctx, hapd->own_addr, dst, data, data_len);
907 #else /* CONFIG_ETH_P_OUI */
908 return -1;
909 #endif /* CONFIG_ETH_P_OUI */
910 }
911
912
hostapd_channel_info(void * ctx,struct wpa_channel_info * ci)913 static int hostapd_channel_info(void *ctx, struct wpa_channel_info *ci)
914 {
915 struct hostapd_data *hapd = ctx;
916
917 return hostapd_drv_channel_info(hapd, ci);
918 }
919
920
921 #ifdef CONFIG_PASN
922
hostapd_store_ptksa(void * ctx,const u8 * addr,int cipher,u32 life_time,const struct wpa_ptk * ptk)923 static void hostapd_store_ptksa(void *ctx, const u8 *addr,int cipher,
924 u32 life_time, const struct wpa_ptk *ptk)
925 {
926 struct hostapd_data *hapd = ctx;
927
928 ptksa_cache_add(hapd->ptksa, addr, cipher, life_time, ptk);
929 }
930
931
hostapd_clear_ptksa(void * ctx,const u8 * addr,int cipher)932 static void hostapd_clear_ptksa(void *ctx, const u8 *addr, int cipher)
933 {
934 struct hostapd_data *hapd = ctx;
935
936 ptksa_cache_flush(hapd->ptksa, addr, cipher);
937 }
938
939 #endif /* CONFIG_PASN */
940
941
hostapd_wpa_auth_update_vlan(void * ctx,const u8 * addr,int vlan_id)942 static int hostapd_wpa_auth_update_vlan(void *ctx, const u8 *addr, int vlan_id)
943 {
944 #ifndef CONFIG_NO_VLAN
945 struct hostapd_data *hapd = ctx;
946 struct sta_info *sta;
947
948 sta = ap_get_sta(hapd, addr);
949 if (!sta)
950 return -1;
951
952 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_VLAN_OFFLOAD)) {
953 struct vlan_description vlan_desc;
954
955 os_memset(&vlan_desc, 0, sizeof(vlan_desc));
956 vlan_desc.notempty = 1;
957 vlan_desc.untagged = vlan_id;
958 if (!hostapd_vlan_valid(hapd->conf->vlan, &vlan_desc)) {
959 wpa_printf(MSG_INFO,
960 "Invalid VLAN ID %d in wpa_psk_file",
961 vlan_id);
962 return -1;
963 }
964
965 if (ap_sta_set_vlan(hapd, sta, &vlan_desc) < 0) {
966 wpa_printf(MSG_INFO,
967 "Failed to assign VLAN ID %d from wpa_psk_file to "
968 MACSTR, vlan_id, MAC2STR(sta->addr));
969 return -1;
970 }
971 } else {
972 sta->vlan_id = vlan_id;
973 }
974
975 wpa_printf(MSG_INFO,
976 "Assigned VLAN ID %d from wpa_psk_file to " MACSTR,
977 vlan_id, MAC2STR(sta->addr));
978 if ((sta->flags & WLAN_STA_ASSOC) &&
979 ap_sta_bind_vlan(hapd, sta) < 0)
980 return -1;
981 #endif /* CONFIG_NO_VLAN */
982
983 return 0;
984 }
985
986
987 #ifdef CONFIG_OCV
hostapd_get_sta_tx_params(void * ctx,const u8 * addr,int ap_max_chanwidth,int ap_seg1_idx,int * bandwidth,int * seg1_idx)988 static int hostapd_get_sta_tx_params(void *ctx, const u8 *addr,
989 int ap_max_chanwidth, int ap_seg1_idx,
990 int *bandwidth, int *seg1_idx)
991 {
992 struct hostapd_data *hapd = ctx;
993 struct sta_info *sta;
994
995 sta = ap_get_sta(hapd, addr);
996 if (!sta) {
997 hostapd_wpa_auth_logger(hapd, addr, LOGGER_INFO,
998 "Failed to get STA info to validate received OCI");
999 return -1;
1000 }
1001
1002 return get_tx_parameters(sta, ap_max_chanwidth, ap_seg1_idx, bandwidth,
1003 seg1_idx);
1004 }
1005 #endif /* CONFIG_OCV */
1006
1007
1008 #ifdef CONFIG_IEEE80211R_AP
1009
hostapd_wpa_auth_send_ft_action(void * ctx,const u8 * dst,const u8 * data,size_t data_len)1010 static int hostapd_wpa_auth_send_ft_action(void *ctx, const u8 *dst,
1011 const u8 *data, size_t data_len)
1012 {
1013 struct hostapd_data *hapd = ctx;
1014 int res;
1015 struct ieee80211_mgmt *m;
1016 size_t mlen;
1017 struct sta_info *sta;
1018
1019 sta = ap_get_sta(hapd, dst);
1020 if (sta == NULL || sta->wpa_sm == NULL)
1021 return -1;
1022
1023 m = os_zalloc(sizeof(*m) + data_len);
1024 if (m == NULL)
1025 return -1;
1026 mlen = ((u8 *) &m->u - (u8 *) m) + data_len;
1027 m->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
1028 WLAN_FC_STYPE_ACTION);
1029 os_memcpy(m->da, dst, ETH_ALEN);
1030 os_memcpy(m->sa, hapd->own_addr, ETH_ALEN);
1031 os_memcpy(m->bssid, hapd->own_addr, ETH_ALEN);
1032 os_memcpy(&m->u, data, data_len);
1033
1034 res = hostapd_drv_send_mlme(hapd, (u8 *) m, mlen, 0, NULL, 0, 0);
1035 os_free(m);
1036 return res;
1037 }
1038
1039
1040 static struct wpa_state_machine *
hostapd_wpa_auth_add_sta(void * ctx,const u8 * sta_addr)1041 hostapd_wpa_auth_add_sta(void *ctx, const u8 *sta_addr)
1042 {
1043 struct hostapd_data *hapd = ctx;
1044 struct sta_info *sta;
1045 int ret;
1046
1047 wpa_printf(MSG_DEBUG, "Add station entry for " MACSTR
1048 " based on WPA authenticator callback",
1049 MAC2STR(sta_addr));
1050 ret = hostapd_add_sta_node(hapd, sta_addr, WLAN_AUTH_FT);
1051
1052 /*
1053 * The expected return values from hostapd_add_sta_node() are
1054 * 0: successfully added STA entry
1055 * -EOPNOTSUPP: driver or driver wrapper does not support/need this
1056 * operations
1057 * any other negative value: error in adding the STA entry */
1058 if (ret < 0 && ret != -EOPNOTSUPP)
1059 return NULL;
1060
1061 sta = ap_sta_add(hapd, sta_addr);
1062 if (sta == NULL)
1063 return NULL;
1064 if (ret == 0)
1065 sta->added_unassoc = 1;
1066
1067 sta->ft_over_ds = 1;
1068 if (sta->wpa_sm) {
1069 sta->auth_alg = WLAN_AUTH_FT;
1070 return sta->wpa_sm;
1071 }
1072
1073 sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, sta->addr, NULL);
1074 if (sta->wpa_sm == NULL) {
1075 ap_free_sta(hapd, sta);
1076 return NULL;
1077 }
1078 sta->auth_alg = WLAN_AUTH_FT;
1079
1080 return sta->wpa_sm;
1081 }
1082
1083
hostapd_wpa_auth_add_sta_ft(void * ctx,const u8 * sta_addr)1084 static int hostapd_wpa_auth_add_sta_ft(void *ctx, const u8 *sta_addr)
1085 {
1086 struct hostapd_data *hapd = ctx;
1087 struct sta_info *sta;
1088
1089 sta = ap_get_sta(hapd, sta_addr);
1090 if (!sta)
1091 return -1;
1092
1093 if (FULL_AP_CLIENT_STATE_SUPP(hapd->iface->drv_flags) &&
1094 (sta->flags & WLAN_STA_MFP) && ap_sta_is_authorized(sta) &&
1095 !(hapd->conf->mesh & MESH_ENABLED) && !(sta->added_unassoc)) {
1096 /* We could not do this in handle_auth() since there was a
1097 * PMF-enabled association for the STA and the new
1098 * authentication attempt was not yet fully processed. Now that
1099 * we are ready to configure the TK to the driver,
1100 * authentication has succeeded and we can clean up the driver
1101 * STA entry to avoid issues with any maintained state from the
1102 * previous association. */
1103 wpa_printf(MSG_DEBUG,
1104 "FT: Remove and re-add driver STA entry after successful FT authentication");
1105 return ap_sta_re_add(hapd, sta);
1106 }
1107
1108 return 0;
1109 }
1110
1111
hostapd_wpa_auth_set_vlan(void * ctx,const u8 * sta_addr,struct vlan_description * vlan)1112 static int hostapd_wpa_auth_set_vlan(void *ctx, const u8 *sta_addr,
1113 struct vlan_description *vlan)
1114 {
1115 struct hostapd_data *hapd = ctx;
1116 struct sta_info *sta;
1117
1118 sta = ap_get_sta(hapd, sta_addr);
1119 if (!sta || !sta->wpa_sm)
1120 return -1;
1121
1122 if (vlan->notempty &&
1123 !hostapd_vlan_valid(hapd->conf->vlan, vlan)) {
1124 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211,
1125 HOSTAPD_LEVEL_INFO,
1126 "Invalid VLAN %d%s received from FT",
1127 vlan->untagged, vlan->tagged[0] ? "+" : "");
1128 return -1;
1129 }
1130
1131 if (ap_sta_set_vlan(hapd, sta, vlan) < 0)
1132 return -1;
1133 /* Configure wpa_group for GTK but ignore error due to driver not
1134 * knowing this STA. */
1135 ap_sta_bind_vlan(hapd, sta);
1136
1137 if (sta->vlan_id)
1138 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211,
1139 HOSTAPD_LEVEL_INFO, "VLAN ID %d", sta->vlan_id);
1140
1141 return 0;
1142 }
1143
1144
hostapd_wpa_auth_get_vlan(void * ctx,const u8 * sta_addr,struct vlan_description * vlan)1145 static int hostapd_wpa_auth_get_vlan(void *ctx, const u8 *sta_addr,
1146 struct vlan_description *vlan)
1147 {
1148 struct hostapd_data *hapd = ctx;
1149 struct sta_info *sta;
1150
1151 sta = ap_get_sta(hapd, sta_addr);
1152 if (!sta)
1153 return -1;
1154
1155 if (sta->vlan_desc)
1156 *vlan = *sta->vlan_desc;
1157 else
1158 os_memset(vlan, 0, sizeof(*vlan));
1159
1160 return 0;
1161 }
1162
1163
1164 static int
hostapd_wpa_auth_set_identity(void * ctx,const u8 * sta_addr,const u8 * identity,size_t identity_len)1165 hostapd_wpa_auth_set_identity(void *ctx, const u8 *sta_addr,
1166 const u8 *identity, size_t identity_len)
1167 {
1168 struct hostapd_data *hapd = ctx;
1169 struct sta_info *sta;
1170
1171 sta = ap_get_sta(hapd, sta_addr);
1172 if (!sta)
1173 return -1;
1174
1175 os_free(sta->identity);
1176 sta->identity = NULL;
1177
1178 if (sta->eapol_sm) {
1179 os_free(sta->eapol_sm->identity);
1180 sta->eapol_sm->identity = NULL;
1181 sta->eapol_sm->identity_len = 0;
1182 }
1183
1184 if (!identity_len)
1185 return 0;
1186
1187 /* sta->identity is NULL terminated */
1188 sta->identity = os_zalloc(identity_len + 1);
1189 if (!sta->identity)
1190 return -1;
1191 os_memcpy(sta->identity, identity, identity_len);
1192
1193 if (sta->eapol_sm) {
1194 sta->eapol_sm->identity = os_zalloc(identity_len);
1195 if (!sta->eapol_sm->identity)
1196 return -1;
1197 os_memcpy(sta->eapol_sm->identity, identity, identity_len);
1198 sta->eapol_sm->identity_len = identity_len;
1199 }
1200
1201 return 0;
1202 }
1203
1204
1205 static size_t
hostapd_wpa_auth_get_identity(void * ctx,const u8 * sta_addr,const u8 ** buf)1206 hostapd_wpa_auth_get_identity(void *ctx, const u8 *sta_addr, const u8 **buf)
1207 {
1208 struct hostapd_data *hapd = ctx;
1209 struct sta_info *sta;
1210 size_t len;
1211 char *identity;
1212
1213 sta = ap_get_sta(hapd, sta_addr);
1214 if (!sta)
1215 return 0;
1216
1217 *buf = ieee802_1x_get_identity(sta->eapol_sm, &len);
1218 if (*buf && len)
1219 return len;
1220
1221 if (!sta->identity) {
1222 *buf = NULL;
1223 return 0;
1224 }
1225
1226 identity = sta->identity;
1227 len = os_strlen(identity);
1228 *buf = (u8 *) identity;
1229
1230 return len;
1231 }
1232
1233
1234 static int
hostapd_wpa_auth_set_radius_cui(void * ctx,const u8 * sta_addr,const u8 * radius_cui,size_t radius_cui_len)1235 hostapd_wpa_auth_set_radius_cui(void *ctx, const u8 *sta_addr,
1236 const u8 *radius_cui, size_t radius_cui_len)
1237 {
1238 struct hostapd_data *hapd = ctx;
1239 struct sta_info *sta;
1240
1241 sta = ap_get_sta(hapd, sta_addr);
1242 if (!sta)
1243 return -1;
1244
1245 os_free(sta->radius_cui);
1246 sta->radius_cui = NULL;
1247
1248 if (sta->eapol_sm) {
1249 wpabuf_free(sta->eapol_sm->radius_cui);
1250 sta->eapol_sm->radius_cui = NULL;
1251 }
1252
1253 if (!radius_cui)
1254 return 0;
1255
1256 /* sta->radius_cui is NULL terminated */
1257 sta->radius_cui = os_zalloc(radius_cui_len + 1);
1258 if (!sta->radius_cui)
1259 return -1;
1260 os_memcpy(sta->radius_cui, radius_cui, radius_cui_len);
1261
1262 if (sta->eapol_sm) {
1263 sta->eapol_sm->radius_cui = wpabuf_alloc_copy(radius_cui,
1264 radius_cui_len);
1265 if (!sta->eapol_sm->radius_cui)
1266 return -1;
1267 }
1268
1269 return 0;
1270 }
1271
1272
1273 static size_t
hostapd_wpa_auth_get_radius_cui(void * ctx,const u8 * sta_addr,const u8 ** buf)1274 hostapd_wpa_auth_get_radius_cui(void *ctx, const u8 *sta_addr, const u8 **buf)
1275 {
1276 struct hostapd_data *hapd = ctx;
1277 struct sta_info *sta;
1278 struct wpabuf *b;
1279 size_t len;
1280 char *radius_cui;
1281
1282 sta = ap_get_sta(hapd, sta_addr);
1283 if (!sta)
1284 return 0;
1285
1286 b = ieee802_1x_get_radius_cui(sta->eapol_sm);
1287 if (b) {
1288 len = wpabuf_len(b);
1289 *buf = wpabuf_head(b);
1290 return len;
1291 }
1292
1293 if (!sta->radius_cui) {
1294 *buf = NULL;
1295 return 0;
1296 }
1297
1298 radius_cui = sta->radius_cui;
1299 len = os_strlen(radius_cui);
1300 *buf = (u8 *) radius_cui;
1301
1302 return len;
1303 }
1304
1305
hostapd_wpa_auth_set_session_timeout(void * ctx,const u8 * sta_addr,int session_timeout)1306 static void hostapd_wpa_auth_set_session_timeout(void *ctx, const u8 *sta_addr,
1307 int session_timeout)
1308 {
1309 struct hostapd_data *hapd = ctx;
1310 struct sta_info *sta;
1311
1312 sta = ap_get_sta(hapd, sta_addr);
1313 if (!sta)
1314 return;
1315
1316 if (session_timeout) {
1317 os_get_reltime(&sta->session_timeout);
1318 sta->session_timeout.sec += session_timeout;
1319 sta->session_timeout_set = 1;
1320 ap_sta_session_timeout(hapd, sta, session_timeout);
1321 } else {
1322 sta->session_timeout_set = 0;
1323 ap_sta_no_session_timeout(hapd, sta);
1324 }
1325 }
1326
1327
hostapd_wpa_auth_get_session_timeout(void * ctx,const u8 * sta_addr)1328 static int hostapd_wpa_auth_get_session_timeout(void *ctx, const u8 *sta_addr)
1329 {
1330 struct hostapd_data *hapd = ctx;
1331 struct sta_info *sta;
1332 struct os_reltime now, remaining;
1333
1334 sta = ap_get_sta(hapd, sta_addr);
1335 if (!sta || !sta->session_timeout_set)
1336 return 0;
1337
1338 os_get_reltime(&now);
1339 if (os_reltime_before(&sta->session_timeout, &now)) {
1340 /* already expired, return >0 as timeout was set */
1341 return 1;
1342 }
1343
1344 os_reltime_sub(&sta->session_timeout, &now, &remaining);
1345
1346 return (remaining.sec > 0) ? remaining.sec : 1;
1347 }
1348
1349
hostapd_rrb_receive(void * ctx,const u8 * src_addr,const u8 * buf,size_t len)1350 static void hostapd_rrb_receive(void *ctx, const u8 *src_addr, const u8 *buf,
1351 size_t len)
1352 {
1353 struct hostapd_data *hapd = ctx;
1354 struct l2_ethhdr *ethhdr;
1355 if (len < sizeof(*ethhdr))
1356 return;
1357 ethhdr = (struct l2_ethhdr *) buf;
1358 wpa_printf(MSG_DEBUG, "FT: RRB received packet " MACSTR " -> "
1359 MACSTR, MAC2STR(ethhdr->h_source), MAC2STR(ethhdr->h_dest));
1360 if (!is_multicast_ether_addr(ethhdr->h_dest) &&
1361 os_memcmp(hapd->own_addr, ethhdr->h_dest, ETH_ALEN) != 0)
1362 return;
1363 wpa_ft_rrb_rx(hapd->wpa_auth, ethhdr->h_source, buf + sizeof(*ethhdr),
1364 len - sizeof(*ethhdr));
1365 }
1366
1367
hostapd_rrb_oui_receive(void * ctx,const u8 * src_addr,const u8 * dst_addr,u8 oui_suffix,const u8 * buf,size_t len)1368 static void hostapd_rrb_oui_receive(void *ctx, const u8 *src_addr,
1369 const u8 *dst_addr, u8 oui_suffix,
1370 const u8 *buf, size_t len)
1371 {
1372 struct hostapd_data *hapd = ctx;
1373
1374 wpa_printf(MSG_DEBUG, "FT: RRB received packet " MACSTR " -> "
1375 MACSTR, MAC2STR(src_addr), MAC2STR(dst_addr));
1376 if (!is_multicast_ether_addr(dst_addr) &&
1377 os_memcmp(hapd->own_addr, dst_addr, ETH_ALEN) != 0)
1378 return;
1379 wpa_ft_rrb_oui_rx(hapd->wpa_auth, src_addr, dst_addr, oui_suffix, buf,
1380 len);
1381 }
1382
1383
hostapd_wpa_auth_add_tspec(void * ctx,const u8 * sta_addr,u8 * tspec_ie,size_t tspec_ielen)1384 static int hostapd_wpa_auth_add_tspec(void *ctx, const u8 *sta_addr,
1385 u8 *tspec_ie, size_t tspec_ielen)
1386 {
1387 struct hostapd_data *hapd = ctx;
1388 return hostapd_add_tspec(hapd, sta_addr, tspec_ie, tspec_ielen);
1389 }
1390
1391
1392
hostapd_wpa_register_ft_oui(struct hostapd_data * hapd,const char * ft_iface)1393 static int hostapd_wpa_register_ft_oui(struct hostapd_data *hapd,
1394 const char *ft_iface)
1395 {
1396 hapd->oui_pull = eth_p_oui_register(hapd, ft_iface,
1397 FT_PACKET_R0KH_R1KH_PULL,
1398 hostapd_rrb_oui_receive, hapd);
1399 if (!hapd->oui_pull)
1400 return -1;
1401
1402 hapd->oui_resp = eth_p_oui_register(hapd, ft_iface,
1403 FT_PACKET_R0KH_R1KH_RESP,
1404 hostapd_rrb_oui_receive, hapd);
1405 if (!hapd->oui_resp)
1406 return -1;
1407
1408 hapd->oui_push = eth_p_oui_register(hapd, ft_iface,
1409 FT_PACKET_R0KH_R1KH_PUSH,
1410 hostapd_rrb_oui_receive, hapd);
1411 if (!hapd->oui_push)
1412 return -1;
1413
1414 hapd->oui_sreq = eth_p_oui_register(hapd, ft_iface,
1415 FT_PACKET_R0KH_R1KH_SEQ_REQ,
1416 hostapd_rrb_oui_receive, hapd);
1417 if (!hapd->oui_sreq)
1418 return -1;
1419
1420 hapd->oui_sresp = eth_p_oui_register(hapd, ft_iface,
1421 FT_PACKET_R0KH_R1KH_SEQ_RESP,
1422 hostapd_rrb_oui_receive, hapd);
1423 if (!hapd->oui_sresp)
1424 return -1;
1425
1426 return 0;
1427 }
1428
1429
hostapd_wpa_unregister_ft_oui(struct hostapd_data * hapd)1430 static void hostapd_wpa_unregister_ft_oui(struct hostapd_data *hapd)
1431 {
1432 eth_p_oui_unregister(hapd->oui_pull);
1433 hapd->oui_pull = NULL;
1434 eth_p_oui_unregister(hapd->oui_resp);
1435 hapd->oui_resp = NULL;
1436 eth_p_oui_unregister(hapd->oui_push);
1437 hapd->oui_push = NULL;
1438 eth_p_oui_unregister(hapd->oui_sreq);
1439 hapd->oui_sreq = NULL;
1440 eth_p_oui_unregister(hapd->oui_sresp);
1441 hapd->oui_sresp = NULL;
1442 }
1443 #endif /* CONFIG_IEEE80211R_AP */
1444
1445
hostapd_setup_wpa(struct hostapd_data * hapd)1446 int hostapd_setup_wpa(struct hostapd_data *hapd)
1447 {
1448 struct wpa_auth_config _conf;
1449 static const struct wpa_auth_callbacks cb = {
1450 .logger = hostapd_wpa_auth_logger,
1451 .disconnect = hostapd_wpa_auth_disconnect,
1452 .mic_failure_report = hostapd_wpa_auth_mic_failure_report,
1453 .psk_failure_report = hostapd_wpa_auth_psk_failure_report,
1454 .set_eapol = hostapd_wpa_auth_set_eapol,
1455 .get_eapol = hostapd_wpa_auth_get_eapol,
1456 .get_psk = hostapd_wpa_auth_get_psk,
1457 .get_msk = hostapd_wpa_auth_get_msk,
1458 .set_key = hostapd_wpa_auth_set_key,
1459 .get_seqnum = hostapd_wpa_auth_get_seqnum,
1460 .send_eapol = hostapd_wpa_auth_send_eapol,
1461 .for_each_sta = hostapd_wpa_auth_for_each_sta,
1462 .for_each_auth = hostapd_wpa_auth_for_each_auth,
1463 .send_ether = hostapd_wpa_auth_send_ether,
1464 .send_oui = hostapd_wpa_auth_send_oui,
1465 .channel_info = hostapd_channel_info,
1466 .update_vlan = hostapd_wpa_auth_update_vlan,
1467 #ifdef CONFIG_PASN
1468 .store_ptksa = hostapd_store_ptksa,
1469 .clear_ptksa = hostapd_clear_ptksa,
1470 #endif /* CONFIG_PASN */
1471
1472 #ifdef CONFIG_OCV
1473 .get_sta_tx_params = hostapd_get_sta_tx_params,
1474 #endif /* CONFIG_OCV */
1475 #ifdef CONFIG_IEEE80211R_AP
1476 .send_ft_action = hostapd_wpa_auth_send_ft_action,
1477 .add_sta = hostapd_wpa_auth_add_sta,
1478 .add_sta_ft = hostapd_wpa_auth_add_sta_ft,
1479 .add_tspec = hostapd_wpa_auth_add_tspec,
1480 .set_vlan = hostapd_wpa_auth_set_vlan,
1481 .get_vlan = hostapd_wpa_auth_get_vlan,
1482 .set_identity = hostapd_wpa_auth_set_identity,
1483 .get_identity = hostapd_wpa_auth_get_identity,
1484 .set_radius_cui = hostapd_wpa_auth_set_radius_cui,
1485 .get_radius_cui = hostapd_wpa_auth_get_radius_cui,
1486 .set_session_timeout = hostapd_wpa_auth_set_session_timeout,
1487 .get_session_timeout = hostapd_wpa_auth_get_session_timeout,
1488 #endif /* CONFIG_IEEE80211R_AP */
1489 };
1490 const u8 *wpa_ie;
1491 size_t wpa_ie_len;
1492
1493 hostapd_wpa_auth_conf(hapd->conf, hapd->iconf, &_conf);
1494 _conf.msg_ctx = hapd->msg_ctx;
1495 if (hapd->iface->drv_flags & WPA_DRIVER_FLAGS_EAPOL_TX_STATUS)
1496 _conf.tx_status = 1;
1497 if (hapd->iface->drv_flags & WPA_DRIVER_FLAGS_AP_MLME)
1498 _conf.ap_mlme = 1;
1499
1500 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_WIRED) &&
1501 (hapd->conf->wpa_deny_ptk0_rekey == PTK0_REKEY_ALLOW_NEVER ||
1502 (hapd->conf->wpa_deny_ptk0_rekey == PTK0_REKEY_ALLOW_LOCAL_OK &&
1503 !(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_SAFE_PTK0_REKEYS)))) {
1504 wpa_msg(hapd->msg_ctx, MSG_INFO,
1505 "Disable PTK0 rekey support - replaced with disconnect");
1506 _conf.wpa_deny_ptk0_rekey = 1;
1507 }
1508
1509 if (_conf.extended_key_id &&
1510 (hapd->iface->drv_flags & WPA_DRIVER_FLAGS_EXTENDED_KEY_ID))
1511 wpa_msg(hapd->msg_ctx, MSG_DEBUG, "Extended Key ID supported");
1512 else
1513 _conf.extended_key_id = 0;
1514
1515 if (!(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_BEACON_PROTECTION))
1516 _conf.beacon_prot = 0;
1517
1518 #ifdef CONFIG_OCV
1519 if (!(hapd->iface->drv_flags2 &
1520 (WPA_DRIVER_FLAGS2_AP_SME | WPA_DRIVER_FLAGS2_OCV)))
1521 _conf.ocv = 0;
1522 #endif /* CONFIG_OCV */
1523
1524 _conf.secure_ltf =
1525 !!(hapd->iface->drv_flags2 & WPA_DRIVER_FLAGS2_SEC_LTF);
1526 _conf.secure_rtt =
1527 !!(hapd->iface->drv_flags2 & WPA_DRIVER_FLAGS2_SEC_RTT);
1528 _conf.prot_range_neg =
1529 !!(hapd->iface->drv_flags2 & WPA_DRIVER_FLAGS2_PROT_RANGE_NEG);
1530
1531 hapd->wpa_auth = wpa_init(hapd->own_addr, &_conf, &cb, hapd);
1532 if (hapd->wpa_auth == NULL) {
1533 wpa_printf(MSG_ERROR, "WPA initialization failed.");
1534 return -1;
1535 }
1536
1537 if (hostapd_set_privacy(hapd, 1)) {
1538 wpa_printf(MSG_ERROR, "Could not set PrivacyInvoked "
1539 "for interface %s", hapd->conf->iface);
1540 return -1;
1541 }
1542
1543 wpa_ie = wpa_auth_get_wpa_ie(hapd->wpa_auth, &wpa_ie_len);
1544 if (hostapd_set_generic_elem(hapd, wpa_ie, wpa_ie_len)) {
1545 wpa_printf(MSG_ERROR, "Failed to configure WPA IE for "
1546 "the kernel driver.");
1547 return -1;
1548 }
1549
1550 if (rsn_preauth_iface_init(hapd)) {
1551 wpa_printf(MSG_ERROR, "Initialization of RSN "
1552 "pre-authentication failed.");
1553 return -1;
1554 }
1555
1556 if (!hapd->ptksa)
1557 hapd->ptksa = ptksa_cache_init();
1558 if (!hapd->ptksa) {
1559 wpa_printf(MSG_ERROR, "Failed to allocate PTKSA cache");
1560 return -1;
1561 }
1562
1563 #ifdef CONFIG_IEEE80211R_AP
1564 if (!hostapd_drv_none(hapd) &&
1565 wpa_key_mgmt_ft(hapd->conf->wpa_key_mgmt)) {
1566 const char *ft_iface;
1567
1568 ft_iface = hapd->conf->bridge[0] ? hapd->conf->bridge :
1569 hapd->conf->iface;
1570 hapd->l2 = l2_packet_init(ft_iface, NULL, ETH_P_RRB,
1571 hostapd_rrb_receive, hapd, 1);
1572 if (!hapd->l2) {
1573 wpa_printf(MSG_ERROR, "Failed to open l2_packet "
1574 "interface");
1575 return -1;
1576 }
1577
1578 if (hostapd_wpa_register_ft_oui(hapd, ft_iface)) {
1579 wpa_printf(MSG_ERROR,
1580 "Failed to open ETH_P_OUI interface");
1581 return -1;
1582 }
1583 }
1584 #endif /* CONFIG_IEEE80211R_AP */
1585
1586 return 0;
1587
1588 }
1589
1590
hostapd_reconfig_wpa(struct hostapd_data * hapd)1591 void hostapd_reconfig_wpa(struct hostapd_data *hapd)
1592 {
1593 struct wpa_auth_config wpa_auth_conf;
1594 hostapd_wpa_auth_conf(hapd->conf, hapd->iconf, &wpa_auth_conf);
1595 wpa_reconfig(hapd->wpa_auth, &wpa_auth_conf);
1596 }
1597
1598
hostapd_deinit_wpa(struct hostapd_data * hapd)1599 void hostapd_deinit_wpa(struct hostapd_data *hapd)
1600 {
1601 ieee80211_tkip_countermeasures_deinit(hapd);
1602 ptksa_cache_deinit(hapd->ptksa);
1603 hapd->ptksa = NULL;
1604
1605 rsn_preauth_iface_deinit(hapd);
1606 if (hapd->wpa_auth) {
1607 wpa_deinit(hapd->wpa_auth);
1608 hapd->wpa_auth = NULL;
1609
1610 if (hapd->drv_priv && hostapd_set_privacy(hapd, 0)) {
1611 wpa_printf(MSG_DEBUG, "Could not disable "
1612 "PrivacyInvoked for interface %s",
1613 hapd->conf->iface);
1614 }
1615
1616 if (hapd->drv_priv &&
1617 hostapd_set_generic_elem(hapd, (u8 *) "", 0)) {
1618 wpa_printf(MSG_DEBUG, "Could not remove generic "
1619 "information element from interface %s",
1620 hapd->conf->iface);
1621 }
1622 }
1623 ieee802_1x_deinit(hapd);
1624
1625 #ifdef CONFIG_IEEE80211R_AP
1626 eloop_cancel_timeout(hostapd_wpa_ft_rrb_rx_later, hapd, ELOOP_ALL_CTX);
1627 hostapd_wpa_ft_rrb_rx_later(hapd, NULL); /* flush without delivering */
1628 eloop_cancel_timeout(hostapd_oui_deliver_later, hapd, ELOOP_ALL_CTX);
1629 hostapd_oui_deliver_later(hapd, NULL); /* flush without delivering */
1630 l2_packet_deinit(hapd->l2);
1631 hapd->l2 = NULL;
1632 hostapd_wpa_unregister_ft_oui(hapd);
1633 #endif /* CONFIG_IEEE80211R_AP */
1634
1635 #ifdef CONFIG_TESTING_OPTIONS
1636 forced_memzero(hapd->last_gtk, WPA_GTK_MAX_LEN);
1637 forced_memzero(hapd->last_igtk, WPA_IGTK_MAX_LEN);
1638 forced_memzero(hapd->last_bigtk, WPA_BIGTK_MAX_LEN);
1639 #endif /* CONFIG_TESTING_OPTIONS */
1640 }
1641
