LCOV - code coverage report
Current view: top level - src/eap_peer - eap_sake.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1422976643 Lines: 241 267 90.3 %
Date: 2015-02-03 Functions: 14 14 100.0 %

          Line data    Source code
       1             : /*
       2             :  * EAP peer method: EAP-SAKE (RFC 4763)
       3             :  * Copyright (c) 2006-2008, Jouni Malinen <j@w1.fi>
       4             :  *
       5             :  * This software may be distributed under the terms of the BSD license.
       6             :  * See README for more details.
       7             :  */
       8             : 
       9             : #include "includes.h"
      10             : 
      11             : #include "common.h"
      12             : #include "crypto/random.h"
      13             : #include "eap_peer/eap_i.h"
      14             : #include "eap_common/eap_sake_common.h"
      15             : 
      16             : struct eap_sake_data {
      17             :         enum { IDENTITY, CHALLENGE, CONFIRM, SUCCESS, FAILURE } state;
      18             :         u8 root_secret_a[EAP_SAKE_ROOT_SECRET_LEN];
      19             :         u8 root_secret_b[EAP_SAKE_ROOT_SECRET_LEN];
      20             :         u8 rand_s[EAP_SAKE_RAND_LEN];
      21             :         u8 rand_p[EAP_SAKE_RAND_LEN];
      22             :         struct {
      23             :                 u8 auth[EAP_SAKE_TEK_AUTH_LEN];
      24             :                 u8 cipher[EAP_SAKE_TEK_CIPHER_LEN];
      25             :         } tek;
      26             :         u8 msk[EAP_MSK_LEN];
      27             :         u8 emsk[EAP_EMSK_LEN];
      28             :         u8 session_id;
      29             :         int session_id_set;
      30             :         u8 *peerid;
      31             :         size_t peerid_len;
      32             :         u8 *serverid;
      33             :         size_t serverid_len;
      34             : };
      35             : 
      36             : 
      37          50 : static const char * eap_sake_state_txt(int state)
      38             : {
      39          50 :         switch (state) {
      40             :         case IDENTITY:
      41          12 :                 return "IDENTITY";
      42             :         case CHALLENGE:
      43          21 :                 return "CHALLENGE";
      44             :         case CONFIRM:
      45          13 :                 return "CONFIRM";
      46             :         case SUCCESS:
      47           3 :                 return "SUCCESS";
      48             :         case FAILURE:
      49           1 :                 return "FAILURE";
      50             :         default:
      51           0 :                 return "?";
      52             :         }
      53             : }
      54             : 
      55             : 
      56          25 : static void eap_sake_state(struct eap_sake_data *data, int state)
      57             : {
      58          50 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: %s -> %s",
      59          25 :                    eap_sake_state_txt(data->state),
      60             :                    eap_sake_state_txt(state));
      61          25 :         data->state = state;
      62          25 : }
      63             : 
      64             : 
      65             : static void eap_sake_deinit(struct eap_sm *sm, void *priv);
      66             : 
      67             : 
      68          28 : static void * eap_sake_init(struct eap_sm *sm)
      69             : {
      70             :         struct eap_sake_data *data;
      71             :         const u8 *identity, *password;
      72             :         size_t identity_len, password_len;
      73             : 
      74          28 :         password = eap_get_config_password(sm, &password_len);
      75          28 :         if (!password || password_len != 2 * EAP_SAKE_ROOT_SECRET_LEN) {
      76          10 :                 wpa_printf(MSG_INFO, "EAP-SAKE: No key of correct length "
      77             :                            "configured");
      78          10 :                 return NULL;
      79             :         }
      80             : 
      81          18 :         data = os_zalloc(sizeof(*data));
      82          18 :         if (data == NULL)
      83           0 :                 return NULL;
      84          18 :         data->state = IDENTITY;
      85             : 
      86          18 :         identity = eap_get_config_identity(sm, &identity_len);
      87          18 :         if (identity) {
      88          18 :                 data->peerid = os_malloc(identity_len);
      89          18 :                 if (data->peerid == NULL) {
      90           0 :                         eap_sake_deinit(sm, data);
      91           0 :                         return NULL;
      92             :                 }
      93          18 :                 os_memcpy(data->peerid, identity, identity_len);
      94          18 :                 data->peerid_len = identity_len;
      95             :         }
      96             : 
      97          18 :         os_memcpy(data->root_secret_a, password, EAP_SAKE_ROOT_SECRET_LEN);
      98          18 :         os_memcpy(data->root_secret_b,
      99             :                   password + EAP_SAKE_ROOT_SECRET_LEN,
     100             :                   EAP_SAKE_ROOT_SECRET_LEN);
     101             : 
     102          18 :         return data;
     103             : }
     104             : 
     105             : 
     106          18 : static void eap_sake_deinit(struct eap_sm *sm, void *priv)
     107             : {
     108          18 :         struct eap_sake_data *data = priv;
     109          18 :         os_free(data->serverid);
     110          18 :         os_free(data->peerid);
     111          18 :         bin_clear_free(data, sizeof(*data));
     112          18 : }
     113             : 
     114             : 
     115          14 : static struct wpabuf * eap_sake_build_msg(struct eap_sake_data *data,
     116             :                                           int id, size_t length, u8 subtype)
     117             : {
     118             :         struct eap_sake_hdr *sake;
     119             :         struct wpabuf *msg;
     120             :         size_t plen;
     121             : 
     122          14 :         plen = length + sizeof(struct eap_sake_hdr);
     123             : 
     124          14 :         msg = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_SAKE, plen,
     125             :                             EAP_CODE_RESPONSE, id);
     126          14 :         if (msg == NULL) {
     127           0 :                 wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to allocate memory "
     128             :                            "request");
     129           0 :                 return NULL;
     130             :         }
     131             : 
     132          14 :         sake = wpabuf_put(msg, sizeof(*sake));
     133          14 :         sake->version = EAP_SAKE_VERSION;
     134          14 :         sake->session_id = data->session_id;
     135          14 :         sake->subtype = subtype;
     136             : 
     137          14 :         return msg;
     138             : }
     139             : 
     140             : 
     141           5 : static struct wpabuf * eap_sake_process_identity(struct eap_sm *sm,
     142             :                                                  struct eap_sake_data *data,
     143             :                                                  struct eap_method_ret *ret,
     144             :                                                  const struct wpabuf *reqData,
     145             :                                                  const u8 *payload,
     146             :                                                  size_t payload_len)
     147             : {
     148             :         struct eap_sake_parse_attr attr;
     149             :         struct wpabuf *resp;
     150             : 
     151           5 :         if (data->state != IDENTITY) {
     152           1 :                 ret->ignore = TRUE;
     153           1 :                 return NULL;
     154             :         }
     155             : 
     156           4 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Request/Identity");
     157             : 
     158           4 :         if (eap_sake_parse_attributes(payload, payload_len, &attr))
     159           2 :                 return NULL;
     160             : 
     161           2 :         if (!attr.perm_id_req && !attr.any_id_req) {
     162           1 :                 wpa_printf(MSG_INFO, "EAP-SAKE: No AT_PERM_ID_REQ or "
     163             :                            "AT_ANY_ID_REQ in Request/Identity");
     164           1 :                 return NULL;
     165             :         }
     166             : 
     167           1 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Sending Response/Identity");
     168             : 
     169           1 :         resp = eap_sake_build_msg(data, eap_get_id(reqData),
     170           1 :                                   2 + data->peerid_len,
     171             :                                   EAP_SAKE_SUBTYPE_IDENTITY);
     172           1 :         if (resp == NULL)
     173           0 :                 return NULL;
     174             : 
     175           1 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_PEERID");
     176           2 :         eap_sake_add_attr(resp, EAP_SAKE_AT_PEERID,
     177           1 :                           data->peerid, data->peerid_len);
     178             : 
     179           1 :         eap_sake_state(data, CHALLENGE);
     180             : 
     181           1 :         return resp;
     182             : }
     183             : 
     184             : 
     185          12 : static struct wpabuf * eap_sake_process_challenge(struct eap_sm *sm,
     186             :                                                   struct eap_sake_data *data,
     187             :                                                   struct eap_method_ret *ret,
     188             :                                                   const struct wpabuf *reqData,
     189             :                                                   const u8 *payload,
     190             :                                                   size_t payload_len)
     191             : {
     192             :         struct eap_sake_parse_attr attr;
     193             :         struct wpabuf *resp;
     194             :         u8 *rpos;
     195             :         size_t rlen;
     196             : 
     197          12 :         if (data->state != IDENTITY && data->state != CHALLENGE) {
     198           1 :                 wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Challenge received "
     199           1 :                            "in unexpected state (%d)", data->state);
     200           1 :                 ret->ignore = TRUE;
     201           1 :                 return NULL;
     202             :         }
     203          11 :         if (data->state == IDENTITY)
     204          11 :                 eap_sake_state(data, CHALLENGE);
     205             : 
     206          11 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Request/Challenge");
     207             : 
     208          11 :         if (eap_sake_parse_attributes(payload, payload_len, &attr))
     209           1 :                 return NULL;
     210             : 
     211          10 :         if (!attr.rand_s) {
     212           1 :                 wpa_printf(MSG_INFO, "EAP-SAKE: Request/Challenge did not "
     213             :                            "include AT_RAND_S");
     214           1 :                 return NULL;
     215             :         }
     216             : 
     217           9 :         os_memcpy(data->rand_s, attr.rand_s, EAP_SAKE_RAND_LEN);
     218           9 :         wpa_hexdump(MSG_MSGDUMP, "EAP-SAKE: RAND_S (server rand)",
     219           9 :                     data->rand_s, EAP_SAKE_RAND_LEN);
     220             : 
     221           9 :         if (random_get_bytes(data->rand_p, EAP_SAKE_RAND_LEN)) {
     222           0 :                 wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to get random data");
     223           0 :                 return NULL;
     224             :         }
     225           9 :         wpa_hexdump(MSG_MSGDUMP, "EAP-SAKE: RAND_P (peer rand)",
     226           9 :                     data->rand_p, EAP_SAKE_RAND_LEN);
     227             : 
     228           9 :         os_free(data->serverid);
     229           9 :         data->serverid = NULL;
     230           9 :         data->serverid_len = 0;
     231           9 :         if (attr.serverid) {
     232           8 :                 wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-SAKE: SERVERID",
     233           4 :                                   attr.serverid, attr.serverid_len);
     234           4 :                 data->serverid = os_malloc(attr.serverid_len);
     235           4 :                 if (data->serverid == NULL)
     236           0 :                         return NULL;
     237           4 :                 os_memcpy(data->serverid, attr.serverid, attr.serverid_len);
     238           4 :                 data->serverid_len = attr.serverid_len;
     239             :         }
     240             : 
     241           9 :         eap_sake_derive_keys(data->root_secret_a, data->root_secret_b,
     242           9 :                              data->rand_s, data->rand_p,
     243           9 :                              (u8 *) &data->tek, data->msk, data->emsk);
     244             : 
     245           9 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Sending Response/Challenge");
     246             : 
     247           9 :         rlen = 2 + EAP_SAKE_RAND_LEN + 2 + EAP_SAKE_MIC_LEN;
     248           9 :         if (data->peerid)
     249           9 :                 rlen += 2 + data->peerid_len;
     250           9 :         resp = eap_sake_build_msg(data, eap_get_id(reqData), rlen,
     251             :                                   EAP_SAKE_SUBTYPE_CHALLENGE);
     252           9 :         if (resp == NULL)
     253           0 :                 return NULL;
     254             : 
     255           9 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_RAND_P");
     256           9 :         eap_sake_add_attr(resp, EAP_SAKE_AT_RAND_P,
     257           9 :                           data->rand_p, EAP_SAKE_RAND_LEN);
     258             : 
     259           9 :         if (data->peerid) {
     260           9 :                 wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_PEERID");
     261          18 :                 eap_sake_add_attr(resp, EAP_SAKE_AT_PEERID,
     262           9 :                                   data->peerid, data->peerid_len);
     263             :         }
     264             : 
     265           9 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_MIC_P");
     266           9 :         wpabuf_put_u8(resp, EAP_SAKE_AT_MIC_P);
     267           9 :         wpabuf_put_u8(resp, 2 + EAP_SAKE_MIC_LEN);
     268           9 :         rpos = wpabuf_put(resp, EAP_SAKE_MIC_LEN);
     269          36 :         if (eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
     270           9 :                                  data->serverid, data->serverid_len,
     271           9 :                                  data->peerid, data->peerid_len, 1,
     272           9 :                                  wpabuf_head(resp), wpabuf_len(resp), rpos,
     273             :                                  rpos)) {
     274           0 :                 wpa_printf(MSG_INFO, "EAP-SAKE: Failed to compute MIC");
     275           0 :                 wpabuf_free(resp);
     276           0 :                 return NULL;
     277             :         }
     278             : 
     279           9 :         eap_sake_state(data, CONFIRM);
     280             : 
     281           9 :         return resp;
     282             : }
     283             : 
     284             : 
     285           7 : static struct wpabuf * eap_sake_process_confirm(struct eap_sm *sm,
     286             :                                                 struct eap_sake_data *data,
     287             :                                                 struct eap_method_ret *ret,
     288             :                                                 const struct wpabuf *reqData,
     289             :                                                 const u8 *payload,
     290             :                                                 size_t payload_len)
     291             : {
     292             :         struct eap_sake_parse_attr attr;
     293             :         u8 mic_s[EAP_SAKE_MIC_LEN];
     294             :         struct wpabuf *resp;
     295             :         u8 *rpos;
     296             : 
     297           7 :         if (data->state != CONFIRM) {
     298           1 :                 ret->ignore = TRUE;
     299           1 :                 return NULL;
     300             :         }
     301             : 
     302           6 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Request/Confirm");
     303             : 
     304           6 :         if (eap_sake_parse_attributes(payload, payload_len, &attr))
     305           1 :                 return NULL;
     306             : 
     307           5 :         if (!attr.mic_s) {
     308           1 :                 wpa_printf(MSG_INFO, "EAP-SAKE: Request/Confirm did not "
     309             :                            "include AT_MIC_S");
     310           1 :                 return NULL;
     311             :         }
     312             : 
     313          16 :         eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
     314           4 :                              data->serverid, data->serverid_len,
     315           4 :                              data->peerid, data->peerid_len, 0,
     316           4 :                              wpabuf_head(reqData), wpabuf_len(reqData),
     317             :                              attr.mic_s, mic_s);
     318           4 :         if (os_memcmp_const(attr.mic_s, mic_s, EAP_SAKE_MIC_LEN) != 0) {
     319           1 :                 wpa_printf(MSG_INFO, "EAP-SAKE: Incorrect AT_MIC_S");
     320           1 :                 eap_sake_state(data, FAILURE);
     321           1 :                 ret->methodState = METHOD_DONE;
     322           1 :                 ret->decision = DECISION_FAIL;
     323           1 :                 ret->allowNotifications = FALSE;
     324           1 :                 wpa_printf(MSG_DEBUG, "EAP-SAKE: Sending "
     325             :                            "Response/Auth-Reject");
     326           1 :                 return eap_sake_build_msg(data, eap_get_id(reqData), 0,
     327             :                                           EAP_SAKE_SUBTYPE_AUTH_REJECT);
     328             :         }
     329             : 
     330           3 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Sending Response/Confirm");
     331             : 
     332           3 :         resp = eap_sake_build_msg(data, eap_get_id(reqData),
     333             :                                   2 + EAP_SAKE_MIC_LEN,
     334             :                                   EAP_SAKE_SUBTYPE_CONFIRM);
     335           3 :         if (resp == NULL)
     336           0 :                 return NULL;
     337             : 
     338           3 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_MIC_P");
     339           3 :         wpabuf_put_u8(resp, EAP_SAKE_AT_MIC_P);
     340           3 :         wpabuf_put_u8(resp, 2 + EAP_SAKE_MIC_LEN);
     341           3 :         rpos = wpabuf_put(resp, EAP_SAKE_MIC_LEN);
     342          12 :         if (eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
     343           3 :                                  data->serverid, data->serverid_len,
     344           3 :                                  data->peerid, data->peerid_len, 1,
     345           3 :                                  wpabuf_head(resp), wpabuf_len(resp), rpos,
     346             :                                  rpos)) {
     347           0 :                 wpa_printf(MSG_INFO, "EAP-SAKE: Failed to compute MIC");
     348           0 :                 wpabuf_free(resp);
     349           0 :                 return NULL;
     350             :         }
     351             : 
     352           3 :         eap_sake_state(data, SUCCESS);
     353           3 :         ret->methodState = METHOD_DONE;
     354           3 :         ret->decision = DECISION_UNCOND_SUCC;
     355           3 :         ret->allowNotifications = FALSE;
     356             : 
     357           3 :         return resp;
     358             : }
     359             : 
     360             : 
     361          27 : static struct wpabuf * eap_sake_process(struct eap_sm *sm, void *priv,
     362             :                                         struct eap_method_ret *ret,
     363             :                                         const struct wpabuf *reqData)
     364             : {
     365          27 :         struct eap_sake_data *data = priv;
     366             :         const struct eap_sake_hdr *req;
     367             :         struct wpabuf *resp;
     368             :         const u8 *pos, *end;
     369             :         size_t len;
     370             :         u8 subtype, session_id;
     371             : 
     372          27 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SAKE, reqData, &len);
     373          27 :         if (pos == NULL || len < sizeof(struct eap_sake_hdr)) {
     374           1 :                 ret->ignore = TRUE;
     375           1 :                 return NULL;
     376             :         }
     377             : 
     378          26 :         req = (const struct eap_sake_hdr *) pos;
     379          26 :         end = pos + len;
     380          26 :         subtype = req->subtype;
     381          26 :         session_id = req->session_id;
     382          26 :         pos = (const u8 *) (req + 1);
     383             : 
     384          26 :         wpa_printf(MSG_DEBUG, "EAP-SAKE: Received frame: subtype %d "
     385             :                    "session_id %d", subtype, session_id);
     386          26 :         wpa_hexdump(MSG_DEBUG, "EAP-SAKE: Received attributes",
     387          26 :                     pos, end - pos);
     388             : 
     389          26 :         if (data->session_id_set && data->session_id != session_id) {
     390           1 :                 wpa_printf(MSG_INFO, "EAP-SAKE: Session ID mismatch (%d,%d)",
     391           1 :                            session_id, data->session_id);
     392           1 :                 ret->ignore = TRUE;
     393           1 :                 return NULL;
     394             :         }
     395          25 :         data->session_id = session_id;
     396          25 :         data->session_id_set = 1;
     397             : 
     398          25 :         ret->ignore = FALSE;
     399          25 :         ret->methodState = METHOD_MAY_CONT;
     400          25 :         ret->decision = DECISION_FAIL;
     401          25 :         ret->allowNotifications = TRUE;
     402             : 
     403          25 :         switch (subtype) {
     404             :         case EAP_SAKE_SUBTYPE_IDENTITY:
     405           5 :                 resp = eap_sake_process_identity(sm, data, ret, reqData,
     406           5 :                                                  pos, end - pos);
     407           5 :                 break;
     408             :         case EAP_SAKE_SUBTYPE_CHALLENGE:
     409          12 :                 resp = eap_sake_process_challenge(sm, data, ret, reqData,
     410          12 :                                                   pos, end - pos);
     411          12 :                 break;
     412             :         case EAP_SAKE_SUBTYPE_CONFIRM:
     413           7 :                 resp = eap_sake_process_confirm(sm, data, ret, reqData,
     414           7 :                                                 pos, end - pos);
     415           7 :                 break;
     416             :         default:
     417           1 :                 wpa_printf(MSG_DEBUG, "EAP-SAKE: Ignoring message with "
     418             :                            "unknown subtype %d", subtype);
     419           1 :                 ret->ignore = TRUE;
     420           1 :                 return NULL;
     421             :         }
     422             : 
     423          24 :         if (ret->methodState == METHOD_DONE)
     424           4 :                 ret->allowNotifications = FALSE;
     425             : 
     426          24 :         return resp;
     427             : }
     428             : 
     429             : 
     430          21 : static Boolean eap_sake_isKeyAvailable(struct eap_sm *sm, void *priv)
     431             : {
     432          21 :         struct eap_sake_data *data = priv;
     433          21 :         return data->state == SUCCESS;
     434             : }
     435             : 
     436             : 
     437           3 : static u8 * eap_sake_getKey(struct eap_sm *sm, void *priv, size_t *len)
     438             : {
     439           3 :         struct eap_sake_data *data = priv;
     440             :         u8 *key;
     441             : 
     442           3 :         if (data->state != SUCCESS)
     443           0 :                 return NULL;
     444             : 
     445           3 :         key = os_malloc(EAP_MSK_LEN);
     446           3 :         if (key == NULL)
     447           0 :                 return NULL;
     448           3 :         os_memcpy(key, data->msk, EAP_MSK_LEN);
     449           3 :         *len = EAP_MSK_LEN;
     450             : 
     451           3 :         return key;
     452             : }
     453             : 
     454             : 
     455           3 : static u8 * eap_sake_get_session_id(struct eap_sm *sm, void *priv, size_t *len)
     456             : {
     457           3 :         struct eap_sake_data *data = priv;
     458             :         u8 *id;
     459             : 
     460           3 :         if (data->state != SUCCESS)
     461           0 :                 return NULL;
     462             : 
     463           3 :         *len = 1 + 2 * EAP_SAKE_RAND_LEN;
     464           3 :         id = os_malloc(*len);
     465           3 :         if (id == NULL)
     466           0 :                 return NULL;
     467             : 
     468           3 :         id[0] = EAP_TYPE_SAKE;
     469           3 :         os_memcpy(id + 1, data->rand_s, EAP_SAKE_RAND_LEN);
     470           3 :         os_memcpy(id + 1 + EAP_SAKE_RAND_LEN, data->rand_s, EAP_SAKE_RAND_LEN);
     471           3 :         wpa_hexdump(MSG_DEBUG, "EAP-SAKE: Derived Session-Id", id, *len);
     472             : 
     473           3 :         return id;
     474             : }
     475             : 
     476             : 
     477           1 : static u8 * eap_sake_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
     478             : {
     479           1 :         struct eap_sake_data *data = priv;
     480             :         u8 *key;
     481             : 
     482           1 :         if (data->state != SUCCESS)
     483           0 :                 return NULL;
     484             : 
     485           1 :         key = os_malloc(EAP_EMSK_LEN);
     486           1 :         if (key == NULL)
     487           0 :                 return NULL;
     488           1 :         os_memcpy(key, data->emsk, EAP_EMSK_LEN);
     489           1 :         *len = EAP_EMSK_LEN;
     490             : 
     491           1 :         return key;
     492             : }
     493             : 
     494             : 
     495          30 : int eap_peer_sake_register(void)
     496             : {
     497             :         struct eap_method *eap;
     498             :         int ret;
     499             : 
     500          30 :         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
     501             :                                     EAP_VENDOR_IETF, EAP_TYPE_SAKE, "SAKE");
     502          30 :         if (eap == NULL)
     503           0 :                 return -1;
     504             : 
     505          30 :         eap->init = eap_sake_init;
     506          30 :         eap->deinit = eap_sake_deinit;
     507          30 :         eap->process = eap_sake_process;
     508          30 :         eap->isKeyAvailable = eap_sake_isKeyAvailable;
     509          30 :         eap->getKey = eap_sake_getKey;
     510          30 :         eap->getSessionId = eap_sake_get_session_id;
     511          30 :         eap->get_emsk = eap_sake_get_emsk;
     512             : 
     513          30 :         ret = eap_peer_method_register(eap);
     514          30 :         if (ret)
     515           0 :                 eap_peer_method_free(eap);
     516          30 :         return ret;
     517             : }

Generated by: LCOV version 1.10