LCOV - code coverage report
Current view: top level - src/wps - wps_attr_process.c (source / functions) Hit Total Coverage
Test: hostapd/hlr_auc_gw (AS) hwsim test run 1388338050 Lines: 0 156 0.0 %
Date: 2013-12-29 Functions: 0 17 0.0 %
Branches: 0 92 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Wi-Fi Protected Setup - attribute processing
       3                 :            :  * Copyright (c) 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 "includes.h"
      10                 :            : 
      11                 :            : #include "common.h"
      12                 :            : #include "crypto/sha256.h"
      13                 :            : #include "wps_i.h"
      14                 :            : 
      15                 :            : 
      16                 :          0 : int wps_process_authenticator(struct wps_data *wps, const u8 *authenticator,
      17                 :            :                               const struct wpabuf *msg)
      18                 :            : {
      19                 :            :         u8 hash[SHA256_MAC_LEN];
      20                 :            :         const u8 *addr[2];
      21                 :            :         size_t len[2];
      22                 :            : 
      23         [ #  # ]:          0 :         if (authenticator == NULL) {
      24                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: No Authenticator attribute "
      25                 :            :                            "included");
      26                 :          0 :                 return -1;
      27                 :            :         }
      28                 :            : 
      29         [ #  # ]:          0 :         if (wps->last_msg == NULL) {
      30                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Last message not available for "
      31                 :            :                            "validating authenticator");
      32                 :          0 :                 return -1;
      33                 :            :         }
      34                 :            : 
      35                 :            :         /* Authenticator = HMAC-SHA256_AuthKey(M_prev || M_curr*)
      36                 :            :          * (M_curr* is M_curr without the Authenticator attribute)
      37                 :            :          */
      38                 :          0 :         addr[0] = wpabuf_head(wps->last_msg);
      39                 :          0 :         len[0] = wpabuf_len(wps->last_msg);
      40                 :          0 :         addr[1] = wpabuf_head(msg);
      41                 :          0 :         len[1] = wpabuf_len(msg) - 4 - WPS_AUTHENTICATOR_LEN;
      42                 :          0 :         hmac_sha256_vector(wps->authkey, WPS_AUTHKEY_LEN, 2, addr, len, hash);
      43                 :            : 
      44         [ #  # ]:          0 :         if (os_memcmp(hash, authenticator, WPS_AUTHENTICATOR_LEN) != 0) {
      45                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Incorrect Authenticator");
      46                 :          0 :                 return -1;
      47                 :            :         }
      48                 :            : 
      49                 :          0 :         return 0;
      50                 :            : }
      51                 :            : 
      52                 :            : 
      53                 :          0 : int wps_process_key_wrap_auth(struct wps_data *wps, struct wpabuf *msg,
      54                 :            :                               const u8 *key_wrap_auth)
      55                 :            : {
      56                 :            :         u8 hash[SHA256_MAC_LEN];
      57                 :            :         const u8 *head;
      58                 :            :         size_t len;
      59                 :            : 
      60         [ #  # ]:          0 :         if (key_wrap_auth == NULL) {
      61                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: No KWA in decrypted attribute");
      62                 :          0 :                 return -1;
      63                 :            :         }
      64                 :            : 
      65                 :          0 :         head = wpabuf_head(msg);
      66                 :          0 :         len = wpabuf_len(msg) - 4 - WPS_KWA_LEN;
      67         [ #  # ]:          0 :         if (head + len != key_wrap_auth - 4) {
      68                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: KWA not in the end of the "
      69                 :            :                            "decrypted attribute");
      70                 :          0 :                 return -1;
      71                 :            :         }
      72                 :            : 
      73                 :          0 :         hmac_sha256(wps->authkey, WPS_AUTHKEY_LEN, head, len, hash);
      74         [ #  # ]:          0 :         if (os_memcmp(hash, key_wrap_auth, WPS_KWA_LEN) != 0) {
      75                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Invalid KWA");
      76                 :          0 :                 return -1;
      77                 :            :         }
      78                 :            : 
      79                 :          0 :         return 0;
      80                 :            : }
      81                 :            : 
      82                 :            : 
      83                 :          0 : static int wps_process_cred_network_idx(struct wps_credential *cred,
      84                 :            :                                         const u8 *idx)
      85                 :            : {
      86         [ #  # ]:          0 :         if (idx == NULL) {
      87                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Credential did not include "
      88                 :            :                            "Network Index");
      89                 :          0 :                 return -1;
      90                 :            :         }
      91                 :            : 
      92                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Network Index: %d", *idx);
      93                 :            : 
      94                 :          0 :         return 0;
      95                 :            : }
      96                 :            : 
      97                 :            : 
      98                 :          0 : static int wps_process_cred_ssid(struct wps_credential *cred, const u8 *ssid,
      99                 :            :                                  size_t ssid_len)
     100                 :            : {
     101         [ #  # ]:          0 :         if (ssid == NULL) {
     102                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Credential did not include SSID");
     103                 :          0 :                 return -1;
     104                 :            :         }
     105                 :            : 
     106                 :            :         /* Remove zero-padding since some Registrar implementations seem to use
     107                 :            :          * hardcoded 32-octet length for this attribute */
     108 [ #  # ][ #  # ]:          0 :         while (ssid_len > 0 && ssid[ssid_len - 1] == 0)
     109                 :          0 :                 ssid_len--;
     110                 :            : 
     111                 :          0 :         wpa_hexdump_ascii(MSG_DEBUG, "WPS: SSID", ssid, ssid_len);
     112         [ #  # ]:          0 :         if (ssid_len <= sizeof(cred->ssid)) {
     113                 :          0 :                 os_memcpy(cred->ssid, ssid, ssid_len);
     114                 :          0 :                 cred->ssid_len = ssid_len;
     115                 :            :         }
     116                 :            : 
     117                 :          0 :         return 0;
     118                 :            : }
     119                 :            : 
     120                 :            : 
     121                 :          0 : static int wps_process_cred_auth_type(struct wps_credential *cred,
     122                 :            :                                       const u8 *auth_type)
     123                 :            : {
     124         [ #  # ]:          0 :         if (auth_type == NULL) {
     125                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Credential did not include "
     126                 :            :                            "Authentication Type");
     127                 :          0 :                 return -1;
     128                 :            :         }
     129                 :            : 
     130                 :          0 :         cred->auth_type = WPA_GET_BE16(auth_type);
     131                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Authentication Type: 0x%x",
     132                 :          0 :                    cred->auth_type);
     133                 :            : 
     134                 :          0 :         return 0;
     135                 :            : }
     136                 :            : 
     137                 :            : 
     138                 :          0 : static int wps_process_cred_encr_type(struct wps_credential *cred,
     139                 :            :                                       const u8 *encr_type)
     140                 :            : {
     141         [ #  # ]:          0 :         if (encr_type == NULL) {
     142                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Credential did not include "
     143                 :            :                            "Encryption Type");
     144                 :          0 :                 return -1;
     145                 :            :         }
     146                 :            : 
     147                 :          0 :         cred->encr_type = WPA_GET_BE16(encr_type);
     148                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Encryption Type: 0x%x",
     149                 :          0 :                    cred->encr_type);
     150                 :            : 
     151                 :          0 :         return 0;
     152                 :            : }
     153                 :            : 
     154                 :            : 
     155                 :          0 : static int wps_process_cred_network_key_idx(struct wps_credential *cred,
     156                 :            :                                             const u8 *key_idx)
     157                 :            : {
     158         [ #  # ]:          0 :         if (key_idx == NULL)
     159                 :          0 :                 return 0; /* optional attribute */
     160                 :            : 
     161                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Network Key Index: %d", *key_idx);
     162                 :          0 :         cred->key_idx = *key_idx;
     163                 :            : 
     164                 :          0 :         return 0;
     165                 :            : }
     166                 :            : 
     167                 :            : 
     168                 :          0 : static int wps_process_cred_network_key(struct wps_credential *cred,
     169                 :            :                                         const u8 *key, size_t key_len)
     170                 :            : {
     171         [ #  # ]:          0 :         if (key == NULL) {
     172                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Credential did not include "
     173                 :            :                            "Network Key");
     174 [ #  # ][ #  # ]:          0 :                 if (cred->auth_type == WPS_AUTH_OPEN &&
     175                 :          0 :                     cred->encr_type == WPS_ENCR_NONE) {
     176                 :          0 :                         wpa_printf(MSG_DEBUG, "WPS: Workaround - Allow "
     177                 :            :                                    "missing mandatory Network Key attribute "
     178                 :            :                                    "for open network");
     179                 :          0 :                         return 0;
     180                 :            :                 }
     181                 :          0 :                 return -1;
     182                 :            :         }
     183                 :            : 
     184                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "WPS: Network Key", key, key_len);
     185         [ #  # ]:          0 :         if (key_len <= sizeof(cred->key)) {
     186                 :          0 :                 os_memcpy(cred->key, key, key_len);
     187                 :          0 :                 cred->key_len = key_len;
     188                 :            :         }
     189                 :            : 
     190                 :          0 :         return 0;
     191                 :            : }
     192                 :            : 
     193                 :            : 
     194                 :          0 : static int wps_process_cred_mac_addr(struct wps_credential *cred,
     195                 :            :                                      const u8 *mac_addr)
     196                 :            : {
     197         [ #  # ]:          0 :         if (mac_addr == NULL) {
     198                 :          0 :                 wpa_printf(MSG_DEBUG, "WPS: Credential did not include "
     199                 :            :                            "MAC Address");
     200                 :          0 :                 return -1;
     201                 :            :         }
     202                 :            : 
     203                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: MAC Address " MACSTR, MAC2STR(mac_addr));
     204                 :          0 :         os_memcpy(cred->mac_addr, mac_addr, ETH_ALEN);
     205                 :            : 
     206                 :          0 :         return 0;
     207                 :            : }
     208                 :            : 
     209                 :            : 
     210                 :          0 : static int wps_process_cred_eap_type(struct wps_credential *cred,
     211                 :            :                                      const u8 *eap_type, size_t eap_type_len)
     212                 :            : {
     213         [ #  # ]:          0 :         if (eap_type == NULL)
     214                 :          0 :                 return 0; /* optional attribute */
     215                 :            : 
     216                 :          0 :         wpa_hexdump(MSG_DEBUG, "WPS: EAP Type", eap_type, eap_type_len);
     217                 :            : 
     218                 :          0 :         return 0;
     219                 :            : }
     220                 :            : 
     221                 :            : 
     222                 :          0 : static int wps_process_cred_eap_identity(struct wps_credential *cred,
     223                 :            :                                          const u8 *identity,
     224                 :            :                                          size_t identity_len)
     225                 :            : {
     226         [ #  # ]:          0 :         if (identity == NULL)
     227                 :          0 :                 return 0; /* optional attribute */
     228                 :            : 
     229                 :          0 :         wpa_hexdump_ascii(MSG_DEBUG, "WPS: EAP Identity",
     230                 :            :                           identity, identity_len);
     231                 :            : 
     232                 :          0 :         return 0;
     233                 :            : }
     234                 :            : 
     235                 :            : 
     236                 :          0 : static int wps_process_cred_key_prov_auto(struct wps_credential *cred,
     237                 :            :                                           const u8 *key_prov_auto)
     238                 :            : {
     239         [ #  # ]:          0 :         if (key_prov_auto == NULL)
     240                 :          0 :                 return 0; /* optional attribute */
     241                 :            : 
     242                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Key Provided Automatically: %d",
     243                 :          0 :                    *key_prov_auto);
     244                 :            : 
     245                 :          0 :         return 0;
     246                 :            : }
     247                 :            : 
     248                 :            : 
     249                 :          0 : static int wps_process_cred_802_1x_enabled(struct wps_credential *cred,
     250                 :            :                                            const u8 *dot1x_enabled)
     251                 :            : {
     252         [ #  # ]:          0 :         if (dot1x_enabled == NULL)
     253                 :          0 :                 return 0; /* optional attribute */
     254                 :            : 
     255                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: 802.1X Enabled: %d", *dot1x_enabled);
     256                 :            : 
     257                 :          0 :         return 0;
     258                 :            : }
     259                 :            : 
     260                 :            : 
     261                 :          0 : static int wps_process_cred_ap_channel(struct wps_credential *cred,
     262                 :            :                                        const u8 *ap_channel)
     263                 :            : {
     264         [ #  # ]:          0 :         if (ap_channel == NULL)
     265                 :          0 :                 return 0; /* optional attribute */
     266                 :            : 
     267                 :          0 :         cred->ap_channel = WPA_GET_BE16(ap_channel);
     268                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: AP Channel: %u", cred->ap_channel);
     269                 :            : 
     270                 :          0 :         return 0;
     271                 :            : }
     272                 :            : 
     273                 :            : 
     274                 :          0 : static int wps_workaround_cred_key(struct wps_credential *cred)
     275                 :            : {
     276 [ #  # ][ #  # ]:          0 :         if (cred->auth_type & (WPS_AUTH_WPAPSK | WPS_AUTH_WPA2PSK) &&
     277 [ #  # ][ #  # ]:          0 :             cred->key_len > 8 && cred->key_len < 64 &&
     278                 :          0 :             cred->key[cred->key_len - 1] == 0) {
     279                 :            : #ifdef CONFIG_WPS_STRICT
     280                 :          0 :                 wpa_printf(MSG_INFO, "WPS: WPA/WPA2-Personal passphrase uses "
     281                 :            :                            "forbidden NULL termination");
     282                 :          0 :                 wpa_hexdump_ascii_key(MSG_INFO, "WPS: Network Key",
     283                 :          0 :                                       cred->key, cred->key_len);
     284                 :          0 :                 return -1;
     285                 :            : #else /* CONFIG_WPS_STRICT */
     286                 :            :                 /*
     287                 :            :                  * A deployed external registrar is known to encode ASCII
     288                 :            :                  * passphrases incorrectly. Remove the extra NULL termination
     289                 :            :                  * to fix the encoding.
     290                 :            :                  */
     291                 :            :                 wpa_printf(MSG_DEBUG, "WPS: Workaround - remove NULL "
     292                 :            :                            "termination from ASCII passphrase");
     293                 :            :                 cred->key_len--;
     294                 :            : #endif /* CONFIG_WPS_STRICT */
     295                 :            :         }
     296                 :          0 :         return 0;
     297                 :            : }
     298                 :            : 
     299                 :            : 
     300                 :          0 : int wps_process_cred(struct wps_parse_attr *attr,
     301                 :            :                      struct wps_credential *cred)
     302                 :            : {
     303                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Process Credential");
     304                 :            : 
     305                 :            :         /* TODO: support multiple Network Keys */
     306   [ #  #  #  # ]:          0 :         if (wps_process_cred_network_idx(cred, attr->network_idx) ||
     307         [ #  # ]:          0 :             wps_process_cred_ssid(cred, attr->ssid, attr->ssid_len) ||
     308         [ #  # ]:          0 :             wps_process_cred_auth_type(cred, attr->auth_type) ||
     309         [ #  # ]:          0 :             wps_process_cred_encr_type(cred, attr->encr_type) ||
     310         [ #  # ]:          0 :             wps_process_cred_network_key_idx(cred, attr->network_key_idx) ||
     311                 :          0 :             wps_process_cred_network_key(cred, attr->network_key,
     312         [ #  # ]:          0 :                                          attr->network_key_len) ||
     313         [ #  # ]:          0 :             wps_process_cred_mac_addr(cred, attr->mac_addr) ||
     314                 :          0 :             wps_process_cred_eap_type(cred, attr->eap_type,
     315         [ #  # ]:          0 :                                       attr->eap_type_len) ||
     316                 :          0 :             wps_process_cred_eap_identity(cred, attr->eap_identity,
     317         [ #  # ]:          0 :                                           attr->eap_identity_len) ||
     318         [ #  # ]:          0 :             wps_process_cred_key_prov_auto(cred, attr->key_prov_auto) ||
     319         [ #  # ]:          0 :             wps_process_cred_802_1x_enabled(cred, attr->dot1x_enabled) ||
     320                 :          0 :             wps_process_cred_ap_channel(cred, attr->ap_channel))
     321                 :          0 :                 return -1;
     322                 :            : 
     323                 :          0 :         return wps_workaround_cred_key(cred);
     324                 :            : }
     325                 :            : 
     326                 :            : 
     327                 :          0 : int wps_process_ap_settings(struct wps_parse_attr *attr,
     328                 :            :                             struct wps_credential *cred)
     329                 :            : {
     330                 :          0 :         wpa_printf(MSG_DEBUG, "WPS: Processing AP Settings");
     331                 :          0 :         os_memset(cred, 0, sizeof(*cred));
     332                 :            :         /* TODO: optional attributes New Password and Device Password ID */
     333   [ #  #  #  # ]:          0 :         if (wps_process_cred_ssid(cred, attr->ssid, attr->ssid_len) ||
     334         [ #  # ]:          0 :             wps_process_cred_auth_type(cred, attr->auth_type) ||
     335         [ #  # ]:          0 :             wps_process_cred_encr_type(cred, attr->encr_type) ||
     336         [ #  # ]:          0 :             wps_process_cred_network_key_idx(cred, attr->network_key_idx) ||
     337                 :          0 :             wps_process_cred_network_key(cred, attr->network_key,
     338         [ #  # ]:          0 :                                          attr->network_key_len) ||
     339                 :          0 :             wps_process_cred_mac_addr(cred, attr->mac_addr))
     340                 :          0 :                 return -1;
     341                 :            : 
     342                 :          0 :         return wps_workaround_cred_key(cred);
     343                 :            : }

Generated by: LCOV version 1.9