ext_key_id_capable indicates the handshake has set the capability bit in the RSN info. This will only be set if the AP also has the capability set. active_tk_index is the key index the AP chose in message 3. This is now used for both legacy (always zero) and extended key IDs. --- src/handshake.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/handshake.h b/src/handshake.h index 36ccc3a2..d57a3794 100644 --- a/src/handshake.h +++ b/src/handshake.h @@ -128,6 +128,7 @@ struct handshake_state { bool support_fils : 1; bool authenticator_ocvc : 1; bool supplicant_ocvc : 1; + bool ext_key_id_capable : 1; uint8_t ssid[32]; size_t ssid_len; char *passphrase; @@ -138,6 +139,7 @@ struct handshake_state { uint8_t gtk_rsc[6]; uint8_t proto_version : 2; unsigned int gtk_index; + uint8_t active_tk_index; struct erp_cache_entry *erp_cache; bool support_ip_allocation : 1; uint32_t client_ip_addr; -- 2.31.1

The procedure for setting extended key IDs is different from the single PTK key. The key ID is toggled between 0 and 1 and the new key is set as RX only, then set to RX/TX after message 4/4 goes out. Since netdev needs to set this new key before sending message 4, eapol can include a built message which netdev will store if required (i.e. using PAE). --- src/handshake.c | 23 +++++++++++++++++++++++ src/handshake.h | 12 ++++++++++++ 2 files changed, 35 insertions(+) diff --git a/src/handshake.c b/src/handshake.c index 642a25a7..58326dcd 100644 --- a/src/handshake.c +++ b/src/handshake.c @@ -76,6 +76,7 @@ static handshake_get_nonce_func_t get_nonce = handshake_get_nonce; static handshake_install_tk_func_t install_tk = NULL; static handshake_install_gtk_func_t install_gtk = NULL; static handshake_install_igtk_func_t install_igtk = NULL; +static handshake_install_ext_tk_func_t install_ext_tk = NULL; void __handshake_set_get_nonce_func(handshake_get_nonce_func_t func) { @@ -97,6 +98,11 @@ void __handshake_set_install_igtk_func(handshake_install_igtk_func_t func) install_igtk = func; } +void __handshake_set_install_ext_tk_func(handshake_install_ext_tk_func_t func) +{ + install_ext_tk = func; +} + void handshake_state_free(struct handshake_state *s) { __typeof__(s->free) destroy = s->free; @@ -663,6 +669,23 @@ void handshake_state_install_ptk(struct handshake_state *s) } } +void handshake_state_install_ext_ptk(struct handshake_state *s, + uint8_t key_idx, + struct eapol_frame *ek, uint16_t proto, + bool noencrypt) +{ + s->ptk_complete = true; + + if (install_ext_tk) { + uint32_t cipher = + ie_rsn_cipher_suite_to_cipher(s->pairwise_cipher); + + install_ext_tk(s, key_idx, handshake_get_tk(s), cipher, ek, + proto, noencrypt); + } +} + + void handshake_state_install_gtk(struct handshake_state *s, uint16_t gtk_key_index, const uint8_t *gtk, size_t gtk_len, diff --git a/src/handshake.h b/src/handshake.h index d57a3794..4cf2ec63 100644 --- a/src/handshake.h +++ b/src/handshake.h @@ -27,6 +27,7 @@ struct handshake_state; enum crypto_cipher; +struct eapol_frame; enum handshake_kde { /* 802.11-2020 Table 12-9 in section 12.7.2 */ @@ -78,11 +79,17 @@ typedef void (*handshake_install_igtk_func_t)(struct handshake_state *hs, const uint8_t *igtk, uint8_t igtk_len, const uint8_t *ipn, uint8_t ipn_len, uint32_t cipher); +typedef void (*handshake_install_ext_tk_func_t)(struct handshake_state *hs, + uint8_t key_idx, const uint8_t *tk, + uint32_t cipher, + const struct eapol_frame *step4, + uint16_t proto, bool noencrypt); void __handshake_set_get_nonce_func(handshake_get_nonce_func_t func); void __handshake_set_install_tk_func(handshake_install_tk_func_t func); void __handshake_set_install_gtk_func(handshake_install_gtk_func_t func); void __handshake_set_install_igtk_func(handshake_install_igtk_func_t func); +void __handshake_set_install_ext_tk_func(handshake_install_ext_tk_func_t func); struct handshake_state { uint32_t ifindex; @@ -226,6 +233,11 @@ size_t handshake_state_get_kek_len(struct handshake_state *s); const uint8_t *handshake_state_get_kek(struct handshake_state *s); void handshake_state_install_ptk(struct handshake_state *s); +void handshake_state_install_ext_ptk(struct handshake_state *s, + uint8_t key_idx, + struct eapol_frame *ek, uint16_t proto, + bool noencrypt); + void handshake_state_install_gtk(struct handshake_state *s, uint16_t gtk_key_index, const uint8_t *gtk, size_t gtk_len, -- 2.31.1

802.11 added Extended Key IDs which aim to solve the issue of PTK key replacement during rekeys. Since swapping out the existing PTK may result in data loss because there may be in flight packets still using the old PTK. Extended Key IDs use two key IDs for the PTK, which toggle between 0 and 1. During a rekey a new PTK is derived which uses the key ID not already taken by the existing PTK. This new PTK is added as RX only, then message 4/4 is sent. This ensure message 4 is encrypted using the previous PTK. Once sent, the new PTK can be modified to both RX and TX and the rekey is complete. To handle this in eapol the extended key ID KDE is parsed which gives us the new PTK key index. Using the new handshake callback (handshake_state_set_ext_tk) the new TK is installed. The 4th message is also included as an argument which is taken care of by netdev (in case waiting for NEW_KEY is required due to PAE socekts). --- src/eapol.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 63 insertions(+), 9 deletions(-) diff --git a/src/eapol.c b/src/eapol.c index 07120fdb..cd481317 100644 --- a/src/eapol.c +++ b/src/eapol.c @@ -860,6 +860,7 @@ struct eapol_sm { uint8_t installed_igtk_len; uint8_t installed_igtk[CRYPTO_MAX_IGTK_LEN]; unsigned int mic_len; + bool rekey : 1; }; static void eapol_sm_destroy(void *value) @@ -1223,6 +1224,9 @@ static void eapol_handle_ptk_1_of_4(struct eapol_sm *sm, return; } + if (sm->handshake->ptk_complete) + sm->rekey = true; + handshake_state_new_snonce(sm->handshake); handshake_state_set_anonce(sm->handshake, ek->key_nonce); @@ -1643,12 +1647,14 @@ static void eapol_handle_ptk_3_of_4(struct eapol_sm *sm, struct handshake_state *hs = sm->handshake; const uint8_t *kck; const uint8_t *kek; - struct eapol_key *step4; + _auto_(l_free) struct eapol_key *step4 = NULL; uint8_t mic[MIC_MAXLEN]; const uint8_t *gtk = NULL; size_t gtk_len; const uint8_t *igtk = NULL; size_t igtk_len; + const uint8_t *key_id = NULL; + size_t key_id_len; const uint8_t *rsne; struct ie_rsn_info rsn_info; const uint8_t *optional_rsne = NULL; @@ -1856,6 +1862,44 @@ static void eapol_handle_ptk_3_of_4(struct eapol_sm *sm, } else igtk = NULL; + key_id = handshake_util_find_kde(HANDSHAKE_KDE_KEY_ID, + decrypted_key_data, + decrypted_key_data_size, &key_id_len); + if (hs->ext_key_id_capable) { + uint8_t idx; + + if (!key_id) { + l_debug("No extended key KDE in frame 3/4"); + handshake_failed(sm, MMPDU_REASON_CODE_INVALID_IE); + return; + } + + if (key_id_len != 2) { + l_error("invalid Key ID KDE format"); + handshake_failed(sm, MMPDU_REASON_CODE_INVALID_IE); + return; + } + + idx = bit_field(key_id[0], 0, 2); + + /* + * IEEE 802.11-2020 - 12.7.6.4 4-way handshake message 3 + * "... the Authenticator assigns a new Key ID for the PTKSA in + * the range of 0 to 1 that is different from the Key ID + * assigned in the previous handshake" + */ + if ((idx != 0 && idx != 1) || (sm->rekey && + idx == hs->active_tk_index)) { + l_error("invalid Key ID KDE value (%u)", idx); + handshake_failed(sm, MMPDU_REASON_CODE_INVALID_IE); + return; + } + + hs->active_tk_index = idx; + + l_debug("using Extended key ID %u", hs->active_tk_index); + } + if (hs->support_ip_allocation) { size_t len; const uint8_t *ip_alloc_kde = @@ -1917,7 +1961,6 @@ retransmit: if (!eapol_calculate_mic(hs->akm_suite, kck, step4, mic, sm->mic_len)) { l_debug("MIC Calculation failed"); - l_free(step4); handshake_failed(sm, MMPDU_REASON_CODE_UNSPECIFIED); return; } @@ -1928,18 +1971,11 @@ retransmit: handshake_state_get_kek_len(hs), step4, NULL, 0)) { l_debug("AES-SIV encryption failed"); - l_free(step4); handshake_failed(sm, MMPDU_REASON_CODE_UNSPECIFIED); return; } } - eapol_sm_write(sm, (struct eapol_frame *) step4, unencrypted); - l_free(step4); - - if (hs->ptk_complete) - return; - /* * For WPA1 the group handshake should be happening after we set the * ptk, this flag tells netdev to wait for the gtk/igtk before @@ -1954,6 +1990,24 @@ retransmit: if (igtk) eapol_install_igtk(sm, igtk_key_index, igtk, igtk_len); + /* + * Only install if this is the first 3/4 message (not retransmitting) + * and a rekey. Initial associations don't need the special RX -> TX + * procedure and can install the TK normally + */ + if (key_id && hs->ext_key_id_capable && sm->rekey) { + handshake_state_install_ext_ptk(hs, hs->active_tk_index, + (struct eapol_frame *) step4, + ETH_P_PAE, unencrypted); + + return; + } + + eapol_sm_write(sm, (struct eapol_frame *) step4, unencrypted); + + if (hs->ptk_complete) + return; + handshake_state_install_ptk(hs); if (rekey_offload) -- 2.31.1

Hi Denis, On Fri, 2021-10-08 at 08:58 -0500, Denis Kenzior wrote: So all the KDE parsing is completely skipped on retransmissions. So we never even get to this if block at all. And same with below... gtk/igtk/key_id pointers wont be set on a retransmission so I think this is safe right?

This implements the new handshake callback for setting a TK with an extended key ID. The procedure is different from legacy zero index TKs. First the new TK is set as RX only. Then message 4 should be sent out (so it uses the existing TK). This poses a slight issue with PAE sockets since message order is not guaranteed. In this case the 4th message is stored and sent after the new TK is installed. Then the new TK is modified using SET_KEY to both send and receive. In the case of control port over NL80211 the above can be avoided and we can simply install the new key, send message 4, and modify the TK as TX + RX all in sequence, without waiting for any callbacks. --- src/netdev.c | 401 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 297 insertions(+), 104 deletions(-) diff --git a/src/netdev.c b/src/netdev.c index de155da1..0bfc4c10 100644 --- a/src/netdev.c +++ b/src/netdev.c @@ -87,6 +87,7 @@ struct netdev_handshake_state { uint32_t group_management_new_key_cmd_id; uint32_t set_station_cmd_id; uint32_t set_pmk_cmd_id; + uint32_t pairwise_set_key_tx_cmd_id; bool ptk_installed; bool gtk_installed; bool igtk_installed; @@ -102,6 +103,12 @@ struct netdev_ft_over_ds_info { bool parsed : 1; }; +struct netdev_ext_key_info { + uint16_t proto; + bool noencrypt; + struct eapol_frame frame[0]; +}; + struct netdev { uint32_t index; uint64_t wdev_id; @@ -170,6 +177,8 @@ struct netdev { struct l_queue *ft_ds_list; + struct netdev_ext_key_info *ext_key_info; + bool connected : 1; bool associated : 1; bool operational : 1; @@ -336,6 +345,11 @@ static void netdev_handshake_state_cancel_all( l_genl_family_cancel(nl80211, nhs->set_pmk_cmd_id); nhs->set_pmk_cmd_id = 0; } + + if (nhs->pairwise_set_key_tx_cmd_id) { + l_genl_family_cancel(nl80211, nhs->pairwise_set_key_tx_cmd_id); + nhs->pairwise_set_key_tx_cmd_id = 0; + } } static void netdev_handshake_state_free(struct handshake_state *hs) @@ -766,6 +780,11 @@ static void netdev_connect_free(struct netdev *netdev) netdev->handshake = NULL; } + if (netdev->ext_key_info) { + l_free(netdev->ext_key_info); + netdev->ext_key_info = NULL; + } + if (netdev->neighbor_report_cb) { netdev->neighbor_report_cb(netdev, -ENOTCONN, NULL, 0, netdev->user_data); @@ -1693,6 +1712,24 @@ static void netdev_set_igtk(struct handshake_state *hs, uint16_t key_index, netdev_setting_keys_failed(nhs, -EIO); } +static struct l_genl_msg *netdev_build_cmd_set_key_tx(struct netdev *netdev) +{ + uint8_t key_mode = NL80211_KEY_SET_TX; + struct l_genl_msg *msg = l_genl_msg_new_sized(NL80211_CMD_SET_KEY, 512); + + l_genl_msg_append_attr(msg, NL80211_ATTR_MAC, ETH_ALEN, + netdev->handshake->aa); + l_genl_msg_append_attr(msg, NL80211_ATTR_IFINDEX, 4, &netdev->index); + + l_genl_msg_enter_nested(msg, NL80211_ATTR_KEY); + l_genl_msg_append_attr(msg, NL80211_KEY_IDX, 1, + &netdev->handshake->active_tk_index); + l_genl_msg_append_attr(msg, NL80211_KEY_MODE, 1, &key_mode); + l_genl_msg_leave_nested(msg); + + return msg; +} + static void netdev_new_pairwise_key_cb(struct l_genl_msg *msg, void *data) { struct netdev_handshake_state *nhs = data; @@ -1730,14 +1767,171 @@ error: netdev_setting_keys_failed(nhs, err); } +static struct l_genl_msg *netdev_build_control_port_frame(struct netdev *netdev, + const uint8_t *to, + uint16_t proto, + bool unencrypted, + const void *body, + size_t body_len) +{ + struct l_genl_msg *msg; + + msg = l_genl_msg_new_sized(NL80211_CMD_CONTROL_PORT_FRAME, + 128 + body_len); + + l_genl_msg_append_attr(msg, NL80211_ATTR_IFINDEX, 4, &netdev->index); + l_genl_msg_append_attr(msg, NL80211_ATTR_FRAME, body_len, body); + l_genl_msg_append_attr(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, 2, + &proto); + l_genl_msg_append_attr(msg, NL80211_ATTR_MAC, ETH_ALEN, to); + + if (unencrypted) + l_genl_msg_append_attr(msg, + NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT, 0, NULL); + + return msg; +} + +static void netdev_control_port_frame_cb(struct l_genl_msg *msg, + void *user_data) +{ + int err = l_genl_msg_get_error(msg); + const char *ext_error; + + if (err >= 0) + return; + + ext_error = l_genl_msg_get_extended_error(msg); + l_error("CMD_CONTROL_PORT failed: %s", + ext_error ? ext_error : strerror(-err)); +} + +static int netdev_control_port_write_pae(struct netdev *netdev, + const uint8_t *dest, + uint16_t proto, + const struct eapol_frame *ef, + bool noencrypt) +{ + int fd = l_io_get_fd(netdev->pae_io); + struct sockaddr_ll sll; + size_t frame_size = sizeof(struct eapol_header) + + L_BE16_TO_CPU(ef->header.packet_len); + ssize_t r; + + memset(&sll, 0, sizeof(sll)); + sll.sll_family = AF_PACKET; + sll.sll_ifindex = netdev->index; + sll.sll_protocol = htons(proto); + sll.sll_halen = ETH_ALEN; + memcpy(sll.sll_addr, dest, ETH_ALEN); + + r = sendto(fd, ef, frame_size, 0, + (struct sockaddr *) &sll, sizeof(sll)); + if (r < 0) + l_error("EAPoL write socket: %s", strerror(errno)); + + return r; +} + +static int netdev_control_port_frame(uint32_t ifindex, + const uint8_t *dest, uint16_t proto, + const struct eapol_frame *ef, + bool noencrypt, + void *user_data) +{ + struct l_genl_msg *msg; + struct netdev *netdev; + size_t frame_size; + + netdev = netdev_find(ifindex); + if (!netdev) + return -ENOENT; + + frame_size = sizeof(struct eapol_header) + + L_BE16_TO_CPU(ef->header.packet_len); + + if (!netdev->pae_over_nl80211) + return netdev_control_port_write_pae(netdev, dest, proto, + ef, noencrypt); + + msg = netdev_build_control_port_frame(netdev, dest, proto, noencrypt, + ef, frame_size); + if (!msg) + return -ENOMEM; + + if (!l_genl_family_send(nl80211, msg, netdev_control_port_frame_cb, + netdev, NULL)) { + l_genl_msg_unref(msg); + return -EINVAL; + } + + return 0; +} + +static int netdev_set_key_tx(struct netdev *netdev) +{ + struct netdev_handshake_state *nhs = l_container_of(netdev->handshake, + struct netdev_handshake_state, super); + struct l_genl_msg *msg = netdev_build_cmd_set_key_tx(netdev); + + nhs->pairwise_set_key_tx_cmd_id = l_genl_family_send(nl80211, msg, + netdev_new_pairwise_key_cb, + nhs, NULL); + if (nhs->pairwise_set_key_tx_cmd_id > 0) + return 0; + + l_genl_msg_unref(msg); + + return -EIO; +} + +static void netdev_new_rx_pairwise_key_cb(struct l_genl_msg *msg, void *data) +{ + struct netdev_handshake_state *nhs = data; + struct netdev *netdev = nhs->netdev; + struct netdev_ext_key_info *info = netdev->ext_key_info; + int err = l_genl_msg_get_error(msg); + + nhs->pairwise_new_key_cmd_id = 0; + + if (err < 0) { + const char *ext_error = l_genl_msg_get_extended_error(msg); + + l_error("New Key for RX Pairwise Key failed for ifindex: %d:%s", + netdev->index, + ext_error ? ext_error : strerror(-err)); + goto error; + } + + if (!info) + return; + + err = netdev_control_port_write_pae(netdev, nhs->super.aa, info->proto, + info->frame, info->noencrypt); + l_free(netdev->ext_key_info); + netdev->ext_key_info = NULL; + + if (err < 0) + goto error; + + err = netdev_set_key_tx(netdev); + if (err < 0) + goto error; + + return; + +error: + netdev_setting_keys_failed(nhs, err); +} + static struct l_genl_msg *netdev_build_cmd_new_key_pairwise( struct netdev *netdev, uint32_t cipher, const uint8_t *aa, const uint8_t *tk, - size_t tk_len) + size_t tk_len, + uint8_t key_id) { - uint8_t key_id = 0; struct l_genl_msg *msg; msg = l_genl_msg_new_sized(NL80211_CMD_NEW_KEY, 512); @@ -1751,6 +1945,36 @@ static struct l_genl_msg *netdev_build_cmd_new_key_pairwise( return msg; } +static struct l_genl_msg *netdev_build_cmd_new_rx_key_pairwise( + struct netdev *netdev, + uint32_t cipher, + const uint8_t *aa, + const uint8_t *tk, + size_t tk_len, + uint8_t key_id) +{ + uint8_t key_mode = NL80211_KEY_NO_TX; + uint32_t key_type = NL80211_KEYTYPE_PAIRWISE; + struct l_genl_msg *msg; + + msg = l_genl_msg_new_sized(NL80211_CMD_NEW_KEY, 512); + + l_genl_msg_append_attr(msg, NL80211_ATTR_MAC, ETH_ALEN, aa); + l_genl_msg_append_attr(msg, NL80211_ATTR_IFINDEX, 4, &netdev->index); + + l_genl_msg_enter_nested(msg, NL80211_ATTR_KEY); + + l_genl_msg_append_attr(msg, NL80211_KEY_DATA, tk_len, tk); + l_genl_msg_append_attr(msg, NL80211_KEY_CIPHER, 4, &cipher); + l_genl_msg_append_attr(msg, NL80211_KEY_IDX, 1, &key_id); + l_genl_msg_append_attr(msg, NL80211_KEY_MODE, 1, &key_mode); + l_genl_msg_append_attr(msg, NL80211_KEY_TYPE, 4, &key_type); + + l_genl_msg_leave_nested(msg); + + return msg; +} + static void netdev_group_timeout_cb(struct l_timeout *timeout, void *user_data) { struct netdev_handshake_state *nhs = user_data; @@ -1823,7 +2047,8 @@ static void netdev_set_tk(struct handshake_state *hs, goto invalid_key; msg = netdev_build_cmd_new_key_pairwise(netdev, cipher, addr, tk_buf, - crypto_cipher_key_len(cipher)); + crypto_cipher_key_len(cipher), + hs->active_tk_index); nhs->pairwise_new_key_cmd_id = l_genl_family_send(nl80211, msg, netdev_new_pairwise_key_cb, nhs, NULL); @@ -1836,6 +2061,74 @@ invalid_key: netdev_setting_keys_failed(nhs, err); } +static void netdev_set_ext_tk(struct handshake_state *hs, uint8_t key_idx, + const uint8_t *tk, uint32_t cipher, + const struct eapol_frame *step4, uint16_t proto, + bool noencrypt) +{ + struct netdev_handshake_state *nhs = + l_container_of(hs, struct netdev_handshake_state, super); + uint8_t tk_buf[32]; + struct netdev *netdev = nhs->netdev; + struct l_genl_msg *msg; + const uint8_t *addr = netdev_choose_key_address(nhs); + int err; + size_t frame_size = sizeof(struct eapol_header) + + L_BE16_TO_CPU(step4->header.packet_len); + + err = -ENOENT; + if (!netdev_copy_tk(tk_buf, tk, cipher, false)) + goto error; + + msg = netdev_build_cmd_new_rx_key_pairwise(netdev, cipher, addr, tk_buf, + crypto_cipher_key_len(cipher), + hs->active_tk_index); + nhs->pairwise_new_key_cmd_id = + l_genl_family_send(nl80211, msg, netdev_new_rx_pairwise_key_cb, + nhs, NULL); + + if (!nhs->pairwise_new_key_cmd_id) + goto io_error; + + /* + * Without control port we cannot guarantee the order that messages go + * out and must wait for NEW_KEY to call back before sending message 4 + */ + if (!wiphy_control_port_enabled(netdev->wiphy)) { + netdev->ext_key_info = l_malloc( + sizeof(struct netdev_ext_key_info) + + frame_size); + memcpy(netdev->ext_key_info->frame, step4, frame_size); + netdev->ext_key_info->proto = proto; + netdev->ext_key_info->noencrypt = noencrypt; + return; + } + + /* + * Otherwise, order of messages will be guaranteed. Therefore we can + * send send message 4, and set the TK to TX (below) without waiting for + * any callbacks + */ + err = netdev_control_port_frame(netdev->index, netdev->handshake->aa, + proto, step4, noencrypt, NULL); + if (err < 0) + goto error; + + /* Then toggle to RX + TX */ + err = netdev_set_key_tx(netdev); + if (err < 0) + goto error; + + return; + +io_error: + err = -EIO; + l_genl_msg_unref(msg); + +error: + netdev_setting_keys_failed(nhs, err); +} + static void netdev_set_pmk_cb(struct l_genl_msg *msg, void *user_data) { struct netdev_handshake_state *nhs = user_data; @@ -5122,107 +5415,6 @@ static void netdev_control_port_frame_event(struct l_genl_msg *msg, frame, frame_len, unencrypted); } -static struct l_genl_msg *netdev_build_control_port_frame(struct netdev *netdev, - const uint8_t *to, - uint16_t proto, - bool unencrypted, - const void *body, - size_t body_len) -{ - struct l_genl_msg *msg; - - msg = l_genl_msg_new_sized(NL80211_CMD_CONTROL_PORT_FRAME, - 128 + body_len); - - l_genl_msg_append_attr(msg, NL80211_ATTR_IFINDEX, 4, &netdev->index); - l_genl_msg_append_attr(msg, NL80211_ATTR_FRAME, body_len, body); - l_genl_msg_append_attr(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, 2, - &proto); - l_genl_msg_append_attr(msg, NL80211_ATTR_MAC, ETH_ALEN, to); - - if (unencrypted) - l_genl_msg_append_attr(msg, - NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT, 0, NULL); - - return msg; -} - -static void netdev_control_port_frame_cb(struct l_genl_msg *msg, - void *user_data) -{ - int err = l_genl_msg_get_error(msg); - const char *ext_error; - - if (err >= 0) - return; - - ext_error = l_genl_msg_get_extended_error(msg); - l_error("CMD_CONTROL_PORT failed: %s", - ext_error ? ext_error : strerror(-err)); -} - -static int netdev_control_port_write_pae(struct netdev *netdev, - const uint8_t *dest, - uint16_t proto, - const struct eapol_frame *ef, - bool noencrypt) -{ - int fd = l_io_get_fd(netdev->pae_io); - struct sockaddr_ll sll; - size_t frame_size = sizeof(struct eapol_header) + - L_BE16_TO_CPU(ef->header.packet_len); - ssize_t r; - - memset(&sll, 0, sizeof(sll)); - sll.sll_family = AF_PACKET; - sll.sll_ifindex = netdev->index; - sll.sll_protocol = htons(proto); - sll.sll_halen = ETH_ALEN; - memcpy(sll.sll_addr, dest, ETH_ALEN); - - r = sendto(fd, ef, frame_size, 0, - (struct sockaddr *) &sll, sizeof(sll)); - if (r < 0) - l_error("EAPoL write socket: %s", strerror(errno)); - - return r; -} - -static int netdev_control_port_frame(uint32_t ifindex, - const uint8_t *dest, uint16_t proto, - const struct eapol_frame *ef, - bool noencrypt, - void *user_data) -{ - struct l_genl_msg *msg; - struct netdev *netdev; - size_t frame_size; - - netdev = netdev_find(ifindex); - if (!netdev) - return -ENOENT; - - frame_size = sizeof(struct eapol_header) + - L_BE16_TO_CPU(ef->header.packet_len); - - if (!netdev->pae_over_nl80211) - return netdev_control_port_write_pae(netdev, dest, proto, - ef, noencrypt); - - msg = netdev_build_control_port_frame(netdev, dest, proto, noencrypt, - ef, frame_size); - if (!msg) - return -ENOMEM; - - if (!l_genl_family_send(nl80211, msg, netdev_control_port_frame_cb, - netdev, NULL)) { - l_genl_msg_unref(msg); - return -EINVAL; - } - - return 0; -} - static void netdev_unicast_notify(struct l_genl_msg *msg, void *user_data) { struct netdev *netdev = NULL; @@ -6243,6 +6435,7 @@ static int netdev_init(void) __handshake_set_install_tk_func(netdev_set_tk); __handshake_set_install_gtk_func(netdev_set_gtk); __handshake_set_install_igtk_func(netdev_set_igtk); + __handshake_set_install_ext_tk_func(netdev_set_ext_tk); __eapol_set_rekey_offload_func(netdev_set_rekey_offload); __eapol_set_tx_packet_func(netdev_control_port_frame); -- 2.31.1

If wiphy and the AP suppor it, set the Extended Key ID capability bit in the RSN info. --- src/station.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/station.c b/src/station.c index f12cdde5..30335170 100644 --- a/src/station.c +++ b/src/station.c @@ -1087,6 +1087,10 @@ build_ie: info.ocvc = !disable_ocv; + /* Extended Key IDs can only be used if supported by both AP and STA */ + if (wiphy_supports_ext_key_id(wiphy) && bss_info.extended_key_id) + info.extended_key_id = true; + /* RSN takes priority */ if (bss->rsne) { ap_ie = bss->rsne; -- 2.31.1

REKEY_GTK kicks off the GTK only handshake where REKEY_PTK does both (via the 4-way). The way this utility was written was causing hostapd some major issues since both REKEY_GTK and REKEY_PTK was used. Instead if address is set only do REKEY_PTK. This will also rekey the GTK via the 4-way handshake. If no address is set do REKEY_GTK which will only rekey the GTK. --- autotests/util/hostapd.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/autotests/util/hostapd.py b/autotests/util/hostapd.py index 9f2dc745..22802be6 100644 --- a/autotests/util/hostapd.py +++ b/autotests/util/hostapd.py @@ -202,11 +202,15 @@ class HostapdCLI(object): cmd = self.cmdline + ['req_beacon', addr, request] ctx.start_process(cmd).wait() - def rekey(self, address): + def rekey(self, address=None): + if address: + cmd = 'REKEY_PTK %s' % address + self.ctrl_sock.sendall(cmd.encode('utf-8')) + self.wait_for_event('EAPOL-4WAY-HS-COMPLETED') + return + cmd = 'REKEY_GTK' self.ctrl_sock.sendall(cmd.encode('utf-8')) - cmd = 'REKEY_PTK %s' % address - self.ctrl_sock.sendall(cmd.encode('utf-8')) @property def bssid(self): -- 2.31.1

--- .../testWPA2-ext-key-id/connection_test.py | 112 ++++++++++++++++++ autotests/testWPA2-ext-key-id/hw.conf | 6 + autotests/testWPA2-ext-key-id/main_pae.conf | 2 + autotests/testWPA2-ext-key-id/ssidCCMP.conf | 11 ++ 4 files changed, 131 insertions(+) create mode 100644 autotests/testWPA2-ext-key-id/connection_test.py create mode 100644 autotests/testWPA2-ext-key-id/hw.conf create mode 100644 autotests/testWPA2-ext-key-id/main_pae.conf create mode 100644 autotests/testWPA2-ext-key-id/ssidCCMP.conf diff --git a/autotests/testWPA2-ext-key-id/connection_test.py b/autotests/testWPA2-ext-key-id/connection_test.py new file mode 100644 index 00000000..afd48149 --- /dev/null +++ b/autotests/testWPA2-ext-key-id/connection_test.py @@ -0,0 +1,112 @@ +#!/usr/bin/python3 + +import unittest +import sys +import os + +sys.path.append('../util') +from iwd import IWD_CONFIG_DIR +from iwd import IWD +from iwd import PSKAgent +from iwd import NetworkType +from hwsim import Hwsim +from hostapd import HostapdCLI +import testutil + +class Test(unittest.TestCase): + def validate(self, wd, resend_m3=False): + hapd = HostapdCLI('ssidCCMP.conf') + + psk_agent = PSKAgent("secret123") + wd.register_psk_agent(psk_agent) + + devices = wd.list_devices(1) + device = devices[0] + + ordered_network = device.get_ordered_network('ssidCCMP') + + self.assertEqual(ordered_network.type, NetworkType.psk) + + condition = 'not obj.connected' + wd.wait_for_object_condition(ordered_network.network_object, condition) + + ordered_network.network_object.connect() + + condition = 'obj.state == DeviceState.connected' + wd.wait_for_object_condition(device, condition) + + testutil.test_iface_operstate() + testutil.test_ifaces_connected() + + + # Rekey 5 times just to make sure the key ID can be toggled back and + # forth without causing problems. + for i in range(5): + hapd.rekey(device.address) + + if resend_m3: + hapd.resend_m3(device.address) + + testutil.test_iface_operstate() + testutil.test_ifaces_connected() + + device.disconnect() + + condition = 'not obj.connected' + wd.wait_for_object_condition(ordered_network.network_object, condition) + + wd.unregister_psk_agent(psk_agent) + + def test_ext_key_control_port(self): + self.hapd.set_value('extended_key_id', '1') + self.hapd.reload() + + self.wd = IWD(True) + + self.validate(self.wd) + + def test_ext_key_control_port_retransmit(self): + self.hapd.set_value('extended_key_id', '1') + self.hapd.reload() + + self.wd = IWD(True) + + self.validate(self.wd, resend_m3=True) + + def test_ext_key_index_1(self): + self.hapd.set_value('extended_key_id', '2') + self.hapd.reload() + + self.wd = IWD(True) + + self.validate(self.wd) + + def test_ext_key_pae(self): + self.hapd.set_value('extended_key_id', '1') + self.hapd.reload() + + IWD.copy_to_storage('main_pae.conf', storage_dir=IWD_CONFIG_DIR, name='main.conf') + + self.wd = IWD(True) + + self.validate(self.wd) + + def tearDown(self): + try: + os.system('rm -rf %s/main.conf' % IWD_CONFIG_DIR) + except: + pass + + self.wd = None + + @classmethod + def setUpClass(cls): + cls.hapd = HostapdCLI() + + @classmethod + def tearDownClass(cls): + IWD.clear_storage() + cls.hapd = None + +if __name__ == '__main__': + unittest.main(exit=True) diff --git a/autotests/testWPA2-ext-key-id/hw.conf b/autotests/testWPA2-ext-key-id/hw.conf new file mode 100644 index 00000000..de81e1e2 --- /dev/null +++ b/autotests/testWPA2-ext-key-id/hw.conf @@ -0,0 +1,6 @@ +[SETUP] +num_radios=2 +start_iwd=0 + +[HOSTAPD] +rad0=ssidCCMP.conf diff --git a/autotests/testWPA2-ext-key-id/main_pae.conf b/autotests/testWPA2-ext-key-id/main_pae.conf new file mode 100644 index 00000000..8bcedda5 --- /dev/null +++ b/autotests/testWPA2-ext-key-id/main_pae.conf @@ -0,0 +1,2 @@ +[General] +ControlPortOverNL80211=false diff --git a/autotests/testWPA2-ext-key-id/ssidCCMP.conf b/autotests/testWPA2-ext-key-id/ssidCCMP.conf new file mode 100644 index 00000000..b52bfb7c --- /dev/null +++ b/autotests/testWPA2-ext-key-id/ssidCCMP.conf @@ -0,0 +1,11 @@ +hw_mode=g +channel=1 +ssid=ssidCCMP + +wpa=2 +wpa_pairwise=CCMP +wpa_passphrase=secret123 + +ieee80211w=2 +wpa_key_mgmt=WPA-PSK-SHA256 +extended_key_id=1 -- 2.31.1