LCOV - code coverage report
Current view: top level - src/eap_common - eap_eke_common.c (source / functions) Hit Total Coverage
Test: hostapd hwsim test run 1388338050 Lines: 0 398 0.0 %
Date: 2013-12-29 Functions: 0 26 0.0 %
Branches: 0 189 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * EAP server/peer: EAP-EKE shared routines
       3                 :            :  * Copyright (c) 2011-2013, 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/aes.h"
      13                 :            : #include "crypto/aes_wrap.h"
      14                 :            : #include "crypto/crypto.h"
      15                 :            : #include "crypto/dh_groups.h"
      16                 :            : #include "crypto/random.h"
      17                 :            : #include "crypto/sha1.h"
      18                 :            : #include "crypto/sha256.h"
      19                 :            : #include "eap_common/eap_defs.h"
      20                 :            : #include "eap_eke_common.h"
      21                 :            : 
      22                 :            : 
      23                 :          0 : static int eap_eke_dh_len(u8 group)
      24                 :            : {
      25   [ #  #  #  #  :          0 :         switch (group) {
                   #  # ]
      26                 :            :         case EAP_EKE_DHGROUP_EKE_2:
      27                 :          0 :                 return 128;
      28                 :            :         case EAP_EKE_DHGROUP_EKE_5:
      29                 :          0 :                 return 192;
      30                 :            :         case EAP_EKE_DHGROUP_EKE_14:
      31                 :          0 :                 return 256;
      32                 :            :         case EAP_EKE_DHGROUP_EKE_15:
      33                 :          0 :                 return 384;
      34                 :            :         case EAP_EKE_DHGROUP_EKE_16:
      35                 :          0 :                 return 512;
      36                 :            :         }
      37                 :            : 
      38                 :          0 :         return -1;
      39                 :            : }
      40                 :            : 
      41                 :            : 
      42                 :          0 : static int eap_eke_dhcomp_len(u8 dhgroup, u8 encr)
      43                 :            : {
      44                 :            :         int dhlen;
      45                 :            : 
      46                 :          0 :         dhlen = eap_eke_dh_len(dhgroup);
      47         [ #  # ]:          0 :         if (dhlen < 0)
      48                 :          0 :                 return -1;
      49         [ #  # ]:          0 :         if (encr != EAP_EKE_ENCR_AES128_CBC)
      50                 :          0 :                 return -1;
      51                 :          0 :         return AES_BLOCK_SIZE + dhlen;
      52                 :            : }
      53                 :            : 
      54                 :            : 
      55                 :          0 : static const struct dh_group * eap_eke_dh_group(u8 group)
      56                 :            : {
      57   [ #  #  #  #  :          0 :         switch (group) {
                   #  # ]
      58                 :            :         case EAP_EKE_DHGROUP_EKE_2:
      59                 :          0 :                 return dh_groups_get(2);
      60                 :            :         case EAP_EKE_DHGROUP_EKE_5:
      61                 :          0 :                 return dh_groups_get(5);
      62                 :            :         case EAP_EKE_DHGROUP_EKE_14:
      63                 :          0 :                 return dh_groups_get(14);
      64                 :            :         case EAP_EKE_DHGROUP_EKE_15:
      65                 :          0 :                 return dh_groups_get(15);
      66                 :            :         case EAP_EKE_DHGROUP_EKE_16:
      67                 :          0 :                 return dh_groups_get(16);
      68                 :            :         }
      69                 :            : 
      70                 :          0 :         return NULL;
      71                 :            : }
      72                 :            : 
      73                 :            : 
      74                 :          0 : static int eap_eke_dh_generator(u8 group)
      75                 :            : {
      76   [ #  #  #  #  :          0 :         switch (group) {
                   #  # ]
      77                 :            :         case EAP_EKE_DHGROUP_EKE_2:
      78                 :          0 :                 return 5;
      79                 :            :         case EAP_EKE_DHGROUP_EKE_5:
      80                 :          0 :                 return 31;
      81                 :            :         case EAP_EKE_DHGROUP_EKE_14:
      82                 :          0 :                 return 11;
      83                 :            :         case EAP_EKE_DHGROUP_EKE_15:
      84                 :          0 :                 return 5;
      85                 :            :         case EAP_EKE_DHGROUP_EKE_16:
      86                 :          0 :                 return 5;
      87                 :            :         }
      88                 :            : 
      89                 :          0 :         return -1;
      90                 :            : }
      91                 :            : 
      92                 :            : 
      93                 :          0 : static int eap_eke_pnonce_len(u8 mac)
      94                 :            : {
      95                 :            :         int mac_len;
      96                 :            : 
      97         [ #  # ]:          0 :         if (mac == EAP_EKE_MAC_HMAC_SHA1)
      98                 :          0 :                 mac_len = SHA1_MAC_LEN;
      99         [ #  # ]:          0 :         else if (mac == EAP_EKE_MAC_HMAC_SHA2_256)
     100                 :          0 :                 mac_len = SHA256_MAC_LEN;
     101                 :            :         else
     102                 :          0 :                 return -1;
     103                 :            : 
     104                 :          0 :         return AES_BLOCK_SIZE + 16 + mac_len;
     105                 :            : }
     106                 :            : 
     107                 :            : 
     108                 :          0 : static int eap_eke_pnonce_ps_len(u8 mac)
     109                 :            : {
     110                 :            :         int mac_len;
     111                 :            : 
     112         [ #  # ]:          0 :         if (mac == EAP_EKE_MAC_HMAC_SHA1)
     113                 :          0 :                 mac_len = SHA1_MAC_LEN;
     114         [ #  # ]:          0 :         else if (mac == EAP_EKE_MAC_HMAC_SHA2_256)
     115                 :          0 :                 mac_len = SHA256_MAC_LEN;
     116                 :            :         else
     117                 :          0 :                 return -1;
     118                 :            : 
     119                 :          0 :         return AES_BLOCK_SIZE + 2 * 16 + mac_len;
     120                 :            : }
     121                 :            : 
     122                 :            : 
     123                 :          0 : static int eap_eke_prf_len(u8 prf)
     124                 :            : {
     125         [ #  # ]:          0 :         if (prf == EAP_EKE_PRF_HMAC_SHA1)
     126                 :          0 :                 return 20;
     127         [ #  # ]:          0 :         if (prf == EAP_EKE_PRF_HMAC_SHA2_256)
     128                 :          0 :                 return 32;
     129                 :          0 :         return -1;
     130                 :            : }
     131                 :            : 
     132                 :            : 
     133                 :          0 : static int eap_eke_nonce_len(u8 prf)
     134                 :            : {
     135                 :            :         int prf_len;
     136                 :            : 
     137                 :          0 :         prf_len = eap_eke_prf_len(prf);
     138         [ #  # ]:          0 :         if (prf_len < 0)
     139                 :          0 :                 return -1;
     140                 :            : 
     141         [ #  # ]:          0 :         if (prf_len > 2 * 16)
     142                 :          0 :                 return (prf_len + 1) / 2;
     143                 :            : 
     144                 :          0 :         return 16;
     145                 :            : }
     146                 :            : 
     147                 :            : 
     148                 :          0 : static int eap_eke_auth_len(u8 prf)
     149                 :            : {
     150      [ #  #  # ]:          0 :         switch (prf) {
     151                 :            :         case EAP_EKE_PRF_HMAC_SHA1:
     152                 :          0 :                 return SHA1_MAC_LEN;
     153                 :            :         case EAP_EKE_PRF_HMAC_SHA2_256:
     154                 :          0 :                 return SHA256_MAC_LEN;
     155                 :            :         }
     156                 :            : 
     157                 :          0 :         return -1;
     158                 :            : }
     159                 :            : 
     160                 :            : 
     161                 :          0 : int eap_eke_dh_init(u8 group, u8 *ret_priv, u8 *ret_pub)
     162                 :            : {
     163                 :            :         int generator;
     164                 :            :         u8 gen;
     165                 :            :         const struct dh_group *dh;
     166                 :            :         size_t pub_len, i;
     167                 :            : 
     168                 :          0 :         generator = eap_eke_dh_generator(group);
     169 [ #  # ][ #  # ]:          0 :         if (generator < 0 || generator > 255)
     170                 :          0 :                 return -1;
     171                 :          0 :         gen = generator;
     172                 :            : 
     173                 :          0 :         dh = eap_eke_dh_group(group);
     174         [ #  # ]:          0 :         if (dh == NULL)
     175                 :          0 :                 return -1;
     176                 :            : 
     177                 :            :         /* x = random number 2 .. p-1 */
     178         [ #  # ]:          0 :         if (random_get_bytes(ret_priv, dh->prime_len))
     179                 :          0 :                 return -1;
     180         [ #  # ]:          0 :         if (os_memcmp(ret_priv, dh->prime, dh->prime_len) > 0) {
     181                 :            :                 /* Make sure private value is smaller than prime */
     182                 :          0 :                 ret_priv[0] = 0;
     183                 :            :         }
     184         [ #  # ]:          0 :         for (i = 0; i < dh->prime_len - 1; i++) {
     185         [ #  # ]:          0 :                 if (ret_priv[i])
     186                 :          0 :                         break;
     187                 :            :         }
     188 [ #  # ][ #  # ]:          0 :         if (i == dh->prime_len - 1 && (ret_priv[i] == 0 || ret_priv[i] == 1))
                 [ #  # ]
     189                 :          0 :                 return -1;
     190                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: DH private value",
     191                 :            :                         ret_priv, dh->prime_len);
     192                 :            : 
     193                 :            :         /* y = g ^ x (mod p) */
     194                 :          0 :         pub_len = dh->prime_len;
     195         [ #  # ]:          0 :         if (crypto_mod_exp(&gen, 1, ret_priv, dh->prime_len,
     196                 :            :                            dh->prime, dh->prime_len, ret_pub, &pub_len) < 0)
     197                 :          0 :                 return -1;
     198         [ #  # ]:          0 :         if (pub_len < dh->prime_len) {
     199                 :          0 :                 size_t pad = dh->prime_len - pub_len;
     200                 :          0 :                 os_memmove(ret_pub + pad, ret_pub, pub_len);
     201                 :          0 :                 os_memset(ret_pub, 0, pad);
     202                 :            :         }
     203                 :            : 
     204                 :          0 :         wpa_hexdump(MSG_DEBUG, "EAP-EKE: DH public value",
     205                 :            :                     ret_pub, dh->prime_len);
     206                 :            : 
     207                 :          0 :         return 0;
     208                 :            : }
     209                 :            : 
     210                 :            : 
     211                 :          0 : static int eap_eke_prf(u8 prf, const u8 *key, size_t key_len, const u8 *data,
     212                 :            :                        size_t data_len, const u8 *data2, size_t data2_len,
     213                 :            :                        u8 *res)
     214                 :            : {
     215                 :            :         const u8 *addr[2];
     216                 :            :         size_t len[2];
     217                 :          0 :         size_t num_elem = 1;
     218                 :            : 
     219                 :          0 :         addr[0] = data;
     220                 :          0 :         len[0] = data_len;
     221         [ #  # ]:          0 :         if (data2) {
     222                 :          0 :                 num_elem++;
     223                 :          0 :                 addr[1] = data2;
     224                 :          0 :                 len[1] = data2_len;
     225                 :            :         }
     226                 :            : 
     227         [ #  # ]:          0 :         if (prf == EAP_EKE_PRF_HMAC_SHA1)
     228                 :          0 :                 return hmac_sha1_vector(key, key_len, num_elem, addr, len, res);
     229         [ #  # ]:          0 :         if (prf == EAP_EKE_PRF_HMAC_SHA2_256)
     230                 :          0 :                 return hmac_sha256_vector(key, key_len, num_elem, addr, len,
     231                 :            :                                           res);
     232                 :          0 :         return -1;
     233                 :            : }
     234                 :            : 
     235                 :            : 
     236                 :          0 : static int eap_eke_prf_hmac_sha1(const u8 *key, size_t key_len, const u8 *data,
     237                 :            :                                  size_t data_len, u8 *res, size_t len)
     238                 :            : {
     239                 :            :         u8 hash[SHA1_MAC_LEN];
     240                 :            :         u8 idx;
     241                 :            :         const u8 *addr[3];
     242                 :            :         size_t vlen[3];
     243                 :            :         int ret;
     244                 :            : 
     245                 :          0 :         idx = 0;
     246                 :          0 :         addr[0] = hash;
     247                 :          0 :         vlen[0] = SHA1_MAC_LEN;
     248                 :          0 :         addr[1] = data;
     249                 :          0 :         vlen[1] = data_len;
     250                 :          0 :         addr[2] = &idx;
     251                 :          0 :         vlen[2] = 1;
     252                 :            : 
     253         [ #  # ]:          0 :         while (len > 0) {
     254                 :          0 :                 idx++;
     255         [ #  # ]:          0 :                 if (idx == 1)
     256                 :          0 :                         ret = hmac_sha1_vector(key, key_len, 2, &addr[1],
     257                 :            :                                                &vlen[1], hash);
     258                 :            :                 else
     259                 :          0 :                         ret = hmac_sha1_vector(key, key_len, 3, addr, vlen,
     260                 :            :                                                hash);
     261         [ #  # ]:          0 :                 if (ret < 0)
     262                 :          0 :                         return -1;
     263         [ #  # ]:          0 :                 if (len > SHA1_MAC_LEN) {
     264                 :          0 :                         os_memcpy(res, hash, SHA1_MAC_LEN);
     265                 :          0 :                         res += SHA1_MAC_LEN;
     266                 :          0 :                         len -= SHA1_MAC_LEN;
     267                 :            :                 } else {
     268                 :          0 :                         os_memcpy(res, hash, len);
     269                 :          0 :                         len = 0;
     270                 :            :                 }
     271                 :            :         }
     272                 :            : 
     273                 :          0 :         return 0;
     274                 :            : }
     275                 :            : 
     276                 :            : 
     277                 :          0 : static int eap_eke_prf_hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
     278                 :            :                                    size_t data_len, u8 *res, size_t len)
     279                 :            : {
     280                 :            :         u8 hash[SHA256_MAC_LEN];
     281                 :            :         u8 idx;
     282                 :            :         const u8 *addr[3];
     283                 :            :         size_t vlen[3];
     284                 :            :         int ret;
     285                 :            : 
     286                 :          0 :         idx = 0;
     287                 :          0 :         addr[0] = hash;
     288                 :          0 :         vlen[0] = SHA256_MAC_LEN;
     289                 :          0 :         addr[1] = data;
     290                 :          0 :         vlen[1] = data_len;
     291                 :          0 :         addr[2] = &idx;
     292                 :          0 :         vlen[2] = 1;
     293                 :            : 
     294         [ #  # ]:          0 :         while (len > 0) {
     295                 :          0 :                 idx++;
     296         [ #  # ]:          0 :                 if (idx == 1)
     297                 :          0 :                         ret = hmac_sha256_vector(key, key_len, 2, &addr[1],
     298                 :            :                                                  &vlen[1], hash);
     299                 :            :                 else
     300                 :          0 :                         ret = hmac_sha256_vector(key, key_len, 3, addr, vlen,
     301                 :            :                                                  hash);
     302         [ #  # ]:          0 :                 if (ret < 0)
     303                 :          0 :                         return -1;
     304         [ #  # ]:          0 :                 if (len > SHA256_MAC_LEN) {
     305                 :          0 :                         os_memcpy(res, hash, SHA256_MAC_LEN);
     306                 :          0 :                         res += SHA256_MAC_LEN;
     307                 :          0 :                         len -= SHA256_MAC_LEN;
     308                 :            :                 } else {
     309                 :          0 :                         os_memcpy(res, hash, len);
     310                 :          0 :                         len = 0;
     311                 :            :                 }
     312                 :            :         }
     313                 :            : 
     314                 :          0 :         return 0;
     315                 :            : }
     316                 :            : 
     317                 :            : 
     318                 :          0 : static int eap_eke_prfplus(u8 prf, const u8 *key, size_t key_len,
     319                 :            :                            const u8 *data, size_t data_len, u8 *res, size_t len)
     320                 :            : {
     321         [ #  # ]:          0 :         if (prf == EAP_EKE_PRF_HMAC_SHA1)
     322                 :          0 :                 return eap_eke_prf_hmac_sha1(key, key_len, data, data_len, res,
     323                 :            :                                              len);
     324         [ #  # ]:          0 :         if (prf == EAP_EKE_PRF_HMAC_SHA2_256)
     325                 :          0 :                 return eap_eke_prf_hmac_sha256(key, key_len, data, data_len,
     326                 :            :                                                res, len);
     327                 :          0 :         return -1;
     328                 :            : }
     329                 :            : 
     330                 :            : 
     331                 :          0 : int eap_eke_derive_key(struct eap_eke_session *sess,
     332                 :            :                        const u8 *password, size_t password_len,
     333                 :            :                        const u8 *id_s, size_t id_s_len, const u8 *id_p,
     334                 :            :                        size_t id_p_len, u8 *key)
     335                 :            : {
     336                 :            :         u8 zeros[EAP_EKE_MAX_HASH_LEN];
     337                 :            :         u8 temp[EAP_EKE_MAX_HASH_LEN];
     338                 :          0 :         size_t key_len = 16; /* Only AES-128-CBC is used here */
     339                 :            :         u8 *id;
     340                 :            : 
     341                 :            :         /* temp = prf(0+, password) */
     342                 :          0 :         os_memset(zeros, 0, sess->prf_len);
     343         [ #  # ]:          0 :         if (eap_eke_prf(sess->prf, zeros, sess->prf_len,
     344                 :            :                         password, password_len, NULL, 0, temp) < 0)
     345                 :          0 :                 return -1;
     346                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: temp = prf(0+, password)",
     347                 :          0 :                         temp, sess->prf_len);
     348                 :            : 
     349                 :            :         /* key = prf+(temp, ID_S | ID_P) */
     350                 :          0 :         id = os_malloc(id_s_len + id_p_len);
     351         [ #  # ]:          0 :         if (id == NULL)
     352                 :          0 :                 return -1;
     353                 :          0 :         os_memcpy(id, id_s, id_s_len);
     354                 :          0 :         os_memcpy(id + id_s_len, id_p, id_p_len);
     355                 :          0 :         wpa_hexdump_ascii(MSG_DEBUG, "EAP-EKE: ID_S | ID_P",
     356                 :            :                           id, id_s_len + id_p_len);
     357         [ #  # ]:          0 :         if (eap_eke_prfplus(sess->prf, temp, sess->prf_len,
     358                 :            :                             id, id_s_len + id_p_len, key, key_len) < 0) {
     359                 :          0 :                 os_free(id);
     360                 :          0 :                 return -1;
     361                 :            :         }
     362                 :          0 :         os_free(id);
     363                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: key = prf+(temp, ID_S | ID_P)",
     364                 :            :                         key, key_len);
     365                 :            : 
     366                 :          0 :         return 0;
     367                 :            : }
     368                 :            : 
     369                 :            : 
     370                 :          0 : int eap_eke_dhcomp(struct eap_eke_session *sess, const u8 *key, const u8 *dhpub,
     371                 :            :                    u8 *ret_dhcomp)
     372                 :            : {
     373                 :            :         u8 pub[EAP_EKE_MAX_DH_LEN];
     374                 :            :         int dh_len;
     375                 :            :         u8 iv[AES_BLOCK_SIZE];
     376                 :            : 
     377                 :          0 :         dh_len = eap_eke_dh_len(sess->dhgroup);
     378         [ #  # ]:          0 :         if (dh_len < 0)
     379                 :          0 :                 return -1;
     380                 :            : 
     381                 :            :         /*
     382                 :            :          * DHComponent = Encr(key, y)
     383                 :            :          *
     384                 :            :          * All defined DH groups use primes that have length devisible by 16, so
     385                 :            :          * no need to do extra padding for y (= pub).
     386                 :            :          */
     387         [ #  # ]:          0 :         if (sess->encr != EAP_EKE_ENCR_AES128_CBC)
     388                 :          0 :                 return -1;
     389         [ #  # ]:          0 :         if (random_get_bytes(iv, AES_BLOCK_SIZE))
     390                 :          0 :                 return -1;
     391                 :          0 :         wpa_hexdump(MSG_DEBUG, "EAP-EKE: IV for Encr(key, y)",
     392                 :            :                     iv, AES_BLOCK_SIZE);
     393                 :          0 :         os_memcpy(pub, dhpub, dh_len);
     394         [ #  # ]:          0 :         if (aes_128_cbc_encrypt(key, iv, pub, dh_len) < 0)
     395                 :          0 :                 return -1;
     396                 :          0 :         os_memcpy(ret_dhcomp, iv, AES_BLOCK_SIZE);
     397                 :          0 :         os_memcpy(ret_dhcomp + AES_BLOCK_SIZE, pub, dh_len);
     398                 :          0 :         wpa_hexdump(MSG_DEBUG, "EAP-EKE: DHComponent = Encr(key, y)",
     399                 :          0 :                     ret_dhcomp, AES_BLOCK_SIZE + dh_len);
     400                 :            : 
     401                 :          0 :         return 0;
     402                 :            : }
     403                 :            : 
     404                 :            : 
     405                 :          0 : int eap_eke_shared_secret(struct eap_eke_session *sess, const u8 *key,
     406                 :            :                           const u8 *dhpriv, const u8 *peer_dhcomp)
     407                 :            : {
     408                 :            :         u8 zeros[EAP_EKE_MAX_HASH_LEN];
     409                 :            :         u8 peer_pub[EAP_EKE_MAX_DH_LEN];
     410                 :            :         u8 modexp[EAP_EKE_MAX_DH_LEN];
     411                 :            :         size_t len;
     412                 :            :         const struct dh_group *dh;
     413                 :            : 
     414         [ #  # ]:          0 :         if (sess->encr != EAP_EKE_ENCR_AES128_CBC)
     415                 :          0 :                 return -1;
     416                 :            : 
     417                 :          0 :         dh = eap_eke_dh_group(sess->dhgroup);
     418         [ #  # ]:          0 :         if (dh == NULL)
     419                 :          0 :                 return -1;
     420                 :            : 
     421                 :            :         /* Decrypt peer DHComponent */
     422                 :          0 :         os_memcpy(peer_pub, peer_dhcomp + AES_BLOCK_SIZE, dh->prime_len);
     423         [ #  # ]:          0 :         if (aes_128_cbc_decrypt(key, peer_dhcomp, peer_pub, dh->prime_len) < 0) {
     424                 :          0 :                 wpa_printf(MSG_INFO, "EAP-EKE: Failed to decrypt DHComponent");
     425                 :          0 :                 return -1;
     426                 :            :         }
     427                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: Decrypted peer DH pubkey",
     428                 :            :                         peer_pub, dh->prime_len);
     429                 :            : 
     430                 :            :         /* SharedSecret = prf(0+, g ^ (x_s * x_p) (mod p)) */
     431                 :          0 :         len = dh->prime_len;
     432         [ #  # ]:          0 :         if (crypto_mod_exp(peer_pub, dh->prime_len, dhpriv, dh->prime_len,
     433                 :            :                            dh->prime, dh->prime_len, modexp, &len) < 0)
     434                 :          0 :                 return -1;
     435         [ #  # ]:          0 :         if (len < dh->prime_len) {
     436                 :          0 :                 size_t pad = dh->prime_len - len;
     437                 :          0 :                 os_memmove(modexp + pad, modexp, len);
     438                 :          0 :                 os_memset(modexp, 0, pad);
     439                 :            :         }
     440                 :            : 
     441                 :          0 :         os_memset(zeros, 0, sess->auth_len);
     442         [ #  # ]:          0 :         if (eap_eke_prf(sess->prf, zeros, sess->auth_len, modexp, dh->prime_len,
     443                 :          0 :                         NULL, 0, sess->shared_secret) < 0)
     444                 :          0 :                 return -1;
     445                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: SharedSecret",
     446                 :          0 :                         sess->shared_secret, sess->auth_len);
     447                 :            : 
     448                 :          0 :         return 0;
     449                 :            : }
     450                 :            : 
     451                 :            : 
     452                 :          0 : int eap_eke_derive_ke_ki(struct eap_eke_session *sess,
     453                 :            :                          const u8 *id_s, size_t id_s_len,
     454                 :            :                          const u8 *id_p, size_t id_p_len)
     455                 :            : {
     456                 :            :         u8 buf[EAP_EKE_MAX_KE_LEN + EAP_EKE_MAX_KI_LEN];
     457                 :            :         size_t ke_len, ki_len;
     458                 :            :         u8 *data;
     459                 :            :         size_t data_len;
     460                 :          0 :         const char *label = "EAP-EKE Keys";
     461                 :            :         size_t label_len;
     462                 :            : 
     463                 :            :         /*
     464                 :            :          * Ke | Ki = prf+(SharedSecret, "EAP-EKE Keys" | ID_S | ID_P)
     465                 :            :          * Ke = encryption key
     466                 :            :          * Ki = integrity protection key
     467                 :            :          * Length of each key depends on the selected algorithms.
     468                 :            :          */
     469                 :            : 
     470         [ #  # ]:          0 :         if (sess->encr == EAP_EKE_ENCR_AES128_CBC)
     471                 :          0 :                 ke_len = 16;
     472                 :            :         else
     473                 :          0 :                 return -1;
     474                 :            : 
     475         [ #  # ]:          0 :         if (sess->mac == EAP_EKE_PRF_HMAC_SHA1)
     476                 :          0 :                 ki_len = 20;
     477         [ #  # ]:          0 :         else if (sess->mac == EAP_EKE_PRF_HMAC_SHA2_256)
     478                 :          0 :                 ki_len = 32;
     479                 :            :         else
     480                 :          0 :                 return -1;
     481                 :            : 
     482                 :          0 :         label_len = os_strlen(label);
     483                 :          0 :         data_len = label_len + id_s_len + id_p_len;
     484                 :          0 :         data = os_malloc(data_len);
     485         [ #  # ]:          0 :         if (data == NULL)
     486                 :          0 :                 return -1;
     487                 :          0 :         os_memcpy(data, label, label_len);
     488                 :          0 :         os_memcpy(data + label_len, id_s, id_s_len);
     489                 :          0 :         os_memcpy(data + label_len + id_s_len, id_p, id_p_len);
     490         [ #  # ]:          0 :         if (eap_eke_prfplus(sess->prf, sess->shared_secret, sess->prf_len,
     491                 :            :                             data, data_len, buf, ke_len + ki_len) < 0) {
     492                 :          0 :                 os_free(data);
     493                 :          0 :                 return -1;
     494                 :            :         }
     495                 :            : 
     496                 :          0 :         os_memcpy(sess->ke, buf, ke_len);
     497                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: Ke", sess->ke, ke_len);
     498                 :          0 :         os_memcpy(sess->ki, buf + ke_len, ki_len);
     499                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: Ki", sess->ki, ki_len);
     500                 :            : 
     501                 :          0 :         os_free(data);
     502                 :          0 :         return 0;
     503                 :            : }
     504                 :            : 
     505                 :            : 
     506                 :          0 : int eap_eke_derive_ka(struct eap_eke_session *sess,
     507                 :            :                       const u8 *id_s, size_t id_s_len,
     508                 :            :                       const u8 *id_p, size_t id_p_len,
     509                 :            :                       const u8 *nonce_p, const u8 *nonce_s)
     510                 :            : {
     511                 :            :         u8 *data, *pos;
     512                 :            :         size_t data_len;
     513                 :          0 :         const char *label = "EAP-EKE Ka";
     514                 :            :         size_t label_len;
     515                 :            : 
     516                 :            :         /*
     517                 :            :          * Ka = prf+(SharedSecret, "EAP-EKE Ka" | ID_S | ID_P | Nonce_P |
     518                 :            :          *           Nonce_S)
     519                 :            :          * Ka = authentication key
     520                 :            :          * Length of the key depends on the selected algorithms.
     521                 :            :          */
     522                 :            : 
     523                 :          0 :         label_len = os_strlen(label);
     524                 :          0 :         data_len = label_len + id_s_len + id_p_len + 2 * sess->nonce_len;
     525                 :          0 :         data = os_malloc(data_len);
     526         [ #  # ]:          0 :         if (data == NULL)
     527                 :          0 :                 return -1;
     528                 :          0 :         pos = data;
     529                 :          0 :         os_memcpy(pos, label, label_len);
     530                 :          0 :         pos += label_len;
     531                 :          0 :         os_memcpy(pos, id_s, id_s_len);
     532                 :          0 :         pos += id_s_len;
     533                 :          0 :         os_memcpy(pos, id_p, id_p_len);
     534                 :          0 :         pos += id_p_len;
     535                 :          0 :         os_memcpy(pos, nonce_p, sess->nonce_len);
     536                 :          0 :         pos += sess->nonce_len;
     537                 :          0 :         os_memcpy(pos, nonce_s, sess->nonce_len);
     538         [ #  # ]:          0 :         if (eap_eke_prfplus(sess->prf, sess->shared_secret, sess->prf_len,
     539                 :          0 :                             data, data_len, sess->ka, sess->prf_len) < 0) {
     540                 :          0 :                 os_free(data);
     541                 :          0 :                 return -1;
     542                 :            :         }
     543                 :          0 :         os_free(data);
     544                 :            : 
     545                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: Ka", sess->ka, sess->prf_len);
     546                 :            : 
     547                 :          0 :         return 0;
     548                 :            : }
     549                 :            : 
     550                 :            : 
     551                 :          0 : int eap_eke_derive_msk(struct eap_eke_session *sess,
     552                 :            :                        const u8 *id_s, size_t id_s_len,
     553                 :            :                        const u8 *id_p, size_t id_p_len,
     554                 :            :                        const u8 *nonce_p, const u8 *nonce_s,
     555                 :            :                        u8 *msk, u8 *emsk)
     556                 :            : {
     557                 :            :         u8 *data, *pos;
     558                 :            :         size_t data_len;
     559                 :          0 :         const char *label = "EAP-EKE Exported Keys";
     560                 :            :         size_t label_len;
     561                 :            :         u8 buf[EAP_MSK_LEN + EAP_EMSK_LEN];
     562                 :            : 
     563                 :            :         /*
     564                 :            :          * MSK | EMSK = prf+(SharedSecret, "EAP-EKE Exported Keys" | ID_S |
     565                 :            :          *                   ID_P | Nonce_P | Nonce_S)
     566                 :            :          */
     567                 :            : 
     568                 :          0 :         label_len = os_strlen(label);
     569                 :          0 :         data_len = label_len + id_s_len + id_p_len + 2 * sess->nonce_len;
     570                 :          0 :         data = os_malloc(data_len);
     571         [ #  # ]:          0 :         if (data == NULL)
     572                 :          0 :                 return -1;
     573                 :          0 :         pos = data;
     574                 :          0 :         os_memcpy(pos, label, label_len);
     575                 :          0 :         pos += label_len;
     576                 :          0 :         os_memcpy(pos, id_s, id_s_len);
     577                 :          0 :         pos += id_s_len;
     578                 :          0 :         os_memcpy(pos, id_p, id_p_len);
     579                 :          0 :         pos += id_p_len;
     580                 :          0 :         os_memcpy(pos, nonce_p, sess->nonce_len);
     581                 :          0 :         pos += sess->nonce_len;
     582                 :          0 :         os_memcpy(pos, nonce_s, sess->nonce_len);
     583         [ #  # ]:          0 :         if (eap_eke_prfplus(sess->prf, sess->shared_secret, sess->prf_len,
     584                 :            :                             data, data_len, buf, EAP_MSK_LEN + EAP_EMSK_LEN) <
     585                 :            :             0) {
     586                 :          0 :                 os_free(data);
     587                 :          0 :                 return -1;
     588                 :            :         }
     589                 :          0 :         os_free(data);
     590                 :            : 
     591                 :          0 :         os_memcpy(msk, buf, EAP_MSK_LEN);
     592                 :          0 :         os_memcpy(emsk, buf + EAP_MSK_LEN, EAP_EMSK_LEN);
     593                 :          0 :         os_memset(buf, 0, sizeof(buf));
     594                 :            : 
     595                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: MSK", msk, EAP_MSK_LEN);
     596                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: EMSK", msk, EAP_EMSK_LEN);
     597                 :            : 
     598                 :          0 :         return 0;
     599                 :            : }
     600                 :            : 
     601                 :            : 
     602                 :          0 : static int eap_eke_mac(u8 mac, const u8 *key, const u8 *data, size_t data_len,
     603                 :            :                        u8 *res)
     604                 :            : {
     605         [ #  # ]:          0 :         if (mac == EAP_EKE_MAC_HMAC_SHA1)
     606                 :          0 :                 return hmac_sha1(key, SHA1_MAC_LEN, data, data_len, res);
     607         [ #  # ]:          0 :         if (mac == EAP_EKE_MAC_HMAC_SHA2_256)
     608                 :          0 :                 return hmac_sha256(key, SHA256_MAC_LEN, data, data_len, res);
     609                 :          0 :         return -1;
     610                 :            : }
     611                 :            : 
     612                 :            : 
     613                 :          0 : int eap_eke_prot(struct eap_eke_session *sess,
     614                 :            :                  const u8 *data, size_t data_len,
     615                 :            :                  u8 *prot, size_t *prot_len)
     616                 :            : {
     617                 :            :         size_t block_size, icv_len, pad;
     618                 :            :         u8 *pos, *iv, *e;
     619                 :            : 
     620         [ #  # ]:          0 :         if (sess->encr == EAP_EKE_ENCR_AES128_CBC)
     621                 :          0 :                 block_size = AES_BLOCK_SIZE;
     622                 :            :         else
     623                 :          0 :                 return -1;
     624                 :            : 
     625         [ #  # ]:          0 :         if (sess->mac == EAP_EKE_PRF_HMAC_SHA1)
     626                 :          0 :                 icv_len = SHA1_MAC_LEN;
     627         [ #  # ]:          0 :         else if (sess->mac == EAP_EKE_PRF_HMAC_SHA2_256)
     628                 :          0 :                 icv_len = SHA256_MAC_LEN;
     629                 :            :         else
     630                 :          0 :                 return -1;
     631                 :            : 
     632                 :          0 :         pad = data_len % block_size;
     633         [ #  # ]:          0 :         if (pad)
     634                 :          0 :                 pad = block_size - pad;
     635                 :            : 
     636         [ #  # ]:          0 :         if (*prot_len < block_size + data_len + pad + icv_len) {
     637                 :          0 :                 wpa_printf(MSG_INFO, "EAP-EKE: Not enough room for Prot() data");
     638                 :            :         }
     639                 :          0 :         pos = prot;
     640                 :            : 
     641         [ #  # ]:          0 :         if (random_get_bytes(pos, block_size))
     642                 :          0 :                 return -1;
     643                 :          0 :         iv = pos;
     644                 :          0 :         wpa_hexdump(MSG_DEBUG, "EAP-EKE: IV for Prot()", iv, block_size);
     645                 :          0 :         pos += block_size;
     646                 :            : 
     647                 :          0 :         e = pos;
     648                 :          0 :         os_memcpy(pos, data, data_len);
     649                 :          0 :         pos += data_len;
     650         [ #  # ]:          0 :         if (pad) {
     651         [ #  # ]:          0 :                 if (random_get_bytes(pos, pad))
     652                 :          0 :                         return -1;
     653                 :          0 :                 pos += pad;
     654                 :            :         }
     655                 :            : 
     656         [ #  # ]:          0 :         if (aes_128_cbc_encrypt(sess->ke, iv, e, data_len + pad) < 0)
     657                 :          0 :                 return -1;
     658                 :            : 
     659         [ #  # ]:          0 :         if (eap_eke_mac(sess->mac, sess->ki, e, data_len + pad, pos) < 0)
     660                 :          0 :                 return -1;
     661                 :          0 :         pos += icv_len;
     662                 :            : 
     663                 :          0 :         *prot_len = pos - prot;
     664                 :          0 :         return 0;
     665                 :            : }
     666                 :            : 
     667                 :            : 
     668                 :          0 : int eap_eke_decrypt_prot(struct eap_eke_session *sess,
     669                 :            :                          const u8 *prot, size_t prot_len,
     670                 :            :                          u8 *data, size_t *data_len)
     671                 :            : {
     672                 :            :         size_t block_size, icv_len;
     673                 :            :         u8 icv[EAP_EKE_MAX_HASH_LEN];
     674                 :            : 
     675         [ #  # ]:          0 :         if (sess->encr == EAP_EKE_ENCR_AES128_CBC)
     676                 :          0 :                 block_size = AES_BLOCK_SIZE;
     677                 :            :         else
     678                 :          0 :                 return -1;
     679                 :            : 
     680         [ #  # ]:          0 :         if (sess->mac == EAP_EKE_PRF_HMAC_SHA1)
     681                 :          0 :                 icv_len = SHA1_MAC_LEN;
     682         [ #  # ]:          0 :         else if (sess->mac == EAP_EKE_PRF_HMAC_SHA2_256)
     683                 :          0 :                 icv_len = SHA256_MAC_LEN;
     684                 :            :         else
     685                 :          0 :                 return -1;
     686                 :            : 
     687         [ #  # ]:          0 :         if (prot_len < 2 * block_size + icv_len)
     688                 :          0 :                 return -1;
     689         [ #  # ]:          0 :         if ((prot_len - icv_len) % block_size)
     690                 :          0 :                 return -1;
     691                 :            : 
     692         [ #  # ]:          0 :         if (eap_eke_mac(sess->mac, sess->ki, prot + block_size,
     693                 :          0 :                         prot_len - block_size - icv_len, icv) < 0)
     694                 :          0 :                 return -1;
     695         [ #  # ]:          0 :         if (os_memcmp(icv, prot + prot_len - icv_len, icv_len) != 0) {
     696                 :          0 :                 wpa_printf(MSG_INFO, "EAP-EKE: ICV mismatch in Prot() data");
     697                 :          0 :                 return -1;
     698                 :            :         }
     699                 :            : 
     700         [ #  # ]:          0 :         if (*data_len < prot_len - block_size - icv_len) {
     701                 :          0 :                 wpa_printf(MSG_INFO, "EAP-EKE: Not enough room for decrypted Prot() data");
     702                 :          0 :                 return -1;
     703                 :            :         }
     704                 :            : 
     705                 :          0 :         *data_len = prot_len - block_size - icv_len;
     706                 :          0 :         os_memcpy(data, prot + block_size, *data_len);
     707         [ #  # ]:          0 :         if (aes_128_cbc_decrypt(sess->ke, prot, data, *data_len) < 0) {
     708                 :          0 :                 wpa_printf(MSG_INFO, "EAP-EKE: Failed to decrypt Prot() data");
     709                 :          0 :                 return -1;
     710                 :            :         }
     711                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: Decrypted Prot() data",
     712                 :            :                         data, *data_len);
     713                 :            : 
     714                 :          0 :         return 0;
     715                 :            : }
     716                 :            : 
     717                 :            : 
     718                 :          0 : int eap_eke_auth(struct eap_eke_session *sess, const char *label,
     719                 :            :                  const struct wpabuf *msgs, u8 *auth)
     720                 :            : {
     721                 :          0 :         wpa_printf(MSG_DEBUG, "EAP-EKE: Auth(%s)", label);
     722                 :          0 :         wpa_hexdump_key(MSG_DEBUG, "EAP-EKE: Ka for Auth",
     723                 :          0 :                         sess->ka, sess->auth_len);
     724                 :          0 :         wpa_hexdump_buf(MSG_MSGDUMP, "EAP-EKE: Messages for Auth", msgs);
     725                 :          0 :         return eap_eke_prf(sess->prf, sess->ka, sess->auth_len,
     726                 :            :                            (const u8 *) label, os_strlen(label),
     727                 :          0 :                            wpabuf_head(msgs), wpabuf_len(msgs), auth);
     728                 :            : }
     729                 :            : 
     730                 :            : 
     731                 :          0 : int eap_eke_session_init(struct eap_eke_session *sess, u8 dhgroup, u8 encr,
     732                 :            :                          u8 prf, u8 mac)
     733                 :            : {
     734                 :          0 :         sess->dhgroup = dhgroup;
     735                 :          0 :         sess->encr = encr;
     736                 :          0 :         sess->prf = prf;
     737                 :          0 :         sess->mac = mac;
     738                 :            : 
     739                 :          0 :         sess->prf_len = eap_eke_prf_len(prf);
     740         [ #  # ]:          0 :         if (sess->prf_len < 0)
     741                 :          0 :                 return -1;
     742                 :          0 :         sess->nonce_len = eap_eke_nonce_len(prf);
     743         [ #  # ]:          0 :         if (sess->nonce_len < 0)
     744                 :          0 :                 return -1;
     745                 :          0 :         sess->auth_len = eap_eke_auth_len(prf);
     746         [ #  # ]:          0 :         if (sess->auth_len < 0)
     747                 :          0 :                 return -1;
     748                 :          0 :         sess->dhcomp_len = eap_eke_dhcomp_len(sess->dhgroup, sess->encr);
     749         [ #  # ]:          0 :         if (sess->dhcomp_len < 0)
     750                 :          0 :                 return -1;
     751                 :          0 :         sess->pnonce_len = eap_eke_pnonce_len(sess->mac);
     752         [ #  # ]:          0 :         if (sess->pnonce_len < 0)
     753                 :          0 :                 return -1;
     754                 :          0 :         sess->pnonce_ps_len = eap_eke_pnonce_ps_len(sess->mac);
     755         [ #  # ]:          0 :         if (sess->pnonce_ps_len < 0)
     756                 :          0 :                 return -1;
     757                 :            : 
     758                 :          0 :         return 0;
     759                 :            : }
     760                 :            : 
     761                 :            : 
     762                 :          0 : void eap_eke_session_clean(struct eap_eke_session *sess)
     763                 :            : {
     764                 :          0 :         os_memset(sess->shared_secret, 0, EAP_EKE_MAX_HASH_LEN);
     765                 :          0 :         os_memset(sess->ke, 0, EAP_EKE_MAX_KE_LEN);
     766                 :          0 :         os_memset(sess->ki, 0, EAP_EKE_MAX_KI_LEN);
     767                 :          0 :         os_memset(sess->ka, 0, EAP_EKE_MAX_KA_LEN);
     768                 :          0 : }

Generated by: LCOV version 1.9