LCOV - code coverage report
Current view: top level - src/eap_server - eap_server_sim.c (source / functions) Hit Total Coverage
Test: hostapd/hlr_auc_gw (AS) hwsim test run 1388338050 Lines: 264 430 61.4 %
Date: 2013-12-29 Functions: 20 24 83.3 %
Branches: 87 198 43.9 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * hostapd / EAP-SIM (RFC 4186)
       3                 :            :  * Copyright (c) 2005-2012, 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/random.h"
      13                 :            : #include "eap_server/eap_i.h"
      14                 :            : #include "eap_common/eap_sim_common.h"
      15                 :            : #include "eap_server/eap_sim_db.h"
      16                 :            : 
      17                 :            : 
      18                 :            : struct eap_sim_data {
      19                 :            :         u8 mk[EAP_SIM_MK_LEN];
      20                 :            :         u8 nonce_mt[EAP_SIM_NONCE_MT_LEN];
      21                 :            :         u8 nonce_s[EAP_SIM_NONCE_S_LEN];
      22                 :            :         u8 k_aut[EAP_SIM_K_AUT_LEN];
      23                 :            :         u8 k_encr[EAP_SIM_K_ENCR_LEN];
      24                 :            :         u8 msk[EAP_SIM_KEYING_DATA_LEN];
      25                 :            :         u8 emsk[EAP_EMSK_LEN];
      26                 :            :         u8 kc[EAP_SIM_MAX_CHAL][EAP_SIM_KC_LEN];
      27                 :            :         u8 sres[EAP_SIM_MAX_CHAL][EAP_SIM_SRES_LEN];
      28                 :            :         u8 rand[EAP_SIM_MAX_CHAL][GSM_RAND_LEN];
      29                 :            :         int num_chal;
      30                 :            :         enum {
      31                 :            :                 START, CHALLENGE, REAUTH, NOTIFICATION, SUCCESS, FAILURE
      32                 :            :         } state;
      33                 :            :         char *next_pseudonym;
      34                 :            :         char *next_reauth_id;
      35                 :            :         u16 counter;
      36                 :            :         struct eap_sim_reauth *reauth;
      37                 :            :         u16 notification;
      38                 :            :         int use_result_ind;
      39                 :            :         int start_round;
      40                 :            :         char permanent[20]; /* Permanent username */
      41                 :            : };
      42                 :            : 
      43                 :            : 
      44                 :         20 : static const char * eap_sim_state_txt(int state)
      45                 :            : {
      46   [ +  +  +  +  :         20 :         switch (state) {
                -  -  - ]
      47                 :            :         case START:
      48                 :          5 :                 return "START";
      49                 :            :         case CHALLENGE:
      50                 :          8 :                 return "CHALLENGE";
      51                 :            :         case REAUTH:
      52                 :          2 :                 return "REAUTH";
      53                 :            :         case SUCCESS:
      54                 :          5 :                 return "SUCCESS";
      55                 :            :         case FAILURE:
      56                 :          0 :                 return "FAILURE";
      57                 :            :         case NOTIFICATION:
      58                 :          0 :                 return "NOTIFICATION";
      59                 :            :         default:
      60                 :         20 :                 return "Unknown?!";
      61                 :            :         }
      62                 :            : }
      63                 :            : 
      64                 :            : 
      65                 :         10 : static void eap_sim_state(struct eap_sim_data *data, int state)
      66                 :            : {
      67                 :         10 :         wpa_printf(MSG_DEBUG, "EAP-SIM: %s -> %s",
      68                 :         10 :                    eap_sim_state_txt(data->state),
      69                 :            :                    eap_sim_state_txt(state));
      70                 :         10 :         data->state = state;
      71                 :         10 : }
      72                 :            : 
      73                 :            : 
      74                 :          5 : static void * eap_sim_init(struct eap_sm *sm)
      75                 :            : {
      76                 :            :         struct eap_sim_data *data;
      77                 :            : 
      78         [ -  + ]:          5 :         if (sm->eap_sim_db_priv == NULL) {
      79                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: eap_sim_db not configured");
      80                 :          0 :                 return NULL;
      81                 :            :         }
      82                 :            : 
      83                 :          5 :         data = os_zalloc(sizeof(*data));
      84         [ -  + ]:          5 :         if (data == NULL)
      85                 :          0 :                 return NULL;
      86                 :          5 :         data->state = START;
      87                 :            : 
      88                 :          5 :         return data;
      89                 :            : }
      90                 :            : 
      91                 :            : 
      92                 :          5 : static void eap_sim_reset(struct eap_sm *sm, void *priv)
      93                 :            : {
      94                 :          5 :         struct eap_sim_data *data = priv;
      95                 :          5 :         os_free(data->next_pseudonym);
      96                 :          5 :         os_free(data->next_reauth_id);
      97                 :          5 :         os_free(data);
      98                 :          5 : }
      99                 :            : 
     100                 :            : 
     101                 :          5 : static struct wpabuf * eap_sim_build_start(struct eap_sm *sm,
     102                 :            :                                            struct eap_sim_data *data, u8 id)
     103                 :            : {
     104                 :            :         struct eap_sim_msg *msg;
     105                 :            :         u8 ver[2];
     106                 :            : 
     107                 :          5 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Start");
     108                 :          5 :         msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
     109                 :            :                                EAP_SIM_SUBTYPE_START);
     110                 :          5 :         data->start_round++;
     111         [ +  - ]:          5 :         if (data->start_round == 1) {
     112                 :            :                 /*
     113                 :            :                  * RFC 4186, Chap. 4.2.4 recommends that identity from EAP is
     114                 :            :                  * ignored and the SIM/Start is used to request the identity.
     115                 :            :                  */
     116                 :          5 :                 wpa_printf(MSG_DEBUG, "   AT_ANY_ID_REQ");
     117                 :          5 :                 eap_sim_msg_add(msg, EAP_SIM_AT_ANY_ID_REQ, 0, NULL, 0);
     118         [ #  # ]:          0 :         } else if (data->start_round > 3) {
     119                 :            :                 /* Cannot use more than three rounds of Start messages */
     120                 :          0 :                 eap_sim_msg_free(msg);
     121                 :          0 :                 return NULL;
     122         [ #  # ]:          0 :         } else if (data->start_round == 0) {
     123                 :            :                 /*
     124                 :            :                  * This is a special case that is used to recover from
     125                 :            :                  * AT_COUNTER_TOO_SMALL during re-authentication. Since we
     126                 :            :                  * already know the identity of the peer, there is no need to
     127                 :            :                  * request any identity in this case.
     128                 :            :                  */
     129 [ #  # ][ #  # ]:          0 :         } else if (sm->identity && sm->identity_len > 0 &&
                 [ #  # ]
     130                 :          0 :                    sm->identity[0] == EAP_SIM_REAUTH_ID_PREFIX) {
     131                 :            :                 /* Reauth id may have expired - try fullauth */
     132                 :          0 :                 wpa_printf(MSG_DEBUG, "   AT_FULLAUTH_ID_REQ");
     133                 :          0 :                 eap_sim_msg_add(msg, EAP_SIM_AT_FULLAUTH_ID_REQ, 0, NULL, 0);
     134                 :            :         } else {
     135                 :          0 :                 wpa_printf(MSG_DEBUG, "   AT_PERMANENT_ID_REQ");
     136                 :          0 :                 eap_sim_msg_add(msg, EAP_SIM_AT_PERMANENT_ID_REQ, 0, NULL, 0);
     137                 :            :         }
     138                 :          5 :         wpa_printf(MSG_DEBUG, "   AT_VERSION_LIST");
     139                 :          5 :         ver[0] = 0;
     140                 :          5 :         ver[1] = EAP_SIM_VERSION;
     141                 :          5 :         eap_sim_msg_add(msg, EAP_SIM_AT_VERSION_LIST, sizeof(ver),
     142                 :            :                         ver, sizeof(ver));
     143                 :          5 :         return eap_sim_msg_finish(msg, NULL, NULL, 0);
     144                 :            : }
     145                 :            : 
     146                 :            : 
     147                 :          5 : static int eap_sim_build_encr(struct eap_sm *sm, struct eap_sim_data *data,
     148                 :            :                               struct eap_sim_msg *msg, u16 counter,
     149                 :            :                               const u8 *nonce_s)
     150                 :            : {
     151                 :          5 :         os_free(data->next_pseudonym);
     152         [ +  + ]:          5 :         if (nonce_s == NULL) {
     153                 :          4 :                 data->next_pseudonym =
     154                 :          4 :                         eap_sim_db_get_next_pseudonym(sm->eap_sim_db_priv,
     155                 :            :                                                       EAP_SIM_DB_SIM);
     156                 :            :         } else {
     157                 :            :                 /* Do not update pseudonym during re-authentication */
     158                 :          1 :                 data->next_pseudonym = NULL;
     159                 :            :         }
     160                 :          5 :         os_free(data->next_reauth_id);
     161         [ +  - ]:          5 :         if (data->counter <= EAP_SIM_MAX_FAST_REAUTHS) {
     162                 :          5 :                 data->next_reauth_id =
     163                 :          5 :                         eap_sim_db_get_next_reauth_id(sm->eap_sim_db_priv,
     164                 :            :                                                       EAP_SIM_DB_SIM);
     165                 :            :         } else {
     166                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Max fast re-authentication "
     167                 :            :                            "count exceeded - force full authentication");
     168                 :          0 :                 data->next_reauth_id = NULL;
     169                 :            :         }
     170                 :            : 
     171 [ +  + ][ -  + ]:          5 :         if (data->next_pseudonym == NULL && data->next_reauth_id == NULL &&
                 [ #  # ]
     172         [ #  # ]:          0 :             counter == 0 && nonce_s == NULL)
     173                 :          0 :                 return 0;
     174                 :            : 
     175                 :          5 :         wpa_printf(MSG_DEBUG, "   AT_IV");
     176                 :          5 :         wpa_printf(MSG_DEBUG, "   AT_ENCR_DATA");
     177                 :          5 :         eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, EAP_SIM_AT_ENCR_DATA);
     178                 :            : 
     179         [ +  + ]:          5 :         if (counter > 0) {
     180                 :          1 :                 wpa_printf(MSG_DEBUG, "   *AT_COUNTER (%u)", counter);
     181                 :          1 :                 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, counter, NULL, 0);
     182                 :            :         }
     183                 :            : 
     184         [ +  + ]:          5 :         if (nonce_s) {
     185                 :          1 :                 wpa_printf(MSG_DEBUG, "   *AT_NONCE_S");
     186                 :          1 :                 eap_sim_msg_add(msg, EAP_SIM_AT_NONCE_S, 0, nonce_s,
     187                 :            :                                 EAP_SIM_NONCE_S_LEN);
     188                 :            :         }
     189                 :            : 
     190         [ +  + ]:          5 :         if (data->next_pseudonym) {
     191                 :          4 :                 wpa_printf(MSG_DEBUG, "   *AT_NEXT_PSEUDONYM (%s)",
     192                 :            :                            data->next_pseudonym);
     193                 :          4 :                 eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_PSEUDONYM,
     194                 :          4 :                                 os_strlen(data->next_pseudonym),
     195                 :          4 :                                 (u8 *) data->next_pseudonym,
     196                 :          4 :                                 os_strlen(data->next_pseudonym));
     197                 :            :         }
     198                 :            : 
     199         [ +  - ]:          5 :         if (data->next_reauth_id) {
     200                 :          5 :                 wpa_printf(MSG_DEBUG, "   *AT_NEXT_REAUTH_ID (%s)",
     201                 :            :                            data->next_reauth_id);
     202                 :          5 :                 eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_REAUTH_ID,
     203                 :          5 :                                 os_strlen(data->next_reauth_id),
     204                 :          5 :                                 (u8 *) data->next_reauth_id,
     205                 :          5 :                                 os_strlen(data->next_reauth_id));
     206                 :            :         }
     207                 :            : 
     208         [ -  + ]:          5 :         if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) {
     209                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to encrypt "
     210                 :            :                            "AT_ENCR_DATA");
     211                 :          0 :                 return -1;
     212                 :            :         }
     213                 :            : 
     214                 :          5 :         return 0;
     215                 :            : }
     216                 :            : 
     217                 :            : 
     218                 :          4 : static struct wpabuf * eap_sim_build_challenge(struct eap_sm *sm,
     219                 :            :                                                struct eap_sim_data *data,
     220                 :            :                                                u8 id)
     221                 :            : {
     222                 :            :         struct eap_sim_msg *msg;
     223                 :            : 
     224                 :          4 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Challenge");
     225                 :          4 :         msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
     226                 :            :                                EAP_SIM_SUBTYPE_CHALLENGE);
     227                 :          4 :         wpa_printf(MSG_DEBUG, "   AT_RAND");
     228                 :          4 :         eap_sim_msg_add(msg, EAP_SIM_AT_RAND, 0, (u8 *) data->rand,
     229                 :          4 :                         data->num_chal * GSM_RAND_LEN);
     230                 :            : 
     231         [ -  + ]:          4 :         if (eap_sim_build_encr(sm, data, msg, 0, NULL)) {
     232                 :          0 :                 eap_sim_msg_free(msg);
     233                 :          0 :                 return NULL;
     234                 :            :         }
     235                 :            : 
     236         [ +  - ]:          4 :         if (sm->eap_sim_aka_result_ind) {
     237                 :          4 :                 wpa_printf(MSG_DEBUG, "   AT_RESULT_IND");
     238                 :          4 :                 eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
     239                 :            :         }
     240                 :            : 
     241                 :          4 :         wpa_printf(MSG_DEBUG, "   AT_MAC");
     242                 :          4 :         eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
     243                 :          4 :         return eap_sim_msg_finish(msg, data->k_aut, data->nonce_mt,
     244                 :            :                                   EAP_SIM_NONCE_MT_LEN);
     245                 :            : }
     246                 :            : 
     247                 :            : 
     248                 :          1 : static struct wpabuf * eap_sim_build_reauth(struct eap_sm *sm,
     249                 :            :                                             struct eap_sim_data *data, u8 id)
     250                 :            : {
     251                 :            :         struct eap_sim_msg *msg;
     252                 :            : 
     253                 :          1 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Re-authentication");
     254                 :            : 
     255         [ -  + ]:          1 :         if (random_get_bytes(data->nonce_s, EAP_SIM_NONCE_S_LEN))
     256                 :          0 :                 return NULL;
     257                 :          1 :         wpa_hexdump_key(MSG_MSGDUMP, "EAP-SIM: NONCE_S",
     258                 :          1 :                         data->nonce_s, EAP_SIM_NONCE_S_LEN);
     259                 :            : 
     260                 :          1 :         eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
     261                 :          1 :                             data->emsk);
     262                 :          1 :         eap_sim_derive_keys_reauth(data->counter, sm->identity,
     263                 :          1 :                                    sm->identity_len, data->nonce_s, data->mk,
     264                 :          1 :                                    data->msk, data->emsk);
     265                 :            : 
     266                 :          1 :         msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
     267                 :            :                                EAP_SIM_SUBTYPE_REAUTHENTICATION);
     268                 :            : 
     269         [ -  + ]:          1 :         if (eap_sim_build_encr(sm, data, msg, data->counter, data->nonce_s)) {
     270                 :          0 :                 eap_sim_msg_free(msg);
     271                 :          0 :                 return NULL;
     272                 :            :         }
     273                 :            : 
     274         [ +  - ]:          1 :         if (sm->eap_sim_aka_result_ind) {
     275                 :          1 :                 wpa_printf(MSG_DEBUG, "   AT_RESULT_IND");
     276                 :          1 :                 eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
     277                 :            :         }
     278                 :            : 
     279                 :          1 :         wpa_printf(MSG_DEBUG, "   AT_MAC");
     280                 :          1 :         eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
     281                 :          1 :         return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
     282                 :            : }
     283                 :            : 
     284                 :            : 
     285                 :          0 : static struct wpabuf * eap_sim_build_notification(struct eap_sm *sm,
     286                 :            :                                                   struct eap_sim_data *data,
     287                 :            :                                                   u8 id)
     288                 :            : {
     289                 :            :         struct eap_sim_msg *msg;
     290                 :            : 
     291                 :          0 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Notification");
     292                 :          0 :         msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
     293                 :            :                                EAP_SIM_SUBTYPE_NOTIFICATION);
     294                 :          0 :         wpa_printf(MSG_DEBUG, "   AT_NOTIFICATION (%d)", data->notification);
     295                 :          0 :         eap_sim_msg_add(msg, EAP_SIM_AT_NOTIFICATION, data->notification,
     296                 :            :                         NULL, 0);
     297         [ #  # ]:          0 :         if (data->use_result_ind) {
     298         [ #  # ]:          0 :                 if (data->reauth) {
     299                 :          0 :                         wpa_printf(MSG_DEBUG, "   AT_IV");
     300                 :          0 :                         wpa_printf(MSG_DEBUG, "   AT_ENCR_DATA");
     301                 :          0 :                         eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV,
     302                 :            :                                                    EAP_SIM_AT_ENCR_DATA);
     303                 :          0 :                         wpa_printf(MSG_DEBUG, "   *AT_COUNTER (%u)",
     304                 :          0 :                                    data->counter);
     305                 :          0 :                         eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter,
     306                 :            :                                         NULL, 0);
     307                 :            : 
     308         [ #  # ]:          0 :                         if (eap_sim_msg_add_encr_end(msg, data->k_encr,
     309                 :            :                                                      EAP_SIM_AT_PADDING)) {
     310                 :          0 :                                 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to "
     311                 :            :                                            "encrypt AT_ENCR_DATA");
     312                 :          0 :                                 eap_sim_msg_free(msg);
     313                 :          0 :                                 return NULL;
     314                 :            :                         }
     315                 :            :                 }
     316                 :            : 
     317                 :          0 :                 wpa_printf(MSG_DEBUG, "   AT_MAC");
     318                 :          0 :                 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
     319                 :            :         }
     320                 :          0 :         return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
     321                 :            : }
     322                 :            : 
     323                 :            : 
     324                 :         10 : static struct wpabuf * eap_sim_buildReq(struct eap_sm *sm, void *priv, u8 id)
     325                 :            : {
     326                 :         10 :         struct eap_sim_data *data = priv;
     327                 :            : 
     328   [ +  +  +  -  :         10 :         switch (data->state) {
                      - ]
     329                 :            :         case START:
     330                 :          5 :                 return eap_sim_build_start(sm, data, id);
     331                 :            :         case CHALLENGE:
     332                 :          4 :                 return eap_sim_build_challenge(sm, data, id);
     333                 :            :         case REAUTH:
     334                 :          1 :                 return eap_sim_build_reauth(sm, data, id);
     335                 :            :         case NOTIFICATION:
     336                 :          0 :                 return eap_sim_build_notification(sm, data, id);
     337                 :            :         default:
     338                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in "
     339                 :          0 :                            "buildReq", data->state);
     340                 :          0 :                 break;
     341                 :            :         }
     342                 :         10 :         return NULL;
     343                 :            : }
     344                 :            : 
     345                 :            : 
     346                 :         10 : static Boolean eap_sim_check(struct eap_sm *sm, void *priv,
     347                 :            :                              struct wpabuf *respData)
     348                 :            : {
     349                 :            :         const u8 *pos;
     350                 :            :         size_t len;
     351                 :            : 
     352                 :         10 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len);
     353 [ +  - ][ -  + ]:         10 :         if (pos == NULL || len < 3) {
     354                 :          0 :                 wpa_printf(MSG_INFO, "EAP-SIM: Invalid frame");
     355                 :          0 :                 return TRUE;
     356                 :            :         }
     357                 :            : 
     358                 :         10 :         return FALSE;
     359                 :            : }
     360                 :            : 
     361                 :            : 
     362                 :         14 : static Boolean eap_sim_unexpected_subtype(struct eap_sim_data *data,
     363                 :            :                                           u8 subtype)
     364                 :            : {
     365         [ -  + ]:         14 :         if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR)
     366                 :          0 :                 return FALSE;
     367                 :            : 
     368   [ +  +  +  -  :         14 :         switch (data->state) {
                      - ]
     369                 :            :         case START:
     370         [ -  + ]:          9 :                 if (subtype != EAP_SIM_SUBTYPE_START) {
     371                 :          0 :                         wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
     372                 :            :                                    "subtype %d", subtype);
     373                 :          0 :                         return TRUE;
     374                 :            :                 }
     375                 :          9 :                 break;
     376                 :            :         case CHALLENGE:
     377         [ -  + ]:          4 :                 if (subtype != EAP_SIM_SUBTYPE_CHALLENGE) {
     378                 :          0 :                         wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
     379                 :            :                                    "subtype %d", subtype);
     380                 :          0 :                         return TRUE;
     381                 :            :                 }
     382                 :          4 :                 break;
     383                 :            :         case REAUTH:
     384         [ -  + ]:          1 :                 if (subtype != EAP_SIM_SUBTYPE_REAUTHENTICATION) {
     385                 :          0 :                         wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
     386                 :            :                                    "subtype %d", subtype);
     387                 :          0 :                         return TRUE;
     388                 :            :                 }
     389                 :          1 :                 break;
     390                 :            :         case NOTIFICATION:
     391         [ #  # ]:          0 :                 if (subtype != EAP_SIM_SUBTYPE_NOTIFICATION) {
     392                 :          0 :                         wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
     393                 :            :                                    "subtype %d", subtype);
     394                 :          0 :                         return TRUE;
     395                 :            :                 }
     396                 :          0 :                 break;
     397                 :            :         default:
     398                 :          0 :                 wpa_printf(MSG_INFO, "EAP-SIM: Unexpected state (%d) for "
     399                 :          0 :                            "processing a response", data->state);
     400                 :          0 :                 return TRUE;
     401                 :            :         }
     402                 :            : 
     403                 :         14 :         return FALSE;
     404                 :            : }
     405                 :            : 
     406                 :            : 
     407                 :          8 : static int eap_sim_supported_ver(struct eap_sim_data *data, int version)
     408                 :            : {
     409                 :          8 :         return version == EAP_SIM_VERSION;
     410                 :            : }
     411                 :            : 
     412                 :            : 
     413                 :          9 : static void eap_sim_process_start(struct eap_sm *sm,
     414                 :            :                                   struct eap_sim_data *data,
     415                 :            :                                   struct wpabuf *respData,
     416                 :            :                                   struct eap_sim_attrs *attr)
     417                 :            : {
     418                 :            :         size_t identity_len;
     419                 :            :         u8 ver_list[2];
     420                 :            :         u8 *new_identity;
     421                 :            :         char *username;
     422                 :            : 
     423                 :          9 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Receive start response");
     424                 :            : 
     425         [ -  + ]:          9 :         if (data->start_round == 0) {
     426                 :            :                 /*
     427                 :            :                  * Special case for AT_COUNTER_TOO_SMALL recovery - no identity
     428                 :            :                  * was requested since we already know it.
     429                 :            :                  */
     430                 :          0 :                 goto skip_id_update;
     431                 :            :         }
     432                 :            : 
     433                 :            :         /*
     434                 :            :          * We always request identity in SIM/Start, so the peer is required to
     435                 :            :          * have replied with one.
     436                 :            :          */
     437 [ +  - ][ -  + ]:          9 :         if (!attr->identity || attr->identity_len == 0) {
     438                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Peer did not provide any "
     439                 :            :                            "identity");
     440                 :          0 :                 goto failed;
     441                 :            :         }
     442                 :            : 
     443                 :          9 :         new_identity = os_malloc(attr->identity_len);
     444         [ -  + ]:          9 :         if (new_identity == NULL)
     445                 :          0 :                 goto failed;
     446                 :          9 :         os_free(sm->identity);
     447                 :          9 :         sm->identity = new_identity;
     448                 :          9 :         os_memcpy(sm->identity, attr->identity, attr->identity_len);
     449                 :          9 :         sm->identity_len = attr->identity_len;
     450                 :            : 
     451                 :          9 :         wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity",
     452                 :          9 :                           sm->identity, sm->identity_len);
     453                 :          9 :         username = sim_get_username(sm->identity, sm->identity_len);
     454         [ -  + ]:          9 :         if (username == NULL)
     455                 :          0 :                 goto failed;
     456                 :            : 
     457         [ +  + ]:          9 :         if (username[0] == EAP_SIM_REAUTH_ID_PREFIX) {
     458                 :          1 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Reauth username '%s'",
     459                 :            :                            username);
     460                 :          1 :                 data->reauth = eap_sim_db_get_reauth_entry(
     461                 :            :                         sm->eap_sim_db_priv, username);
     462                 :          1 :                 os_free(username);
     463         [ -  + ]:          1 :                 if (data->reauth == NULL) {
     464                 :          0 :                         wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown reauth "
     465                 :            :                                    "identity - request full auth identity");
     466                 :            :                         /* Remain in START state for another round */
     467                 :          0 :                         return;
     468                 :            :                 }
     469                 :          1 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Using fast re-authentication");
     470                 :          1 :                 os_strlcpy(data->permanent, data->reauth->permanent,
     471                 :            :                            sizeof(data->permanent));
     472                 :          1 :                 data->counter = data->reauth->counter;
     473                 :          1 :                 os_memcpy(data->mk, data->reauth->mk, EAP_SIM_MK_LEN);
     474                 :          1 :                 eap_sim_state(data, REAUTH);
     475                 :          1 :                 return;
     476                 :            :         }
     477                 :            : 
     478         [ -  + ]:          8 :         if (username[0] == EAP_SIM_PSEUDONYM_PREFIX) {
     479                 :            :                 const char *permanent;
     480                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Pseudonym username '%s'",
     481                 :            :                            username);
     482                 :          0 :                 permanent = eap_sim_db_get_permanent(
     483                 :            :                         sm->eap_sim_db_priv, username);
     484                 :          0 :                 os_free(username);
     485         [ #  # ]:          0 :                 if (permanent == NULL) {
     486                 :          0 :                         wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown pseudonym "
     487                 :            :                                    "identity - request permanent identity");
     488                 :            :                         /* Remain in START state for another round */
     489                 :          0 :                         return;
     490                 :            :                 }
     491                 :          0 :                 os_strlcpy(data->permanent, permanent,
     492                 :            :                            sizeof(data->permanent));
     493         [ +  - ]:          8 :         } else if (username[0] == EAP_SIM_PERMANENT_PREFIX) {
     494                 :          8 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Permanent username '%s'",
     495                 :            :                            username);
     496                 :          8 :                 os_strlcpy(data->permanent, username, sizeof(data->permanent));
     497                 :          8 :                 os_free(username);
     498                 :            :         } else {
     499                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Unrecognized username '%s'",
     500                 :            :                            username);
     501                 :          0 :                 os_free(username);
     502                 :          0 :                 goto failed;
     503                 :            :         }
     504                 :            : 
     505                 :            : skip_id_update:
     506                 :            :         /* Full authentication */
     507                 :            : 
     508 [ +  - ][ -  + ]:          8 :         if (attr->nonce_mt == NULL || attr->selected_version < 0) {
     509                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Start/Response missing "
     510                 :            :                            "required attributes");
     511                 :          0 :                 goto failed;
     512                 :            :         }
     513                 :            : 
     514         [ -  + ]:          8 :         if (!eap_sim_supported_ver(data, attr->selected_version)) {
     515                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Peer selected unsupported "
     516                 :            :                            "version %d", attr->selected_version);
     517                 :          0 :                 goto failed;
     518                 :            :         }
     519                 :            : 
     520                 :          8 :         data->counter = 0; /* reset re-auth counter since this is full auth */
     521                 :          8 :         data->reauth = NULL;
     522                 :            : 
     523                 :          8 :         data->num_chal = eap_sim_db_get_gsm_triplets(
     524                 :          8 :                 sm->eap_sim_db_priv, data->permanent, EAP_SIM_MAX_CHAL,
     525                 :          8 :                 (u8 *) data->rand, (u8 *) data->kc, (u8 *) data->sres, sm);
     526         [ +  + ]:          8 :         if (data->num_chal == EAP_SIM_DB_PENDING) {
     527                 :          4 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: GSM authentication triplets "
     528                 :            :                            "not yet available - pending request");
     529                 :          4 :                 sm->method_pending = METHOD_PENDING_WAIT;
     530                 :          4 :                 return;
     531                 :            :         }
     532         [ -  + ]:          4 :         if (data->num_chal < 2) {
     533                 :          0 :                 wpa_printf(MSG_INFO, "EAP-SIM: Failed to get GSM "
     534                 :            :                            "authentication triplets for the peer");
     535                 :          0 :                 goto failed;
     536                 :            :         }
     537                 :            : 
     538                 :          4 :         identity_len = sm->identity_len;
     539 [ +  - ][ -  + ]:          4 :         while (identity_len > 0 && sm->identity[identity_len - 1] == '\0') {
     540                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Workaround - drop last null "
     541                 :            :                            "character from identity");
     542                 :          0 :                 identity_len--;
     543                 :            :         }
     544                 :          4 :         wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity for MK derivation",
     545                 :          4 :                           sm->identity, identity_len);
     546                 :            : 
     547                 :          4 :         os_memcpy(data->nonce_mt, attr->nonce_mt, EAP_SIM_NONCE_MT_LEN);
     548                 :          4 :         WPA_PUT_BE16(ver_list, EAP_SIM_VERSION);
     549                 :          4 :         eap_sim_derive_mk(sm->identity, identity_len, attr->nonce_mt,
     550                 :          4 :                           attr->selected_version, ver_list, sizeof(ver_list),
     551                 :          4 :                           data->num_chal, (const u8 *) data->kc, data->mk);
     552                 :          4 :         eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
     553                 :          4 :                             data->emsk);
     554                 :            : 
     555                 :          4 :         eap_sim_state(data, CHALLENGE);
     556                 :          4 :         return;
     557                 :            : 
     558                 :            : failed:
     559                 :          0 :         data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
     560                 :          9 :         eap_sim_state(data, NOTIFICATION);
     561                 :            : }
     562                 :            : 
     563                 :            : 
     564                 :          4 : static void eap_sim_process_challenge(struct eap_sm *sm,
     565                 :            :                                       struct eap_sim_data *data,
     566                 :            :                                       struct wpabuf *respData,
     567                 :            :                                       struct eap_sim_attrs *attr)
     568                 :            : {
     569   [ +  -  -  + ]:          8 :         if (attr->mac == NULL ||
     570                 :          4 :             eap_sim_verify_mac(data->k_aut, respData, attr->mac,
     571                 :          4 :                                (u8 *) data->sres,
     572                 :          4 :                                data->num_chal * EAP_SIM_SRES_LEN)) {
     573                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: Challenge message "
     574                 :            :                            "did not include valid AT_MAC");
     575                 :          0 :                 data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
     576                 :          0 :                 eap_sim_state(data, NOTIFICATION);
     577                 :          4 :                 return;
     578                 :            :         }
     579                 :            : 
     580                 :          4 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Challenge response includes the "
     581                 :            :                    "correct AT_MAC");
     582 [ +  - ][ -  + ]:          4 :         if (sm->eap_sim_aka_result_ind && attr->result_ind) {
     583                 :          0 :                 data->use_result_ind = 1;
     584                 :          0 :                 data->notification = EAP_SIM_SUCCESS;
     585                 :          0 :                 eap_sim_state(data, NOTIFICATION);
     586                 :            :         } else
     587                 :          4 :                 eap_sim_state(data, SUCCESS);
     588                 :            : 
     589         [ +  - ]:          4 :         if (data->next_pseudonym) {
     590                 :          4 :                 eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, data->permanent,
     591                 :            :                                          data->next_pseudonym);
     592                 :          4 :                 data->next_pseudonym = NULL;
     593                 :            :         }
     594         [ +  - ]:          4 :         if (data->next_reauth_id) {
     595                 :          4 :                 eap_sim_db_add_reauth(sm->eap_sim_db_priv, data->permanent,
     596                 :          4 :                                       data->next_reauth_id, data->counter + 1,
     597                 :          4 :                                       data->mk);
     598                 :          4 :                 data->next_reauth_id = NULL;
     599                 :            :         }
     600                 :            : }
     601                 :            : 
     602                 :            : 
     603                 :          1 : static void eap_sim_process_reauth(struct eap_sm *sm,
     604                 :            :                                    struct eap_sim_data *data,
     605                 :            :                                    struct wpabuf *respData,
     606                 :            :                                    struct eap_sim_attrs *attr)
     607                 :            : {
     608                 :            :         struct eap_sim_attrs eattr;
     609                 :          1 :         u8 *decrypted = NULL;
     610                 :            : 
     611   [ +  -  -  + ]:          2 :         if (attr->mac == NULL ||
     612                 :          1 :             eap_sim_verify_mac(data->k_aut, respData, attr->mac, data->nonce_s,
     613                 :            :                                EAP_SIM_NONCE_S_LEN)) {
     614                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message "
     615                 :            :                            "did not include valid AT_MAC");
     616                 :          0 :                 goto fail;
     617                 :            :         }
     618                 :            : 
     619 [ +  - ][ -  + ]:          1 :         if (attr->encr_data == NULL || attr->iv == NULL) {
     620                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: Reauthentication "
     621                 :            :                            "message did not include encrypted data");
     622                 :          0 :                 goto fail;
     623                 :            :         }
     624                 :            : 
     625                 :          1 :         decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
     626                 :            :                                        attr->encr_data_len, attr->iv, &eattr,
     627                 :            :                                        0);
     628         [ -  + ]:          1 :         if (decrypted == NULL) {
     629                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to parse encrypted "
     630                 :            :                            "data from reauthentication message");
     631                 :          0 :                 goto fail;
     632                 :            :         }
     633                 :            : 
     634         [ -  + ]:          1 :         if (eattr.counter != data->counter) {
     635                 :          0 :                 wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message "
     636                 :            :                            "used incorrect counter %u, expected %u",
     637                 :          0 :                            eattr.counter, data->counter);
     638                 :          0 :                 goto fail;
     639                 :            :         }
     640                 :          1 :         os_free(decrypted);
     641                 :          1 :         decrypted = NULL;
     642                 :            : 
     643                 :          1 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Re-authentication response includes "
     644                 :            :                    "the correct AT_MAC");
     645                 :            : 
     646         [ -  + ]:          1 :         if (eattr.counter_too_small) {
     647                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-AKA: Re-authentication response "
     648                 :            :                            "included AT_COUNTER_TOO_SMALL - starting full "
     649                 :            :                            "authentication");
     650                 :          0 :                 data->start_round = -1;
     651                 :          0 :                 eap_sim_state(data, START);
     652                 :          0 :                 return;
     653                 :            :         }
     654                 :            : 
     655 [ +  - ][ -  + ]:          1 :         if (sm->eap_sim_aka_result_ind && attr->result_ind) {
     656                 :          0 :                 data->use_result_ind = 1;
     657                 :          0 :                 data->notification = EAP_SIM_SUCCESS;
     658                 :          0 :                 eap_sim_state(data, NOTIFICATION);
     659                 :            :         } else
     660                 :          1 :                 eap_sim_state(data, SUCCESS);
     661                 :            : 
     662         [ +  - ]:          1 :         if (data->next_reauth_id) {
     663                 :          1 :                 eap_sim_db_add_reauth(sm->eap_sim_db_priv, data->permanent,
     664                 :            :                                       data->next_reauth_id,
     665                 :          1 :                                       data->counter + 1, data->mk);
     666                 :          1 :                 data->next_reauth_id = NULL;
     667                 :            :         } else {
     668                 :          0 :                 eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
     669                 :          0 :                 data->reauth = NULL;
     670                 :            :         }
     671                 :            : 
     672                 :          1 :         return;
     673                 :            : 
     674                 :            : fail:
     675                 :          0 :         data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
     676                 :          0 :         eap_sim_state(data, NOTIFICATION);
     677                 :          0 :         eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
     678                 :          0 :         data->reauth = NULL;
     679                 :          1 :         os_free(decrypted);
     680                 :            : }
     681                 :            : 
     682                 :            : 
     683                 :          0 : static void eap_sim_process_client_error(struct eap_sm *sm,
     684                 :            :                                          struct eap_sim_data *data,
     685                 :            :                                          struct wpabuf *respData,
     686                 :            :                                          struct eap_sim_attrs *attr)
     687                 :            : {
     688                 :          0 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Client reported error %d",
     689                 :            :                    attr->client_error_code);
     690 [ #  # ][ #  # ]:          0 :         if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
     691                 :          0 :                 eap_sim_state(data, SUCCESS);
     692                 :            :         else
     693                 :          0 :                 eap_sim_state(data, FAILURE);
     694                 :          0 : }
     695                 :            : 
     696                 :            : 
     697                 :          0 : static void eap_sim_process_notification(struct eap_sm *sm,
     698                 :            :                                          struct eap_sim_data *data,
     699                 :            :                                          struct wpabuf *respData,
     700                 :            :                                          struct eap_sim_attrs *attr)
     701                 :            : {
     702                 :          0 :         wpa_printf(MSG_DEBUG, "EAP-SIM: Client replied to notification");
     703 [ #  # ][ #  # ]:          0 :         if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
     704                 :          0 :                 eap_sim_state(data, SUCCESS);
     705                 :            :         else
     706                 :          0 :                 eap_sim_state(data, FAILURE);
     707                 :          0 : }
     708                 :            : 
     709                 :            : 
     710                 :         14 : static void eap_sim_process(struct eap_sm *sm, void *priv,
     711                 :            :                             struct wpabuf *respData)
     712                 :            : {
     713                 :         14 :         struct eap_sim_data *data = priv;
     714                 :            :         const u8 *pos, *end;
     715                 :            :         u8 subtype;
     716                 :            :         size_t len;
     717                 :            :         struct eap_sim_attrs attr;
     718                 :            : 
     719                 :         14 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len);
     720 [ +  - ][ -  + ]:         14 :         if (pos == NULL || len < 3)
     721                 :          0 :                 return;
     722                 :            : 
     723                 :         14 :         end = pos + len;
     724                 :         14 :         subtype = *pos;
     725                 :         14 :         pos += 3;
     726                 :            : 
     727         [ -  + ]:         14 :         if (eap_sim_unexpected_subtype(data, subtype)) {
     728                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Unrecognized or unexpected "
     729                 :            :                            "EAP-SIM Subtype in EAP Response");
     730                 :          0 :                 data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
     731                 :          0 :                 eap_sim_state(data, NOTIFICATION);
     732                 :          0 :                 return;
     733                 :            :         }
     734                 :            : 
     735         [ -  + ]:         14 :         if (eap_sim_parse_attr(pos, end, &attr, 0, 0)) {
     736                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Failed to parse attributes");
     737 [ #  # ][ #  # ]:          0 :                 if (subtype != EAP_SIM_SUBTYPE_CLIENT_ERROR &&
     738 [ #  # ][ #  # ]:          0 :                     (data->state == START || data->state == CHALLENGE ||
     739                 :          0 :                      data->state == REAUTH)) {
     740                 :          0 :                         data->notification =
     741                 :            :                                 EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
     742                 :          0 :                         eap_sim_state(data, NOTIFICATION);
     743                 :          0 :                         return;
     744                 :            :                 }
     745                 :          0 :                 eap_sim_state(data, FAILURE);
     746                 :          0 :                 return;
     747                 :            :         }
     748                 :            : 
     749         [ -  + ]:         14 :         if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR) {
     750                 :          0 :                 eap_sim_process_client_error(sm, data, respData, &attr);
     751                 :          0 :                 return;
     752                 :            :         }
     753                 :            : 
     754   [ +  +  +  -  :         14 :         switch (data->state) {
                      - ]
     755                 :            :         case START:
     756                 :          9 :                 eap_sim_process_start(sm, data, respData, &attr);
     757                 :          9 :                 break;
     758                 :            :         case CHALLENGE:
     759                 :          4 :                 eap_sim_process_challenge(sm, data, respData, &attr);
     760                 :          4 :                 break;
     761                 :            :         case REAUTH:
     762                 :          1 :                 eap_sim_process_reauth(sm, data, respData, &attr);
     763                 :          1 :                 break;
     764                 :            :         case NOTIFICATION:
     765                 :          0 :                 eap_sim_process_notification(sm, data, respData, &attr);
     766                 :          0 :                 break;
     767                 :            :         default:
     768                 :          0 :                 wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in "
     769                 :          0 :                            "process", data->state);
     770                 :         14 :                 break;
     771                 :            :         }
     772                 :            : }
     773                 :            : 
     774                 :            : 
     775                 :         14 : static Boolean eap_sim_isDone(struct eap_sm *sm, void *priv)
     776                 :            : {
     777                 :         14 :         struct eap_sim_data *data = priv;
     778 [ +  + ][ -  + ]:         14 :         return data->state == SUCCESS || data->state == FAILURE;
     779                 :            : }
     780                 :            : 
     781                 :            : 
     782                 :          5 : static u8 * eap_sim_getKey(struct eap_sm *sm, void *priv, size_t *len)
     783                 :            : {
     784                 :          5 :         struct eap_sim_data *data = priv;
     785                 :            :         u8 *key;
     786                 :            : 
     787         [ -  + ]:          5 :         if (data->state != SUCCESS)
     788                 :          0 :                 return NULL;
     789                 :            : 
     790                 :          5 :         key = os_malloc(EAP_SIM_KEYING_DATA_LEN);
     791         [ -  + ]:          5 :         if (key == NULL)
     792                 :          0 :                 return NULL;
     793                 :          5 :         os_memcpy(key, data->msk, EAP_SIM_KEYING_DATA_LEN);
     794                 :          5 :         *len = EAP_SIM_KEYING_DATA_LEN;
     795                 :          5 :         return key;
     796                 :            : }
     797                 :            : 
     798                 :            : 
     799                 :          0 : static u8 * eap_sim_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
     800                 :            : {
     801                 :          0 :         struct eap_sim_data *data = priv;
     802                 :            :         u8 *key;
     803                 :            : 
     804         [ #  # ]:          0 :         if (data->state != SUCCESS)
     805                 :          0 :                 return NULL;
     806                 :            : 
     807                 :          0 :         key = os_malloc(EAP_EMSK_LEN);
     808         [ #  # ]:          0 :         if (key == NULL)
     809                 :          0 :                 return NULL;
     810                 :          0 :         os_memcpy(key, data->emsk, EAP_EMSK_LEN);
     811                 :          0 :         *len = EAP_EMSK_LEN;
     812                 :          0 :         return key;
     813                 :            : }
     814                 :            : 
     815                 :            : 
     816                 :          5 : static Boolean eap_sim_isSuccess(struct eap_sm *sm, void *priv)
     817                 :            : {
     818                 :          5 :         struct eap_sim_data *data = priv;
     819                 :          5 :         return data->state == SUCCESS;
     820                 :            : }
     821                 :            : 
     822                 :            : 
     823                 :          1 : int eap_server_sim_register(void)
     824                 :            : {
     825                 :            :         struct eap_method *eap;
     826                 :            :         int ret;
     827                 :            : 
     828                 :          1 :         eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
     829                 :            :                                       EAP_VENDOR_IETF, EAP_TYPE_SIM, "SIM");
     830         [ -  + ]:          1 :         if (eap == NULL)
     831                 :          0 :                 return -1;
     832                 :            : 
     833                 :          1 :         eap->init = eap_sim_init;
     834                 :          1 :         eap->reset = eap_sim_reset;
     835                 :          1 :         eap->buildReq = eap_sim_buildReq;
     836                 :          1 :         eap->check = eap_sim_check;
     837                 :          1 :         eap->process = eap_sim_process;
     838                 :          1 :         eap->isDone = eap_sim_isDone;
     839                 :          1 :         eap->getKey = eap_sim_getKey;
     840                 :          1 :         eap->isSuccess = eap_sim_isSuccess;
     841                 :          1 :         eap->get_emsk = eap_sim_get_emsk;
     842                 :            : 
     843                 :          1 :         ret = eap_server_method_register(eap);
     844         [ -  + ]:          1 :         if (ret)
     845                 :          0 :                 eap_server_method_free(eap);
     846                 :          1 :         return ret;
     847                 :            : }

Generated by: LCOV version 1.9