Changeset bc4bb2e in rtems-libbsd


Ignore:
Timestamp:
Oct 17, 2017, 5:22:36 PM (2 years ago)
Author:
gordon <gordon@…>
Branches:
c1e05b9ea378b2971e3d7704779112b4bc4296da, 4a77611a223ea883fb548679b516d326a020d447
Children:
9521c08
Parents:
bdc4f21
git-author:
gordon <gordon@…> (10/17/17 17:22:36)
git-committer:
Sebastian Huber <sebastian.huber@…> (11/10/17 13:13:19)
Message:

Update wpa_supplicant/hostapd for 2017-01 vulnerability release.

hostapd: Avoid key reinstallation in FT handshake
Prevent reinstallation of an already in-use group key
Extend protection of GTK/IGTK reinstallation of WNM-Sleep Mode cases
Fix TK configuration to the driver in EAPOL-Key 3/4 retry case
Prevent installation of an all-zero TK
Fix PTK rekeying to generate a new ANonce
TDLS: Reject TPK-TK reconfiguration
WNM: Ignore Key Data in WNM Sleep Mode Response frame if no PMF in use
WNM: Ignore WNM-Sleep Mode Response if WNM-Sleep Mode has not been used
WNM: Ignore WNM-Sleep Mode Response without pending request
FT: Do not allow multiple Reassociation Response frames
TDLS: Ignore incoming TDLS Setup Response retries

Submitted by: jhb
Obtained from: https://w1.fi/security/2017-01/ (against later version)
Security: FreeBSD-SA-17:07
Security: CERT VU#228519
Security: CVE-2017-13077
Security: CVE-2017-13078
Security: CVE-2017-13079
Security: CVE-2017-13080
Security: CVE-2017-13081
Security: CVE-2017-13082
Security: CVE-2017-13086
Security: CVE-2017-13087
Security: CVE-2017-13088
Differential Revision: https://reviews.freebsd.org/D12693

Location:
freebsd/contrib/wpa
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • freebsd/contrib/wpa/src/ap/wpa_auth.c

    rbdc4f21 rbc4bb2e  
    18961896
    18971897
     1898static int wpa_auth_sm_ptk_update(struct wpa_state_machine *sm)
     1899{
     1900        if (random_get_bytes(sm->ANonce, WPA_NONCE_LEN)) {
     1901                wpa_printf(MSG_ERROR,
     1902                           "WPA: Failed to get random data for ANonce");
     1903                sm->Disconnect = TRUE;
     1904                return -1;
     1905        }
     1906        wpa_hexdump(MSG_DEBUG, "WPA: Assign new ANonce", sm->ANonce,
     1907                    WPA_NONCE_LEN);
     1908        sm->TimeoutCtr = 0;
     1909        return 0;
     1910}
     1911
     1912
    18981913SM_STATE(WPA_PTK, INITPMK)
    18991914{
     
    24172432        else if (sm->ReAuthenticationRequest)
    24182433                SM_ENTER(WPA_PTK, AUTHENTICATION2);
    2419         else if (sm->PTKRequest)
    2420                 SM_ENTER(WPA_PTK, PTKSTART);
    2421         else switch (sm->wpa_ptk_state) {
     2434        else if (sm->PTKRequest) {
     2435                if (wpa_auth_sm_ptk_update(sm) < 0)
     2436                        SM_ENTER(WPA_PTK, DISCONNECTED);
     2437                else
     2438                        SM_ENTER(WPA_PTK, PTKSTART);
     2439        } else switch (sm->wpa_ptk_state) {
    24222440        case WPA_PTK_INITIALIZE:
    24232441                break;
     
    32123230
    32133231
     3232int wpa_auth_sta_ft_tk_already_set(struct wpa_state_machine *sm)
     3233{
     3234        if (!sm || !wpa_key_mgmt_ft(sm->wpa_key_mgmt))
     3235                return 0;
     3236        return sm->tk_already_set;
     3237}
     3238
     3239
    32143240int wpa_auth_sta_clear_pmksa(struct wpa_state_machine *sm,
    32153241                             struct rsn_pmksa_cache_entry *entry)
  • freebsd/contrib/wpa/src/ap/wpa_auth.h

    rbdc4f21 rbc4bb2e  
    272272int wpa_auth_sta_key_mgmt(struct wpa_state_machine *sm);
    273273int wpa_auth_sta_wpa_version(struct wpa_state_machine *sm);
     274int wpa_auth_sta_ft_tk_already_set(struct wpa_state_machine *sm);
    274275int wpa_auth_sta_clear_pmksa(struct wpa_state_machine *sm,
    275276                             struct rsn_pmksa_cache_entry *entry);
  • freebsd/contrib/wpa/src/ap/wpa_auth_ft.c

    rbdc4f21 rbc4bb2e  
    783783        }
    784784
     785        if (sm->tk_already_set) {
     786                /* Must avoid TK reconfiguration to prevent clearing of TX/RX
     787                 * PN in the driver */
     788                wpa_printf(MSG_DEBUG,
     789                           "FT: Do not re-install same PTK to the driver");
     790                return;
     791        }
     792
    785793        /* FIX: add STA entry to kernel/driver here? The set_key will fail
    786794         * most likely without this.. At the moment, STA entry is added only
     
    795803        /* FIX: MLME-SetProtection.Request(TA, Tx_Rx) */
    796804        sm->pairwise_set = TRUE;
     805        sm->tk_already_set = TRUE;
    797806}
    798807
     
    901910        sm->pairwise = pairwise;
    902911        sm->PTK_valid = TRUE;
     912        sm->tk_already_set = FALSE;
    903913        wpa_ft_install_ptk(sm);
    904914
  • freebsd/contrib/wpa/src/ap/wpa_auth_i.h

    rbdc4f21 rbc4bb2e  
    6565        Boolean PTK_valid;
    6666        Boolean pairwise_set;
     67        Boolean tk_already_set;
    6768        int keycount;
    6869        Boolean Pair;
  • freebsd/contrib/wpa/src/common/wpa_common.h

    rbdc4f21 rbc4bb2e  
    214214        size_t kek_len;
    215215        size_t tk_len;
    216 };
    217 
     216        int installed; /* 1 if key has already been installed to driver */
     217};
     218
     219struct wpa_gtk {
     220        u8 gtk[WPA_GTK_MAX_LEN];
     221        size_t gtk_len;
     222};
     223
     224#ifdef CONFIG_IEEE80211W
     225struct wpa_igtk {
     226        u8 igtk[WPA_IGTK_MAX_LEN];
     227        size_t igtk_len;
     228};
     229#endif /* CONFIG_IEEE80211W */
    218230
    219231/* WPA IE version 1
  • freebsd/contrib/wpa/src/rsn_supp/tdls.c

    rbdc4f21 rbc4bb2e  
    116116        } tpk;
    117117        int tpk_set;
     118        int tk_set; /* TPK-TK configured to the driver */
    118119        int tpk_success;
    119120        int tpk_in_progress;
     
    196197        enum wpa_alg alg;
    197198
     199        if (peer->tk_set) {
     200                /*
     201                 * This same TPK-TK has already been configured to the driver
     202                 * and this new configuration attempt (likely due to an
     203                 * unexpected retransmitted frame) would result in clearing
     204                 * the TX/RX sequence number which can break security, so must
     205                 * not allow that to happen.
     206                 */
     207                wpa_printf(MSG_INFO, "TDLS: TPK-TK for the peer " MACSTR
     208                           " has already been configured to the driver - do not reconfigure",
     209                           MAC2STR(peer->addr));
     210                return -1;
     211        }
     212
    198213        os_memset(rsc, 0, 6);
    199214
     
    213228        }
    214229
     230        wpa_printf(MSG_DEBUG, "TDLS: Configure pairwise key for peer " MACSTR,
     231                   MAC2STR(peer->addr));
    215232        if (wpa_sm_set_key(sm, alg, peer->addr, -1, 1,
    216233                           rsc, sizeof(rsc), peer->tpk.tk, key_len) < 0) {
     
    219236                return -1;
    220237        }
     238        peer->tk_set = 1;
    221239        return 0;
    222240}
     
    694712        peer->qos_info = 0;
    695713        peer->wmm_capable = 0;
    696         peer->tpk_set = peer->tpk_success = 0;
     714        peer->tk_set = peer->tpk_set = peer->tpk_success = 0;
    697715        peer->chan_switch_enabled = 0;
    698716        os_memset(&peer->tpk, 0, sizeof(peer->tpk));
     
    11571175                return -1;
    11581176        }
     1177        peer->tk_set = 0; /* A new nonce results in a new TK */
    11591178        wpa_hexdump(MSG_DEBUG, "TDLS: Initiator Nonce for TPK handshake",
    11601179                    peer->inonce, WPA_NONCE_LEN);
     
    17461765                                       peer->supp_oper_classes,
    17471766                                       peer->supp_oper_classes_len);
     1767}
     1768
     1769
     1770static int tdls_nonce_set(const u8 *nonce)
     1771{
     1772        int i;
     1773
     1774        for (i = 0; i < WPA_NONCE_LEN; i++) {
     1775                if (nonce[i])
     1776                        return 1;
     1777        }
     1778
     1779        return 0;
    17481780}
    17491781
     
    20022034        peer->cipher = cipher;
    20032035
    2004         if (os_memcmp(peer->inonce, ftie->Snonce, WPA_NONCE_LEN) != 0) {
     2036        if (os_memcmp(peer->inonce, ftie->Snonce, WPA_NONCE_LEN) != 0 ||
     2037            !tdls_nonce_set(peer->inonce)) {
    20052038                /*
    20062039                 * There is no point in updating the RNonce for every obtained
     
    20182051                        goto error;
    20192052                }
     2053                peer->tk_set = 0; /* A new nonce results in a new TK */
    20202054        }
    20212055
     
    21742208                return -1;
    21752209        }
     2210
     2211        if (peer->tpk_success) {
     2212                wpa_printf(MSG_INFO, "TDLS: Ignore incoming TPK M2 retry, from "
     2213                           MACSTR " as TPK M3 was already sent",
     2214                           MAC2STR(src_addr));
     2215                return 0;
     2216        }
     2217
    21762218        wpa_tdls_tpk_retry_timeout_cancel(sm, peer, WLAN_TDLS_SETUP_REQUEST);
    21772219
  • freebsd/contrib/wpa/src/rsn_supp/wpa.c

    rbdc4f21 rbc4bb2e  
    608608        u8 null_rsc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    609609
     610        if (sm->ptk.installed) {
     611                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     612                        "WPA: Do not re-install same PTK to the driver");
     613                return 0;
     614        }
     615
    610616        wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
    611617                "WPA: Installing PTK to the driver");
     
    646652        /* TK is not needed anymore in supplicant */
    647653        os_memset(sm->ptk.tk, 0, WPA_TK_MAX_LEN);
     654        sm->ptk.installed = 1;
    648655
    649656        if (sm->wpa_ptk_rekey) {
     
    695702static int wpa_supplicant_install_gtk(struct wpa_sm *sm,
    696703                                      const struct wpa_gtk_data *gd,
    697                                       const u8 *key_rsc)
     704                                      const u8 *key_rsc, int wnm_sleep)
    698705{
    699706        const u8 *_gtk = gd->gtk;
    700707        u8 gtk_buf[32];
     708
     709        /* Detect possible key reinstallation */
     710        if ((sm->gtk.gtk_len == (size_t) gd->gtk_len &&
     711             os_memcmp(sm->gtk.gtk, gd->gtk, sm->gtk.gtk_len) == 0) ||
     712            (sm->gtk_wnm_sleep.gtk_len == (size_t) gd->gtk_len &&
     713             os_memcmp(sm->gtk_wnm_sleep.gtk, gd->gtk,
     714                       sm->gtk_wnm_sleep.gtk_len) == 0)) {
     715                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     716                        "WPA: Not reinstalling already in-use GTK to the driver (keyidx=%d tx=%d len=%d)",
     717                        gd->keyidx, gd->tx, gd->gtk_len);
     718                return 0;
     719        }
    701720
    702721        wpa_hexdump_key(MSG_DEBUG, "WPA: Group Key", gd->gtk, gd->gtk_len);
     
    734753        os_memset(gtk_buf, 0, sizeof(gtk_buf));
    735754
     755        if (wnm_sleep) {
     756                sm->gtk_wnm_sleep.gtk_len = gd->gtk_len;
     757                os_memcpy(sm->gtk_wnm_sleep.gtk, gd->gtk,
     758                          sm->gtk_wnm_sleep.gtk_len);
     759        } else {
     760                sm->gtk.gtk_len = gd->gtk_len;
     761                os_memcpy(sm->gtk.gtk, gd->gtk, sm->gtk.gtk_len);
     762        }
     763
    736764        return 0;
    737765}
     
    791819                                               gtk_len, gtk_len,
    792820                                               &gd.key_rsc_len, &gd.alg) ||
    793              wpa_supplicant_install_gtk(sm, &gd, key->key_rsc))) {
     821             wpa_supplicant_install_gtk(sm, &gd, key->key_rsc, 0))) {
    794822                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
    795823                        "RSN: Failed to install GTK");
     
    805833
    806834
     835#ifdef CONFIG_IEEE80211W
     836static int wpa_supplicant_install_igtk(struct wpa_sm *sm,
     837                                       const struct wpa_igtk_kde *igtk,
     838                                       int wnm_sleep)
     839{
     840        size_t len = wpa_cipher_key_len(sm->mgmt_group_cipher);
     841        u16 keyidx = WPA_GET_LE16(igtk->keyid);
     842
     843        /* Detect possible key reinstallation */
     844        if ((sm->igtk.igtk_len == len &&
     845             os_memcmp(sm->igtk.igtk, igtk->igtk, sm->igtk.igtk_len) == 0) ||
     846            (sm->igtk_wnm_sleep.igtk_len == len &&
     847             os_memcmp(sm->igtk_wnm_sleep.igtk, igtk->igtk,
     848                       sm->igtk_wnm_sleep.igtk_len) == 0)) {
     849                wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     850                        "WPA: Not reinstalling already in-use IGTK to the driver (keyidx=%d)",
     851                        keyidx);
     852                return  0;
     853        }
     854
     855        wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
     856                "WPA: IGTK keyid %d pn %02x%02x%02x%02x%02x%02x",
     857                keyidx, MAC2STR(igtk->pn));
     858        wpa_hexdump_key(MSG_DEBUG, "WPA: IGTK", igtk->igtk, len);
     859        if (keyidx > 4095) {
     860                wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
     861                        "WPA: Invalid IGTK KeyID %d", keyidx);
     862                return -1;
     863        }
     864        if (wpa_sm_set_key(sm, wpa_cipher_to_alg(sm->mgmt_group_cipher),
     865                           broadcast_ether_addr,
     866                           keyidx, 0, igtk->pn, sizeof(igtk->pn),
     867                           igtk->igtk, len) < 0) {
     868                wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
     869                        "WPA: Failed to configure IGTK to the driver");
     870                return -1;
     871        }
     872
     873        if (wnm_sleep) {
     874                sm->igtk_wnm_sleep.igtk_len = len;
     875                os_memcpy(sm->igtk_wnm_sleep.igtk, igtk->igtk,
     876                          sm->igtk_wnm_sleep.igtk_len);
     877        } else {
     878                sm->igtk.igtk_len = len;
     879                os_memcpy(sm->igtk.igtk, igtk->igtk, sm->igtk.igtk_len);
     880        }
     881
     882        return 0;
     883}
     884#endif /* CONFIG_IEEE80211W */
     885
     886
    807887static int ieee80211w_set_keys(struct wpa_sm *sm,
    808888                               struct wpa_eapol_ie_parse *ie)
     
    815895                size_t len;
    816896                const struct wpa_igtk_kde *igtk;
    817                 u16 keyidx;
     897
    818898                len = wpa_cipher_key_len(sm->mgmt_group_cipher);
    819899                if (ie->igtk_len != WPA_IGTK_KDE_PREFIX_LEN + len)
    820900                        return -1;
     901
    821902                igtk = (const struct wpa_igtk_kde *) ie->igtk;
    822                 keyidx = WPA_GET_LE16(igtk->keyid);
    823                 wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG, "WPA: IGTK keyid %d "
    824                         "pn %02x%02x%02x%02x%02x%02x",
    825                         keyidx, MAC2STR(igtk->pn));
    826                 wpa_hexdump_key(MSG_DEBUG, "WPA: IGTK",
    827                                 igtk->igtk, len);
    828                 if (keyidx > 4095) {
    829                         wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
    830                                 "WPA: Invalid IGTK KeyID %d", keyidx);
     903                if (wpa_supplicant_install_igtk(sm, igtk, 0) < 0)
    831904                        return -1;
    832                 }
    833                 if (wpa_sm_set_key(sm, wpa_cipher_to_alg(sm->mgmt_group_cipher),
    834                                    broadcast_ether_addr,
    835                                    keyidx, 0, igtk->pn, sizeof(igtk->pn),
    836                                    igtk->igtk, len) < 0) {
    837                         wpa_msg(sm->ctx->msg_ctx, MSG_WARNING,
    838                                 "WPA: Failed to configure IGTK to the driver");
    839                         return -1;
    840                 }
    841905        }
    842906
     
    14861550                goto failed;
    14871551
    1488         if (wpa_supplicant_install_gtk(sm, &gd, key->key_rsc) ||
     1552        if (wpa_supplicant_install_gtk(sm, &gd, key->key_rsc, 0) ||
    14891553            wpa_supplicant_send_2_of_2(sm, key, ver, key_info))
    14901554                goto failed;
     
    22542318void wpa_sm_notify_assoc(struct wpa_sm *sm, const u8 *bssid)
    22552319{
    2256         int clear_ptk = 1;
     2320        int clear_keys = 1;
    22572321
    22582322        if (sm == NULL)
     
    22802344                wpa_ft_prepare_auth_request(sm, NULL);
    22812345
    2282                 clear_ptk = 0;
     2346                clear_keys = 0;
    22832347        }
    22842348#endif /* CONFIG_IEEE80211R */
    22852349
    2286         if (clear_ptk) {
     2350        if (clear_keys) {
    22872351                /*
    22882352                 * IEEE 802.11, 8.4.10: Delete PTK SA on (re)association if
     
    22942358                sm->tptk_set = 0;
    22952359                os_memset(&sm->tptk, 0, sizeof(sm->tptk));
     2360                os_memset(&sm->gtk, 0, sizeof(sm->gtk));
     2361                os_memset(&sm->gtk_wnm_sleep, 0, sizeof(sm->gtk_wnm_sleep));
     2362#ifdef CONFIG_IEEE80211W
     2363                os_memset(&sm->igtk, 0, sizeof(sm->igtk));
     2364                os_memset(&sm->igtk_wnm_sleep, 0, sizeof(sm->igtk_wnm_sleep));
     2365#endif /* CONFIG_IEEE80211W */
    22962366        }
    22972367
     
    23252395        wpa_tdls_disassoc(sm);
    23262396#endif /* CONFIG_TDLS */
     2397#ifdef CONFIG_IEEE80211R
     2398        sm->ft_reassoc_completed = 0;
     2399#endif /* CONFIG_IEEE80211R */
    23272400
    23282401        /* Keys are not needed in the WPA state machine anymore */
     
    28102883        os_memset(&sm->ptk, 0, sizeof(sm->ptk));
    28112884        os_memset(&sm->tptk, 0, sizeof(sm->tptk));
     2885        os_memset(&sm->gtk, 0, sizeof(sm->gtk));
     2886        os_memset(&sm->gtk_wnm_sleep, 0, sizeof(sm->gtk_wnm_sleep));
     2887#ifdef CONFIG_IEEE80211W
     2888        os_memset(&sm->igtk, 0, sizeof(sm->igtk));
     2889        os_memset(&sm->igtk_wnm_sleep, 0, sizeof(sm->igtk_wnm_sleep));
     2890#endif /* CONFIG_IEEE80211W */
    28122891#ifdef CONFIG_IEEE80211R
    28132892        os_memset(sm->xxkey, 0, sizeof(sm->xxkey));
     
    28732952                wpa_hexdump_key(MSG_DEBUG, "Install GTK (WNM SLEEP)",
    28742953                                gd.gtk, gd.gtk_len);
    2875                 if (wpa_supplicant_install_gtk(sm, &gd, key_rsc)) {
     2954                if (wpa_supplicant_install_gtk(sm, &gd, key_rsc, 1)) {
    28762955                        os_memset(&gd, 0, sizeof(gd));
    28772956                        wpa_printf(MSG_DEBUG, "Failed to install the GTK in "
     
    28822961#ifdef CONFIG_IEEE80211W
    28832962        } else if (subelem_id == WNM_SLEEP_SUBELEM_IGTK) {
    2884                 struct wpa_igtk_kde igd;
    2885                 u16 keyidx;
    2886 
    2887                 os_memset(&igd, 0, sizeof(igd));
    2888                 keylen = wpa_cipher_key_len(sm->mgmt_group_cipher);
    2889                 os_memcpy(igd.keyid, buf + 2, 2);
    2890                 os_memcpy(igd.pn, buf + 4, 6);
    2891 
    2892                 keyidx = WPA_GET_LE16(igd.keyid);
    2893                 os_memcpy(igd.igtk, buf + 10, keylen);
    2894 
    2895                 wpa_hexdump_key(MSG_DEBUG, "Install IGTK (WNM SLEEP)",
    2896                                 igd.igtk, keylen);
    2897                 if (wpa_sm_set_key(sm, wpa_cipher_to_alg(sm->mgmt_group_cipher),
    2898                                    broadcast_ether_addr,
    2899                                    keyidx, 0, igd.pn, sizeof(igd.pn),
    2900                                    igd.igtk, keylen) < 0) {
    2901                         wpa_printf(MSG_DEBUG, "Failed to install the IGTK in "
    2902                                    "WNM mode");
    2903                         os_memset(&igd, 0, sizeof(igd));
     2963                const struct wpa_igtk_kde *igtk;
     2964
     2965                igtk = (const struct wpa_igtk_kde *) (buf + 2);
     2966                if (wpa_supplicant_install_igtk(sm, igtk, 1) < 0)
    29042967                        return -1;
    2905                 }
    2906                 os_memset(&igd, 0, sizeof(igd));
    29072968#endif /* CONFIG_IEEE80211W */
    29082969        } else {
  • freebsd/contrib/wpa/src/rsn_supp/wpa_ft.c

    rbdc4f21 rbc4bb2e  
    156156
    157157        sm->ft_completed = 0;
     158        sm->ft_reassoc_completed = 0;
    158159
    159160        buf_len = 2 + sizeof(struct rsn_mdie) + 2 + sizeof(struct rsn_ftie) +
     
    684685        }
    685686
     687        if (sm->ft_reassoc_completed) {
     688                wpa_printf(MSG_DEBUG, "FT: Reassociation has already been completed for this FT protocol instance - ignore unexpected retransmission");
     689                return 0;
     690        }
     691
    686692        if (wpa_ft_parse_ies(ies, ies_len, &parse) < 0) {
    687693                wpa_printf(MSG_DEBUG, "FT: Failed to parse IEs");
     
    784790        }
    785791
     792        sm->ft_reassoc_completed = 1;
     793
    786794        if (wpa_ft_process_gtk_subelem(sm, parse.gtk, parse.gtk_len) < 0)
    787795                return -1;
  • freebsd/contrib/wpa/src/rsn_supp/wpa_i.h

    rbdc4f21 rbc4bb2e  
    3131        int rx_replay_counter_set;
    3232        u8 request_counter[WPA_REPLAY_COUNTER_LEN];
     33        struct wpa_gtk gtk;
     34        struct wpa_gtk gtk_wnm_sleep;
     35#ifdef CONFIG_IEEE80211W
     36        struct wpa_igtk igtk;
     37        struct wpa_igtk igtk_wnm_sleep;
     38#endif /* CONFIG_IEEE80211W */
    3339
    3440        struct eapol_sm *eapol; /* EAPOL state machine from upper level code */
     
    122128        u8 r1kh_id[FT_R1KH_ID_LEN];
    123129        int ft_completed;
     130        int ft_reassoc_completed;
    124131        int over_the_ds_in_progress;
    125132        u8 target_ap[ETH_ALEN]; /* over-the-DS target AP */
  • freebsd/contrib/wpa/wpa_supplicant/ctrl_iface.c

    rbdc4f21 rbc4bb2e  
    68946894
    68956895        eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
     6896        wpa_s->wnmsleep_used = 0;
    68966897}
    68976898
  • freebsd/contrib/wpa/wpa_supplicant/events.c

    rbdc4f21 rbc4bb2e  
    306306
    307307        wpas_rrm_reset(wpa_s);
     308        wpa_s->wnmsleep_used = 0;
    308309}
    309310
  • freebsd/contrib/wpa/wpa_supplicant/wnm_sta.c

    rbdc4f21 rbc4bb2e  
    141141                wpa_printf(MSG_DEBUG, "Failed to send WNM-Sleep Request "
    142142                           "(action=%d, intval=%d)", action, intval);
     143        else
     144                wpa_s->wnmsleep_used = 1;
    143145
    144146        os_free(wnmsleep_ie);
     
    190192        end = ptr + key_len_total;
    191193        wpa_hexdump_key(MSG_DEBUG, "WNM: Key Data", ptr, key_len_total);
     194
     195        if (key_len_total && !wpa_sm_pmf_enabled(wpa_s->wpa)) {
     196                wpa_msg(wpa_s, MSG_INFO,
     197                        "WNM: Ignore Key Data in WNM-Sleep Mode Response - PMF not enabled");
     198                return;
     199        }
    192200
    193201        while (ptr + 1 < end) {
     
    251259        size_t left;
    252260
     261        if (!wpa_s->wnmsleep_used) {
     262                wpa_printf(MSG_DEBUG,
     263                           "WNM: Ignore WNM-Sleep Mode Response frame since WNM-Sleep Mode operation has not been requested");
     264                return;
     265        }
     266
    253267        if (len < 3)
    254268                return;
     
    285299                return;
    286300        }
     301
     302        wpa_s->wnmsleep_used = 0;
    287303
    288304        if (wnmsleep_ie->status == WNM_STATUS_SLEEP_ACCEPT ||
  • freebsd/contrib/wpa/wpa_supplicant/wpa_supplicant_i.h

    rbdc4f21 rbc4bb2e  
    659659        unsigned int mac_addr_changed:1;
    660660        unsigned int added_vif:1;
     661        unsigned int wnmsleep_used:1;
    661662
    662663        struct os_reltime last_mac_addr_change;
Note: See TracChangeset for help on using the changeset viewer.