LCOV - code coverage report
Current view: top level - src/ap - wpa_auth_ie.c (source / functions) Hit Total Coverage
Test: hostapd hwsim test run 1388338050 Lines: 322 410 78.5 %
Date: 2013-12-29 Functions: 9 9 100.0 %
Branches: 178 250 71.2 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * hostapd - WPA/RSN IE and KDE definitions
       3                 :            :  * Copyright (c) 2004-2008, 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 "common/ieee802_11_defs.h"
      13                 :            : #include "eapol_auth/eapol_auth_sm.h"
      14                 :            : #include "ap_config.h"
      15                 :            : #include "ieee802_11.h"
      16                 :            : #include "wpa_auth.h"
      17                 :            : #include "pmksa_cache_auth.h"
      18                 :            : #include "wpa_auth_ie.h"
      19                 :            : #include "wpa_auth_i.h"
      20                 :            : 
      21                 :            : 
      22                 :            : #ifdef CONFIG_RSN_TESTING
      23                 :            : int rsn_testing = 0;
      24                 :            : #endif /* CONFIG_RSN_TESTING */
      25                 :            : 
      26                 :            : 
      27                 :         15 : static int wpa_write_wpa_ie(struct wpa_auth_config *conf, u8 *buf, size_t len)
      28                 :            : {
      29                 :            :         struct wpa_ie_hdr *hdr;
      30                 :            :         int num_suites;
      31                 :            :         u8 *pos, *count;
      32                 :            :         u32 suite;
      33                 :            : 
      34                 :         15 :         hdr = (struct wpa_ie_hdr *) buf;
      35                 :         15 :         hdr->elem_id = WLAN_EID_VENDOR_SPECIFIC;
      36                 :         15 :         RSN_SELECTOR_PUT(hdr->oui, WPA_OUI_TYPE);
      37                 :         15 :         WPA_PUT_LE16(hdr->version, WPA_VERSION);
      38                 :         15 :         pos = (u8 *) (hdr + 1);
      39                 :            : 
      40                 :         15 :         suite = wpa_cipher_to_suite(WPA_PROTO_WPA, conf->wpa_group);
      41         [ -  + ]:         15 :         if (suite == 0) {
      42                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid group cipher (%d).",
      43                 :            :                            conf->wpa_group);
      44                 :          0 :                 return -1;
      45                 :            :         }
      46                 :         15 :         RSN_SELECTOR_PUT(pos, suite);
      47                 :         15 :         pos += WPA_SELECTOR_LEN;
      48                 :            : 
      49                 :         15 :         count = pos;
      50                 :         15 :         pos += 2;
      51                 :            : 
      52                 :         15 :         num_suites = wpa_cipher_put_suites(pos, conf->wpa_pairwise);
      53         [ -  + ]:         15 :         if (num_suites == 0) {
      54                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid pairwise cipher (%d).",
      55                 :            :                            conf->wpa_pairwise);
      56                 :          0 :                 return -1;
      57                 :            :         }
      58                 :         15 :         pos += num_suites * WPA_SELECTOR_LEN;
      59                 :         15 :         WPA_PUT_LE16(count, num_suites);
      60                 :            : 
      61                 :         15 :         num_suites = 0;
      62                 :         15 :         count = pos;
      63                 :         15 :         pos += 2;
      64                 :            : 
      65         [ +  + ]:         15 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
      66                 :          1 :                 RSN_SELECTOR_PUT(pos, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X);
      67                 :          1 :                 pos += WPA_SELECTOR_LEN;
      68                 :          1 :                 num_suites++;
      69                 :            :         }
      70         [ +  + ]:         15 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
      71                 :         14 :                 RSN_SELECTOR_PUT(pos, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X);
      72                 :         14 :                 pos += WPA_SELECTOR_LEN;
      73                 :         14 :                 num_suites++;
      74                 :            :         }
      75                 :            : 
      76         [ -  + ]:         15 :         if (num_suites == 0) {
      77                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid key management type (%d).",
      78                 :            :                            conf->wpa_key_mgmt);
      79                 :          0 :                 return -1;
      80                 :            :         }
      81                 :         15 :         WPA_PUT_LE16(count, num_suites);
      82                 :            : 
      83                 :            :         /* WPA Capabilities; use defaults, so no need to include it */
      84                 :            : 
      85                 :         15 :         hdr->len = (pos - buf) - 2;
      86                 :            : 
      87                 :         15 :         return pos - buf;
      88                 :            : }
      89                 :            : 
      90                 :            : 
      91                 :        187 : int wpa_write_rsn_ie(struct wpa_auth_config *conf, u8 *buf, size_t len,
      92                 :            :                      const u8 *pmkid)
      93                 :            : {
      94                 :            :         struct rsn_ie_hdr *hdr;
      95                 :            :         int num_suites, res;
      96                 :            :         u8 *pos, *count;
      97                 :            :         u16 capab;
      98                 :            :         u32 suite;
      99                 :            : 
     100                 :        187 :         hdr = (struct rsn_ie_hdr *) buf;
     101                 :        187 :         hdr->elem_id = WLAN_EID_RSN;
     102                 :        187 :         WPA_PUT_LE16(hdr->version, RSN_VERSION);
     103                 :        187 :         pos = (u8 *) (hdr + 1);
     104                 :            : 
     105                 :        187 :         suite = wpa_cipher_to_suite(WPA_PROTO_RSN, conf->wpa_group);
     106         [ -  + ]:        187 :         if (suite == 0) {
     107                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid group cipher (%d).",
     108                 :            :                            conf->wpa_group);
     109                 :          0 :                 return -1;
     110                 :            :         }
     111                 :        187 :         RSN_SELECTOR_PUT(pos, suite);
     112                 :        187 :         pos += RSN_SELECTOR_LEN;
     113                 :            : 
     114                 :        187 :         num_suites = 0;
     115                 :        187 :         count = pos;
     116                 :        187 :         pos += 2;
     117                 :            : 
     118                 :            : #ifdef CONFIG_RSN_TESTING
     119                 :            :         if (rsn_testing) {
     120                 :            :                 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 1));
     121                 :            :                 pos += RSN_SELECTOR_LEN;
     122                 :            :                 num_suites++;
     123                 :            :         }
     124                 :            : #endif /* CONFIG_RSN_TESTING */
     125                 :            : 
     126                 :        187 :         res = rsn_cipher_put_suites(pos, conf->rsn_pairwise);
     127                 :        187 :         num_suites += res;
     128                 :        187 :         pos += res * RSN_SELECTOR_LEN;
     129                 :            : 
     130                 :            : #ifdef CONFIG_RSN_TESTING
     131                 :            :         if (rsn_testing) {
     132                 :            :                 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 2));
     133                 :            :                 pos += RSN_SELECTOR_LEN;
     134                 :            :                 num_suites++;
     135                 :            :         }
     136                 :            : #endif /* CONFIG_RSN_TESTING */
     137                 :            : 
     138         [ -  + ]:        187 :         if (num_suites == 0) {
     139                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid pairwise cipher (%d).",
     140                 :            :                            conf->rsn_pairwise);
     141                 :          0 :                 return -1;
     142                 :            :         }
     143                 :        187 :         WPA_PUT_LE16(count, num_suites);
     144                 :            : 
     145                 :        187 :         num_suites = 0;
     146                 :        187 :         count = pos;
     147                 :        187 :         pos += 2;
     148                 :            : 
     149                 :            : #ifdef CONFIG_RSN_TESTING
     150                 :            :         if (rsn_testing) {
     151                 :            :                 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 1));
     152                 :            :                 pos += RSN_SELECTOR_LEN;
     153                 :            :                 num_suites++;
     154                 :            :         }
     155                 :            : #endif /* CONFIG_RSN_TESTING */
     156                 :            : 
     157         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
     158                 :         69 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X);
     159                 :         69 :                 pos += RSN_SELECTOR_LEN;
     160                 :         69 :                 num_suites++;
     161                 :            :         }
     162         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
     163                 :         68 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X);
     164                 :         68 :                 pos += RSN_SELECTOR_LEN;
     165                 :         68 :                 num_suites++;
     166                 :            :         }
     167                 :            : #ifdef CONFIG_IEEE80211R
     168         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
     169                 :          6 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_802_1X);
     170                 :          6 :                 pos += RSN_SELECTOR_LEN;
     171                 :          6 :                 num_suites++;
     172                 :            :         }
     173         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) {
     174                 :         30 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_PSK);
     175                 :         30 :                 pos += RSN_SELECTOR_LEN;
     176                 :         30 :                 num_suites++;
     177                 :            :         }
     178                 :            : #endif /* CONFIG_IEEE80211R */
     179                 :            : #ifdef CONFIG_IEEE80211W
     180         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
     181                 :          1 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_802_1X_SHA256);
     182                 :          1 :                 pos += RSN_SELECTOR_LEN;
     183                 :          1 :                 num_suites++;
     184                 :            :         }
     185         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
     186                 :          4 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_PSK_SHA256);
     187                 :          4 :                 pos += RSN_SELECTOR_LEN;
     188                 :          4 :                 num_suites++;
     189                 :            :         }
     190                 :            : #endif /* CONFIG_IEEE80211W */
     191                 :            : #ifdef CONFIG_SAE
     192         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) {
     193                 :          4 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_SAE);
     194                 :          4 :                 pos += RSN_SELECTOR_LEN;
     195                 :          4 :                 num_suites++;
     196                 :            :         }
     197         [ +  + ]:        187 :         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE) {
     198                 :         12 :                 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_SAE);
     199                 :         12 :                 pos += RSN_SELECTOR_LEN;
     200                 :         12 :                 num_suites++;
     201                 :            :         }
     202                 :            : #endif /* CONFIG_SAE */
     203                 :            : 
     204                 :            : #ifdef CONFIG_RSN_TESTING
     205                 :            :         if (rsn_testing) {
     206                 :            :                 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 2));
     207                 :            :                 pos += RSN_SELECTOR_LEN;
     208                 :            :                 num_suites++;
     209                 :            :         }
     210                 :            : #endif /* CONFIG_RSN_TESTING */
     211                 :            : 
     212         [ -  + ]:        187 :         if (num_suites == 0) {
     213                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid key management type (%d).",
     214                 :            :                            conf->wpa_key_mgmt);
     215                 :          0 :                 return -1;
     216                 :            :         }
     217                 :        187 :         WPA_PUT_LE16(count, num_suites);
     218                 :            : 
     219                 :            :         /* RSN Capabilities */
     220                 :        187 :         capab = 0;
     221         [ -  + ]:        187 :         if (conf->rsn_preauth)
     222                 :          0 :                 capab |= WPA_CAPABILITY_PREAUTH;
     223         [ +  + ]:        187 :         if (conf->peerkey)
     224                 :          1 :                 capab |= WPA_CAPABILITY_PEERKEY_ENABLED;
     225         [ +  - ]:        187 :         if (conf->wmm_enabled) {
     226                 :            :                 /* 4 PTKSA replay counters when using WMM */
     227                 :        187 :                 capab |= (RSN_NUM_REPLAY_COUNTERS_16 << 2);
     228                 :            :         }
     229                 :            : #ifdef CONFIG_IEEE80211W
     230         [ +  + ]:        187 :         if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
     231                 :         59 :                 capab |= WPA_CAPABILITY_MFPC;
     232         [ +  + ]:         59 :                 if (conf->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED)
     233                 :         16 :                         capab |= WPA_CAPABILITY_MFPR;
     234                 :            :         }
     235                 :            : #endif /* CONFIG_IEEE80211W */
     236                 :            : #ifdef CONFIG_RSN_TESTING
     237                 :            :         if (rsn_testing)
     238                 :            :                 capab |= BIT(8) | BIT(14) | BIT(15);
     239                 :            : #endif /* CONFIG_RSN_TESTING */
     240                 :        187 :         WPA_PUT_LE16(pos, capab);
     241                 :        187 :         pos += 2;
     242                 :            : 
     243         [ +  + ]:        187 :         if (pmkid) {
     244         [ -  + ]:         32 :                 if (pos + 2 + PMKID_LEN > buf + len)
     245                 :          0 :                         return -1;
     246                 :            :                 /* PMKID Count */
     247                 :         32 :                 WPA_PUT_LE16(pos, 1);
     248                 :         32 :                 pos += 2;
     249                 :         32 :                 os_memcpy(pos, pmkid, PMKID_LEN);
     250                 :         32 :                 pos += PMKID_LEN;
     251                 :            :         }
     252                 :            : 
     253                 :            : #ifdef CONFIG_IEEE80211W
     254         [ +  + ]:        187 :         if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
     255         [ -  + ]:         59 :                 if (pos + 2 + 4 > buf + len)
     256                 :          0 :                         return -1;
     257         [ +  + ]:         59 :                 if (pmkid == NULL) {
     258                 :            :                         /* PMKID Count */
     259                 :         51 :                         WPA_PUT_LE16(pos, 0);
     260                 :         51 :                         pos += 2;
     261                 :            :                 }
     262                 :            : 
     263                 :            :                 /* Management Group Cipher Suite */
     264                 :         59 :                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_AES_128_CMAC);
     265                 :         59 :                 pos += RSN_SELECTOR_LEN;
     266                 :            :         }
     267                 :            : #endif /* CONFIG_IEEE80211W */
     268                 :            : 
     269                 :            : #ifdef CONFIG_RSN_TESTING
     270                 :            :         if (rsn_testing) {
     271                 :            :                 /*
     272                 :            :                  * Fill in any defined fields and add extra data to the end of
     273                 :            :                  * the element.
     274                 :            :                  */
     275                 :            :                 int pmkid_count_set = pmkid != NULL;
     276                 :            :                 if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION)
     277                 :            :                         pmkid_count_set = 1;
     278                 :            :                 /* PMKID Count */
     279                 :            :                 WPA_PUT_LE16(pos, 0);
     280                 :            :                 pos += 2;
     281                 :            :                 if (conf->ieee80211w == NO_MGMT_FRAME_PROTECTION) {
     282                 :            :                         /* Management Group Cipher Suite */
     283                 :            :                         RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_AES_128_CMAC);
     284                 :            :                         pos += RSN_SELECTOR_LEN;
     285                 :            :                 }
     286                 :            : 
     287                 :            :                 os_memset(pos, 0x12, 17);
     288                 :            :                 pos += 17;
     289                 :            :         }
     290                 :            : #endif /* CONFIG_RSN_TESTING */
     291                 :            : 
     292                 :        187 :         hdr->len = (pos - buf) - 2;
     293                 :            : 
     294                 :        187 :         return pos - buf;
     295                 :            : }
     296                 :            : 
     297                 :            : 
     298                 :        158 : int wpa_auth_gen_wpa_ie(struct wpa_authenticator *wpa_auth)
     299                 :            : {
     300                 :            :         u8 *pos, buf[128];
     301                 :            :         int res;
     302                 :            : 
     303                 :        158 :         pos = buf;
     304                 :            : 
     305         [ +  + ]:        158 :         if (wpa_auth->conf.wpa & WPA_PROTO_RSN) {
     306                 :        155 :                 res = wpa_write_rsn_ie(&wpa_auth->conf,
     307                 :        155 :                                        pos, buf + sizeof(buf) - pos, NULL);
     308         [ -  + ]:        155 :                 if (res < 0)
     309                 :          0 :                         return res;
     310                 :        155 :                 pos += res;
     311                 :            :         }
     312                 :            : #ifdef CONFIG_IEEE80211R
     313         [ +  + ]:        158 :         if (wpa_key_mgmt_ft(wpa_auth->conf.wpa_key_mgmt)) {
     314                 :         16 :                 res = wpa_write_mdie(&wpa_auth->conf, pos,
     315                 :         16 :                                      buf + sizeof(buf) - pos);
     316         [ -  + ]:         16 :                 if (res < 0)
     317                 :          0 :                         return res;
     318                 :         16 :                 pos += res;
     319                 :            :         }
     320                 :            : #endif /* CONFIG_IEEE80211R */
     321         [ +  + ]:        158 :         if (wpa_auth->conf.wpa & WPA_PROTO_WPA) {
     322                 :         15 :                 res = wpa_write_wpa_ie(&wpa_auth->conf,
     323                 :         15 :                                        pos, buf + sizeof(buf) - pos);
     324         [ -  + ]:         15 :                 if (res < 0)
     325                 :          0 :                         return res;
     326                 :         15 :                 pos += res;
     327                 :            :         }
     328                 :            : 
     329                 :        158 :         os_free(wpa_auth->wpa_ie);
     330                 :        158 :         wpa_auth->wpa_ie = os_malloc(pos - buf);
     331         [ -  + ]:        158 :         if (wpa_auth->wpa_ie == NULL)
     332                 :          0 :                 return -1;
     333                 :        158 :         os_memcpy(wpa_auth->wpa_ie, buf, pos - buf);
     334                 :        158 :         wpa_auth->wpa_ie_len = pos - buf;
     335                 :            : 
     336                 :        158 :         return 0;
     337                 :            : }
     338                 :            : 
     339                 :            : 
     340                 :        202 : u8 * wpa_add_kde(u8 *pos, u32 kde, const u8 *data, size_t data_len,
     341                 :            :                  const u8 *data2, size_t data2_len)
     342                 :            : {
     343                 :        202 :         *pos++ = WLAN_EID_VENDOR_SPECIFIC;
     344                 :        202 :         *pos++ = RSN_SELECTOR_LEN + data_len + data2_len;
     345                 :        202 :         RSN_SELECTOR_PUT(pos, kde);
     346                 :        202 :         pos += RSN_SELECTOR_LEN;
     347                 :        202 :         os_memcpy(pos, data, data_len);
     348                 :        202 :         pos += data_len;
     349         [ +  + ]:        202 :         if (data2) {
     350                 :        183 :                 os_memcpy(pos, data2, data2_len);
     351                 :        183 :                 pos += data2_len;
     352                 :            :         }
     353                 :        202 :         return pos;
     354                 :            : }
     355                 :            : 
     356                 :            : 
     357                 :            : struct wpa_auth_okc_iter_data {
     358                 :            :         struct rsn_pmksa_cache_entry *pmksa;
     359                 :            :         const u8 *aa;
     360                 :            :         const u8 *spa;
     361                 :            :         const u8 *pmkid;
     362                 :            : };
     363                 :            : 
     364                 :            : 
     365                 :          1 : static int wpa_auth_okc_iter(struct wpa_authenticator *a, void *ctx)
     366                 :            : {
     367                 :          1 :         struct wpa_auth_okc_iter_data *data = ctx;
     368                 :          1 :         data->pmksa = pmksa_cache_get_okc(a->pmksa, data->aa, data->spa,
     369                 :            :                                           data->pmkid);
     370         [ +  - ]:          1 :         if (data->pmksa)
     371                 :          1 :                 return 1;
     372                 :          1 :         return 0;
     373                 :            : }
     374                 :            : 
     375                 :            : 
     376                 :        185 : int wpa_validate_wpa_ie(struct wpa_authenticator *wpa_auth,
     377                 :            :                         struct wpa_state_machine *sm,
     378                 :            :                         const u8 *wpa_ie, size_t wpa_ie_len,
     379                 :            :                         const u8 *mdie, size_t mdie_len)
     380                 :            : {
     381                 :            :         struct wpa_ie_data data;
     382                 :            :         int ciphers, key_mgmt, res, version;
     383                 :            :         u32 selector;
     384                 :            :         size_t i;
     385                 :        185 :         const u8 *pmkid = NULL;
     386                 :            : 
     387 [ +  - ][ -  + ]:        185 :         if (wpa_auth == NULL || sm == NULL)
     388                 :          0 :                 return WPA_NOT_ENABLED;
     389                 :            : 
     390 [ +  - ][ -  + ]:        185 :         if (wpa_ie == NULL || wpa_ie_len < 1)
     391                 :          0 :                 return WPA_INVALID_IE;
     392                 :            : 
     393         [ +  + ]:        185 :         if (wpa_ie[0] == WLAN_EID_RSN)
     394                 :        179 :                 version = WPA_PROTO_RSN;
     395                 :            :         else
     396                 :          6 :                 version = WPA_PROTO_WPA;
     397                 :            : 
     398         [ -  + ]:        185 :         if (!(wpa_auth->conf.wpa & version)) {
     399                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid WPA proto (%d) from " MACSTR,
     400                 :          0 :                            version, MAC2STR(sm->addr));
     401                 :          0 :                 return WPA_INVALID_PROTO;
     402                 :            :         }
     403                 :            : 
     404         [ +  + ]:        185 :         if (version == WPA_PROTO_RSN) {
     405                 :        179 :                 res = wpa_parse_wpa_ie_rsn(wpa_ie, wpa_ie_len, &data);
     406                 :            : 
     407                 :        179 :                 selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
     408                 :            :                 if (0) {
     409                 :            :                 }
     410                 :            : #ifdef CONFIG_IEEE80211R
     411         [ +  + ]:        179 :                 else if (data.key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
     412                 :          3 :                         selector = RSN_AUTH_KEY_MGMT_FT_802_1X;
     413         [ +  + ]:        176 :                 else if (data.key_mgmt & WPA_KEY_MGMT_FT_PSK)
     414                 :         15 :                         selector = RSN_AUTH_KEY_MGMT_FT_PSK;
     415                 :            : #endif /* CONFIG_IEEE80211R */
     416                 :            : #ifdef CONFIG_IEEE80211W
     417         [ +  + ]:        161 :                 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
     418                 :          1 :                         selector = RSN_AUTH_KEY_MGMT_802_1X_SHA256;
     419         [ +  + ]:        160 :                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
     420                 :          6 :                         selector = RSN_AUTH_KEY_MGMT_PSK_SHA256;
     421                 :            : #endif /* CONFIG_IEEE80211W */
     422                 :            : #ifdef CONFIG_SAE
     423         [ +  + ]:        154 :                 else if (data.key_mgmt & WPA_KEY_MGMT_SAE)
     424                 :         14 :                         selector = RSN_AUTH_KEY_MGMT_SAE;
     425         [ +  + ]:        140 :                 else if (data.key_mgmt & WPA_KEY_MGMT_FT_SAE)
     426                 :          6 :                         selector = RSN_AUTH_KEY_MGMT_FT_SAE;
     427                 :            : #endif /* CONFIG_SAE */
     428         [ +  + ]:        134 :                 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
     429                 :         65 :                         selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
     430         [ +  - ]:         69 :                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
     431                 :         69 :                         selector = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
     432                 :        179 :                 wpa_auth->dot11RSNAAuthenticationSuiteSelected = selector;
     433                 :            : 
     434                 :        179 :                 selector = wpa_cipher_to_suite(WPA_PROTO_RSN,
     435                 :            :                                                data.pairwise_cipher);
     436         [ -  + ]:        179 :                 if (!selector)
     437                 :          0 :                         selector = RSN_CIPHER_SUITE_CCMP;
     438                 :        179 :                 wpa_auth->dot11RSNAPairwiseCipherSelected = selector;
     439                 :            : 
     440                 :        179 :                 selector = wpa_cipher_to_suite(WPA_PROTO_RSN,
     441                 :            :                                                data.group_cipher);
     442         [ -  + ]:        179 :                 if (!selector)
     443                 :          0 :                         selector = RSN_CIPHER_SUITE_CCMP;
     444                 :        179 :                 wpa_auth->dot11RSNAGroupCipherSelected = selector;
     445                 :            :         } else {
     446                 :          6 :                 res = wpa_parse_wpa_ie_wpa(wpa_ie, wpa_ie_len, &data);
     447                 :            : 
     448                 :          6 :                 selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
     449         [ +  + ]:          6 :                 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
     450                 :          1 :                         selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
     451         [ +  - ]:          5 :                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
     452                 :          5 :                         selector = WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X;
     453                 :          6 :                 wpa_auth->dot11RSNAAuthenticationSuiteSelected = selector;
     454                 :            : 
     455                 :          6 :                 selector = wpa_cipher_to_suite(WPA_PROTO_WPA,
     456                 :            :                                                data.pairwise_cipher);
     457         [ -  + ]:          6 :                 if (!selector)
     458                 :          0 :                         selector = RSN_CIPHER_SUITE_TKIP;
     459                 :          6 :                 wpa_auth->dot11RSNAPairwiseCipherSelected = selector;
     460                 :            : 
     461                 :          6 :                 selector = wpa_cipher_to_suite(WPA_PROTO_WPA,
     462                 :            :                                                data.group_cipher);
     463         [ -  + ]:          6 :                 if (!selector)
     464                 :          0 :                         selector = WPA_CIPHER_SUITE_TKIP;
     465                 :          6 :                 wpa_auth->dot11RSNAGroupCipherSelected = selector;
     466                 :            :         }
     467         [ -  + ]:        185 :         if (res) {
     468                 :          0 :                 wpa_printf(MSG_DEBUG, "Failed to parse WPA/RSN IE from "
     469                 :          0 :                            MACSTR " (res=%d)", MAC2STR(sm->addr), res);
     470                 :          0 :                 wpa_hexdump(MSG_DEBUG, "WPA/RSN IE", wpa_ie, wpa_ie_len);
     471                 :          0 :                 return WPA_INVALID_IE;
     472                 :            :         }
     473                 :            : 
     474         [ -  + ]:        185 :         if (data.group_cipher != wpa_auth->conf.wpa_group) {
     475                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid WPA group cipher (0x%x) from "
     476                 :          0 :                            MACSTR, data.group_cipher, MAC2STR(sm->addr));
     477                 :          0 :                 return WPA_INVALID_GROUP;
     478                 :            :         }
     479                 :            : 
     480                 :        185 :         key_mgmt = data.key_mgmt & wpa_auth->conf.wpa_key_mgmt;
     481         [ -  + ]:        185 :         if (!key_mgmt) {
     482                 :          0 :                 wpa_printf(MSG_DEBUG, "Invalid WPA key mgmt (0x%x) from "
     483                 :          0 :                            MACSTR, data.key_mgmt, MAC2STR(sm->addr));
     484                 :          0 :                 return WPA_INVALID_AKMP;
     485                 :            :         }
     486                 :            :         if (0) {
     487                 :            :         }
     488                 :            : #ifdef CONFIG_IEEE80211R
     489         [ +  + ]:        185 :         else if (key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
     490                 :          3 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
     491         [ +  + ]:        182 :         else if (key_mgmt & WPA_KEY_MGMT_FT_PSK)
     492                 :         15 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_PSK;
     493                 :            : #endif /* CONFIG_IEEE80211R */
     494                 :            : #ifdef CONFIG_IEEE80211W
     495         [ +  + ]:        167 :         else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
     496                 :          1 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
     497         [ +  + ]:        166 :         else if (key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
     498                 :          6 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
     499                 :            : #endif /* CONFIG_IEEE80211W */
     500                 :            : #ifdef CONFIG_SAE
     501         [ +  + ]:        160 :         else if (key_mgmt & WPA_KEY_MGMT_SAE)
     502                 :         14 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_SAE;
     503         [ +  + ]:        146 :         else if (key_mgmt & WPA_KEY_MGMT_FT_SAE)
     504                 :          6 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_SAE;
     505                 :            : #endif /* CONFIG_SAE */
     506         [ +  + ]:        140 :         else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X)
     507                 :         66 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X;
     508                 :            :         else
     509                 :         74 :                 sm->wpa_key_mgmt = WPA_KEY_MGMT_PSK;
     510                 :            : 
     511         [ +  + ]:        185 :         if (version == WPA_PROTO_RSN)
     512                 :        179 :                 ciphers = data.pairwise_cipher & wpa_auth->conf.rsn_pairwise;
     513                 :            :         else
     514                 :          6 :                 ciphers = data.pairwise_cipher & wpa_auth->conf.wpa_pairwise;
     515         [ -  + ]:        185 :         if (!ciphers) {
     516         [ #  # ]:          0 :                 wpa_printf(MSG_DEBUG, "Invalid %s pairwise cipher (0x%x) "
     517                 :            :                            "from " MACSTR,
     518                 :            :                            version == WPA_PROTO_RSN ? "RSN" : "WPA",
     519                 :          0 :                            data.pairwise_cipher, MAC2STR(sm->addr));
     520                 :          0 :                 return WPA_INVALID_PAIRWISE;
     521                 :            :         }
     522                 :            : 
     523                 :            : #ifdef CONFIG_IEEE80211W
     524         [ +  + ]:        185 :         if (wpa_auth->conf.ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
     525         [ -  + ]:         11 :                 if (!(data.capabilities & WPA_CAPABILITY_MFPC)) {
     526                 :          0 :                         wpa_printf(MSG_DEBUG, "Management frame protection "
     527                 :            :                                    "required, but client did not enable it");
     528                 :          0 :                         return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
     529                 :            :                 }
     530                 :            : 
     531         [ -  + ]:         11 :                 if (ciphers & WPA_CIPHER_TKIP) {
     532                 :          0 :                         wpa_printf(MSG_DEBUG, "Management frame protection "
     533                 :            :                                    "cannot use TKIP");
     534                 :          0 :                         return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
     535                 :            :                 }
     536                 :            : 
     537         [ -  + ]:         11 :                 if (data.mgmt_group_cipher != WPA_CIPHER_AES_128_CMAC) {
     538                 :          0 :                         wpa_printf(MSG_DEBUG, "Unsupported management group "
     539                 :            :                                    "cipher %d", data.mgmt_group_cipher);
     540                 :          0 :                         return WPA_INVALID_MGMT_GROUP_CIPHER;
     541                 :            :                 }
     542                 :            :         }
     543                 :            : 
     544 [ +  + ][ +  + ]:        185 :         if (wpa_auth->conf.ieee80211w == NO_MGMT_FRAME_PROTECTION ||
     545                 :         44 :             !(data.capabilities & WPA_CAPABILITY_MFPC))
     546                 :        170 :                 sm->mgmt_frame_prot = 0;
     547                 :            :         else
     548                 :         15 :                 sm->mgmt_frame_prot = 1;
     549                 :            : #endif /* CONFIG_IEEE80211W */
     550                 :            : 
     551                 :            : #ifdef CONFIG_IEEE80211R
     552         [ +  + ]:        185 :         if (wpa_key_mgmt_ft(sm->wpa_key_mgmt)) {
     553 [ +  - ][ -  + ]:         24 :                 if (mdie == NULL || mdie_len < MOBILITY_DOMAIN_ID_LEN + 1) {
     554                 :          0 :                         wpa_printf(MSG_DEBUG, "RSN: Trying to use FT, but "
     555                 :            :                                    "MDIE not included");
     556                 :          0 :                         return WPA_INVALID_MDIE;
     557                 :            :                 }
     558         [ -  + ]:         24 :                 if (os_memcmp(mdie, wpa_auth->conf.mobility_domain,
     559                 :            :                               MOBILITY_DOMAIN_ID_LEN) != 0) {
     560                 :          0 :                         wpa_hexdump(MSG_DEBUG, "RSN: Attempted to use unknown "
     561                 :            :                                     "MDIE", mdie, MOBILITY_DOMAIN_ID_LEN);
     562                 :          0 :                         return WPA_INVALID_MDIE;
     563                 :            :                 }
     564                 :            :         }
     565                 :            : #endif /* CONFIG_IEEE80211R */
     566                 :            : 
     567                 :        185 :         sm->pairwise = wpa_pick_pairwise_cipher(ciphers, 0);
     568         [ -  + ]:        185 :         if (sm->pairwise < 0)
     569                 :          0 :                 return WPA_INVALID_PAIRWISE;
     570                 :            : 
     571                 :            :         /* TODO: clear WPA/WPA2 state if STA changes from one to another */
     572         [ +  + ]:        185 :         if (wpa_ie[0] == WLAN_EID_RSN)
     573                 :        179 :                 sm->wpa = WPA_VERSION_WPA2;
     574                 :            :         else
     575                 :          6 :                 sm->wpa = WPA_VERSION_WPA;
     576                 :            : 
     577                 :        185 :         sm->pmksa = NULL;
     578         [ +  + ]:        203 :         for (i = 0; i < data.num_pmkid; i++) {
     579                 :         22 :                 wpa_hexdump(MSG_DEBUG, "RSN IE: STA PMKID",
     580                 :         22 :                             &data.pmkid[i * PMKID_LEN], PMKID_LEN);
     581                 :         22 :                 sm->pmksa = pmksa_cache_auth_get(wpa_auth->pmksa, sm->addr,
     582                 :         22 :                                                  &data.pmkid[i * PMKID_LEN]);
     583         [ +  + ]:         22 :                 if (sm->pmksa) {
     584                 :          4 :                         pmkid = sm->pmksa->pmkid;
     585                 :          4 :                         break;
     586                 :            :                 }
     587                 :            :         }
     588 [ +  + ][ +  + ]:        185 :         for (i = 0; sm->pmksa == NULL && wpa_auth->conf.okc &&
                 [ +  + ]
     589                 :          0 :                      i < data.num_pmkid; i++) {
     590                 :            :                 struct wpa_auth_okc_iter_data idata;
     591                 :          1 :                 idata.pmksa = NULL;
     592                 :          1 :                 idata.aa = wpa_auth->addr;
     593                 :          1 :                 idata.spa = sm->addr;
     594                 :          1 :                 idata.pmkid = &data.pmkid[i * PMKID_LEN];
     595                 :          1 :                 wpa_auth_for_each_auth(wpa_auth, wpa_auth_okc_iter, &idata);
     596         [ +  - ]:          1 :                 if (idata.pmksa) {
     597                 :          1 :                         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
     598                 :            :                                          "OKC match for PMKID");
     599                 :          1 :                         sm->pmksa = pmksa_cache_add_okc(wpa_auth->pmksa,
     600                 :          1 :                                                         idata.pmksa,
     601                 :          1 :                                                         wpa_auth->addr,
     602                 :            :                                                         idata.pmkid);
     603                 :          1 :                         pmkid = idata.pmkid;
     604                 :          1 :                         break;
     605                 :            :                 }
     606                 :            :         }
     607         [ +  + ]:        185 :         if (sm->pmksa) {
     608                 :          5 :                 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
     609                 :            :                                  "PMKID found from PMKSA cache "
     610                 :            :                                  "eap_type=%d vlan_id=%d",
     611                 :          5 :                                  sm->pmksa->eap_type_authsrv,
     612                 :          5 :                                  sm->pmksa->vlan_id);
     613                 :          5 :                 os_memcpy(wpa_auth->dot11RSNAPMKIDUsed, pmkid, PMKID_LEN);
     614                 :            :         }
     615                 :            : 
     616 [ +  + ][ +  + ]:        185 :         if (sm->wpa_ie == NULL || sm->wpa_ie_len < wpa_ie_len) {
     617                 :        183 :                 os_free(sm->wpa_ie);
     618                 :        183 :                 sm->wpa_ie = os_malloc(wpa_ie_len);
     619         [ -  + ]:        183 :                 if (sm->wpa_ie == NULL)
     620                 :          0 :                         return WPA_ALLOC_FAIL;
     621                 :            :         }
     622                 :        185 :         os_memcpy(sm->wpa_ie, wpa_ie, wpa_ie_len);
     623                 :        185 :         sm->wpa_ie_len = wpa_ie_len;
     624                 :            : 
     625                 :        185 :         return WPA_IE_OK;
     626                 :            : }
     627                 :            : 
     628                 :            : 
     629                 :            : /**
     630                 :            :  * wpa_parse_generic - Parse EAPOL-Key Key Data Generic IEs
     631                 :            :  * @pos: Pointer to the IE header
     632                 :            :  * @end: Pointer to the end of the Key Data buffer
     633                 :            :  * @ie: Pointer to parsed IE data
     634                 :            :  * Returns: 0 on success, 1 if end mark is found, -1 on failure
     635                 :            :  */
     636                 :         10 : static int wpa_parse_generic(const u8 *pos, const u8 *end,
     637                 :            :                              struct wpa_eapol_ie_parse *ie)
     638                 :            : {
     639         [ -  + ]:         10 :         if (pos[1] == 0)
     640                 :          0 :                 return 1;
     641                 :            : 
     642   [ +  -  +  + ]:         20 :         if (pos[1] >= 6 &&
     643         [ +  - ]:         17 :             RSN_SELECTOR_GET(pos + 2) == WPA_OUI_TYPE &&
     644         [ +  - ]:          7 :             pos[2 + WPA_SELECTOR_LEN] == 1 &&
     645                 :          7 :             pos[2 + WPA_SELECTOR_LEN + 1] == 0) {
     646                 :          7 :                 ie->wpa_ie = pos;
     647                 :          7 :                 ie->wpa_ie_len = pos[1] + 2;
     648                 :          7 :                 return 0;
     649                 :            :         }
     650                 :            : 
     651 [ +  - ][ +  + ]:          3 :         if (pos + 1 + RSN_SELECTOR_LEN < end &&
     652         [ -  + ]:          1 :             pos[1] >= RSN_SELECTOR_LEN + PMKID_LEN &&
     653                 :          1 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_PMKID) {
     654                 :          0 :                 ie->pmkid = pos + 2 + RSN_SELECTOR_LEN;
     655                 :          0 :                 return 0;
     656                 :            :         }
     657                 :            : 
     658   [ +  -  -  + ]:          6 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     659                 :          3 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_GROUPKEY) {
     660                 :          0 :                 ie->gtk = pos + 2 + RSN_SELECTOR_LEN;
     661                 :          0 :                 ie->gtk_len = pos[1] - RSN_SELECTOR_LEN;
     662                 :          0 :                 return 0;
     663                 :            :         }
     664                 :            : 
     665   [ +  -  +  + ]:          6 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     666                 :          3 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_MAC_ADDR) {
     667                 :          2 :                 ie->mac_addr = pos + 2 + RSN_SELECTOR_LEN;
     668                 :          2 :                 ie->mac_addr_len = pos[1] - RSN_SELECTOR_LEN;
     669                 :          2 :                 return 0;
     670                 :            :         }
     671                 :            : 
     672                 :            : #ifdef CONFIG_PEERKEY
     673   [ +  -  -  + ]:          2 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     674                 :          1 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_SMK) {
     675                 :          0 :                 ie->smk = pos + 2 + RSN_SELECTOR_LEN;
     676                 :          0 :                 ie->smk_len = pos[1] - RSN_SELECTOR_LEN;
     677                 :          0 :                 return 0;
     678                 :            :         }
     679                 :            : 
     680   [ +  -  +  - ]:          2 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     681                 :          1 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_NONCE) {
     682                 :          1 :                 ie->nonce = pos + 2 + RSN_SELECTOR_LEN;
     683                 :          1 :                 ie->nonce_len = pos[1] - RSN_SELECTOR_LEN;
     684                 :          1 :                 return 0;
     685                 :            :         }
     686                 :            : 
     687   [ #  #  #  # ]:          0 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     688                 :          0 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_LIFETIME) {
     689                 :          0 :                 ie->lifetime = pos + 2 + RSN_SELECTOR_LEN;
     690                 :          0 :                 ie->lifetime_len = pos[1] - RSN_SELECTOR_LEN;
     691                 :          0 :                 return 0;
     692                 :            :         }
     693                 :            : 
     694   [ #  #  #  # ]:          0 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     695                 :          0 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_ERROR) {
     696                 :          0 :                 ie->error = pos + 2 + RSN_SELECTOR_LEN;
     697                 :          0 :                 ie->error_len = pos[1] - RSN_SELECTOR_LEN;
     698                 :          0 :                 return 0;
     699                 :            :         }
     700                 :            : #endif /* CONFIG_PEERKEY */
     701                 :            : 
     702                 :            : #ifdef CONFIG_IEEE80211W
     703   [ #  #  #  # ]:          0 :         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
     704                 :          0 :             RSN_SELECTOR_GET(pos + 2) == RSN_KEY_DATA_IGTK) {
     705                 :          0 :                 ie->igtk = pos + 2 + RSN_SELECTOR_LEN;
     706                 :          0 :                 ie->igtk_len = pos[1] - RSN_SELECTOR_LEN;
     707                 :          0 :                 return 0;
     708                 :            :         }
     709                 :            : #endif /* CONFIG_IEEE80211W */
     710                 :            : 
     711                 :         10 :         return 0;
     712                 :            : }
     713                 :            : 
     714                 :            : 
     715                 :            : /**
     716                 :            :  * wpa_parse_kde_ies - Parse EAPOL-Key Key Data IEs
     717                 :            :  * @buf: Pointer to the Key Data buffer
     718                 :            :  * @len: Key Data Length
     719                 :            :  * @ie: Pointer to parsed IE data
     720                 :            :  * Returns: 0 on success, -1 on failure
     721                 :            :  */
     722                 :        193 : int wpa_parse_kde_ies(const u8 *buf, size_t len, struct wpa_eapol_ie_parse *ie)
     723                 :            : {
     724                 :            :         const u8 *pos, *end;
     725                 :        193 :         int ret = 0;
     726                 :            : 
     727                 :        193 :         os_memset(ie, 0, sizeof(*ie));
     728         [ +  + ]:        405 :         for (pos = buf, end = pos + len; pos + 1 < end; pos += 2 + pos[1]) {
     729 [ +  + ][ +  - ]:        212 :                 if (pos[0] == 0xdd &&
     730         [ +  - ]:         10 :                     ((pos == buf + len - 1) || pos[1] == 0)) {
     731                 :            :                         /* Ignore padding */
     732                 :            :                         break;
     733                 :            :                 }
     734         [ -  + ]:        212 :                 if (pos + 2 + pos[1] > end) {
     735                 :          0 :                         wpa_printf(MSG_DEBUG, "WPA: EAPOL-Key Key Data "
     736                 :            :                                    "underflow (ie=%d len=%d pos=%d)",
     737                 :          0 :                                    pos[0], pos[1], (int) (pos - buf));
     738                 :          0 :                         wpa_hexdump_key(MSG_DEBUG, "WPA: Key Data",
     739                 :            :                                         buf, len);
     740                 :          0 :                         ret = -1;
     741                 :          0 :                         break;
     742                 :            :                 }
     743         [ +  + ]:        212 :                 if (*pos == WLAN_EID_RSN) {
     744                 :        186 :                         ie->rsn_ie = pos;
     745                 :        186 :                         ie->rsn_ie_len = pos[1] + 2;
     746                 :            : #ifdef CONFIG_IEEE80211R
     747         [ +  + ]:         26 :                 } else if (*pos == WLAN_EID_MOBILITY_DOMAIN) {
     748                 :          8 :                         ie->mdie = pos;
     749                 :          8 :                         ie->mdie_len = pos[1] + 2;
     750         [ +  + ]:         18 :                 } else if (*pos == WLAN_EID_FAST_BSS_TRANSITION) {
     751                 :          8 :                         ie->ftie = pos;
     752                 :          8 :                         ie->ftie_len = pos[1] + 2;
     753                 :            : #endif /* CONFIG_IEEE80211R */
     754         [ +  - ]:         10 :                 } else if (*pos == WLAN_EID_VENDOR_SPECIFIC) {
     755                 :         10 :                         ret = wpa_parse_generic(pos, end, ie);
     756         [ -  + ]:         10 :                         if (ret < 0)
     757                 :          0 :                                 break;
     758         [ -  + ]:         10 :                         if (ret > 0) {
     759                 :          0 :                                 ret = 0;
     760                 :          0 :                                 break;
     761                 :            :                         }
     762                 :            :                 } else {
     763                 :          0 :                         wpa_hexdump(MSG_DEBUG, "WPA: Unrecognized EAPOL-Key "
     764                 :          0 :                                     "Key Data IE", pos, 2 + pos[1]);
     765                 :            :                 }
     766                 :            :         }
     767                 :            : 
     768                 :        193 :         return ret;
     769                 :            : }
     770                 :            : 
     771                 :            : 
     772                 :        194 : int wpa_auth_uses_mfp(struct wpa_state_machine *sm)
     773                 :            : {
     774         [ +  + ]:        194 :         return sm ? sm->mgmt_frame_prot : 0;
     775                 :            : }

Generated by: LCOV version 1.9