LCOV - code coverage report
Current view: top level - src/eap_peer - eap_pax.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1422976643 Lines: 252 287 87.8 %
Date: 2015-02-03 Functions: 11 11 100.0 %

          Line data    Source code
       1             : /*
       2             :  * EAP peer method: EAP-PAX (RFC 4746)
       3             :  * Copyright (c) 2005-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_common/eap_pax_common.h"
      14             : #include "eap_i.h"
      15             : 
      16             : /*
      17             :  * Note: only PAX_STD subprotocol is currently supported
      18             :  *
      19             :  * TODO: Add support with PAX_SEC with the mandatory to implement ciphersuite
      20             :  * (HMAC_SHA1_128, IANA DH Group 14 (2048 bits), RSA-PKCS1-V1_5) and
      21             :  * recommended ciphersuite (HMAC_SHA256_128, IANA DH Group 15 (3072 bits),
      22             :  * RSAES-OAEP).
      23             :  */
      24             : 
      25             : struct eap_pax_data {
      26             :         enum { PAX_INIT, PAX_STD_2_SENT, PAX_DONE } state;
      27             :         u8 mac_id, dh_group_id, public_key_id;
      28             :         union {
      29             :                 u8 e[2 * EAP_PAX_RAND_LEN];
      30             :                 struct {
      31             :                         u8 x[EAP_PAX_RAND_LEN]; /* server rand */
      32             :                         u8 y[EAP_PAX_RAND_LEN]; /* client rand */
      33             :                 } r;
      34             :         } rand;
      35             :         char *cid;
      36             :         size_t cid_len;
      37             :         u8 ak[EAP_PAX_AK_LEN];
      38             :         u8 mk[EAP_PAX_MK_LEN];
      39             :         u8 ck[EAP_PAX_CK_LEN];
      40             :         u8 ick[EAP_PAX_ICK_LEN];
      41             :         u8 mid[EAP_PAX_MID_LEN];
      42             : };
      43             : 
      44             : 
      45             : static void eap_pax_deinit(struct eap_sm *sm, void *priv);
      46             : 
      47             : 
      48          47 : static void * eap_pax_init(struct eap_sm *sm)
      49             : {
      50             :         struct eap_pax_data *data;
      51             :         const u8 *identity, *password;
      52             :         size_t identity_len, password_len;
      53             : 
      54          47 :         identity = eap_get_config_identity(sm, &identity_len);
      55          47 :         password = eap_get_config_password(sm, &password_len);
      56          47 :         if (!identity || !password) {
      57           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: CID (nai) or key (password) "
      58             :                            "not configured");
      59           1 :                 return NULL;
      60             :         }
      61             : 
      62          46 :         if (password_len != EAP_PAX_AK_LEN) {
      63           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: Invalid PSK length");
      64           1 :                 return NULL;
      65             :         }
      66             : 
      67          45 :         data = os_zalloc(sizeof(*data));
      68          45 :         if (data == NULL)
      69           0 :                 return NULL;
      70          45 :         data->state = PAX_INIT;
      71             : 
      72          45 :         data->cid = os_malloc(identity_len);
      73          45 :         if (data->cid == NULL) {
      74           0 :                 eap_pax_deinit(sm, data);
      75           0 :                 return NULL;
      76             :         }
      77          45 :         os_memcpy(data->cid, identity, identity_len);
      78          45 :         data->cid_len = identity_len;
      79             : 
      80          45 :         os_memcpy(data->ak, password, EAP_PAX_AK_LEN);
      81             : 
      82          45 :         return data;
      83             : }
      84             : 
      85             : 
      86          45 : static void eap_pax_deinit(struct eap_sm *sm, void *priv)
      87             : {
      88          45 :         struct eap_pax_data *data = priv;
      89          45 :         os_free(data->cid);
      90          45 :         bin_clear_free(data, sizeof(*data));
      91          45 : }
      92             : 
      93             : 
      94          58 : static struct wpabuf * eap_pax_alloc_resp(const struct eap_pax_hdr *req,
      95             :                                           u8 id, u8 op_code, size_t plen)
      96             : {
      97             :         struct wpabuf *resp;
      98             :         struct eap_pax_hdr *pax;
      99             : 
     100          58 :         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PAX,
     101             :                              sizeof(*pax) + plen, EAP_CODE_RESPONSE, id);
     102          58 :         if (resp == NULL)
     103           0 :                 return NULL;
     104             : 
     105          58 :         pax = wpabuf_put(resp, sizeof(*pax));
     106          58 :         pax->op_code = op_code;
     107          58 :         pax->flags = 0;
     108          58 :         pax->mac_id = req->mac_id;
     109          58 :         pax->dh_group_id = req->dh_group_id;
     110          58 :         pax->public_key_id = req->public_key_id;
     111             : 
     112          58 :         return resp;
     113             : }
     114             : 
     115             : 
     116          36 : static struct wpabuf * eap_pax_process_std_1(struct eap_pax_data *data,
     117             :                                              struct eap_method_ret *ret, u8 id,
     118             :                                              const struct eap_pax_hdr *req,
     119             :                                              size_t req_plen)
     120             : {
     121             :         struct wpabuf *resp;
     122             :         const u8 *pos;
     123             :         u8 *rpos;
     124             :         size_t left, plen;
     125             : 
     126          36 :         wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-1 (received)");
     127             : 
     128          36 :         if (data->state != PAX_INIT) {
     129           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-1 received in "
     130           1 :                            "unexpected state (%d) - ignored", data->state);
     131           1 :                 ret->ignore = TRUE;
     132           1 :                 return NULL;
     133             :         }
     134             : 
     135          35 :         if (req->flags & EAP_PAX_FLAGS_CE) {
     136           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-1 with CE flag set - "
     137             :                            "ignored");
     138           1 :                 ret->ignore = TRUE;
     139           1 :                 return NULL;
     140             :         }
     141             : 
     142          34 :         left = req_plen - sizeof(*req);
     143             : 
     144          34 :         if (left < 2 + EAP_PAX_RAND_LEN) {
     145           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-1 with too short "
     146             :                            "payload");
     147           1 :                 ret->ignore = TRUE;
     148           1 :                 return NULL;
     149             :         }
     150             : 
     151          33 :         pos = (const u8 *) (req + 1);
     152          33 :         if (WPA_GET_BE16(pos) != EAP_PAX_RAND_LEN) {
     153           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-1 with incorrect A "
     154             :                            "length %d (expected %d)",
     155           1 :                            WPA_GET_BE16(pos), EAP_PAX_RAND_LEN);
     156           1 :                 ret->ignore = TRUE;
     157           1 :                 return NULL;
     158             :         }
     159             : 
     160          32 :         pos += 2;
     161          32 :         left -= 2;
     162          32 :         os_memcpy(data->rand.r.x, pos, EAP_PAX_RAND_LEN);
     163          32 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: X (server rand)",
     164          32 :                     data->rand.r.x, EAP_PAX_RAND_LEN);
     165          32 :         pos += EAP_PAX_RAND_LEN;
     166          32 :         left -= EAP_PAX_RAND_LEN;
     167             : 
     168          32 :         if (left > 0) {
     169           1 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ignored extra payload",
     170             :                             pos, left);
     171             :         }
     172             : 
     173          32 :         if (random_get_bytes(data->rand.r.y, EAP_PAX_RAND_LEN)) {
     174           0 :                 wpa_printf(MSG_ERROR, "EAP-PAX: Failed to get random data");
     175           0 :                 ret->ignore = TRUE;
     176           0 :                 return NULL;
     177             :         }
     178          32 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Y (client rand)",
     179          32 :                     data->rand.r.y, EAP_PAX_RAND_LEN);
     180             : 
     181          32 :         if (eap_pax_initial_key_derivation(req->mac_id, data->ak, data->rand.e,
     182          32 :                                            data->mk, data->ck, data->ick,
     183          32 :                                            data->mid) < 0) {
     184           0 :                 ret->ignore = TRUE;
     185           0 :                 return NULL;
     186             :         }
     187             : 
     188          32 :         wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-2 (sending)");
     189             : 
     190          32 :         plen = 2 + EAP_PAX_RAND_LEN + 2 + data->cid_len + 2 + EAP_PAX_MAC_LEN +
     191             :                 EAP_PAX_ICV_LEN;
     192          32 :         resp = eap_pax_alloc_resp(req, id, EAP_PAX_OP_STD_2, plen);
     193          32 :         if (resp == NULL)
     194           0 :                 return NULL;
     195             : 
     196          32 :         wpabuf_put_be16(resp, EAP_PAX_RAND_LEN);
     197          32 :         wpabuf_put_data(resp, data->rand.r.y, EAP_PAX_RAND_LEN);
     198          32 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: B = Y (client rand)",
     199          32 :                     data->rand.r.y, EAP_PAX_RAND_LEN);
     200             : 
     201          32 :         wpabuf_put_be16(resp, data->cid_len);
     202          32 :         wpabuf_put_data(resp, data->cid, data->cid_len);
     203          64 :         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-PAX: CID",
     204          32 :                           (u8 *) data->cid, data->cid_len);
     205             : 
     206          32 :         wpabuf_put_be16(resp, EAP_PAX_MAC_LEN);
     207          32 :         rpos = wpabuf_put(resp, EAP_PAX_MAC_LEN);
     208          64 :         eap_pax_mac(req->mac_id, data->ck, EAP_PAX_CK_LEN,
     209          32 :                     data->rand.r.x, EAP_PAX_RAND_LEN,
     210          32 :                     data->rand.r.y, EAP_PAX_RAND_LEN,
     211          32 :                     (u8 *) data->cid, data->cid_len, rpos);
     212          32 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: MAC_CK(A, B, CID)",
     213             :                     rpos, EAP_PAX_MAC_LEN);
     214             : 
     215             :         /* Optional ADE could be added here, if needed */
     216             : 
     217          32 :         rpos = wpabuf_put(resp, EAP_PAX_ICV_LEN);
     218          64 :         eap_pax_mac(req->mac_id, data->ick, EAP_PAX_ICK_LEN,
     219          64 :                     wpabuf_head(resp), wpabuf_len(resp) - EAP_PAX_ICV_LEN,
     220             :                     NULL, 0, NULL, 0, rpos);
     221          32 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", rpos, EAP_PAX_ICV_LEN);
     222             : 
     223          32 :         data->state = PAX_STD_2_SENT;
     224          32 :         data->mac_id = req->mac_id;
     225          32 :         data->dh_group_id = req->dh_group_id;
     226          32 :         data->public_key_id = req->public_key_id;
     227             : 
     228          32 :         return resp;
     229             : }
     230             : 
     231             : 
     232          27 : static struct wpabuf * eap_pax_process_std_3(struct eap_pax_data *data,
     233             :                                              struct eap_method_ret *ret, u8 id,
     234             :                                              const struct eap_pax_hdr *req,
     235             :                                              size_t req_plen)
     236             : {
     237             :         struct wpabuf *resp;
     238             :         u8 *rpos, mac[EAP_PAX_MAC_LEN];
     239             :         const u8 *pos;
     240             :         size_t left;
     241             : 
     242          27 :         wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-3 (received)");
     243             : 
     244          27 :         if (data->state != PAX_STD_2_SENT) {
     245           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-3 received in "
     246           1 :                            "unexpected state (%d) - ignored", data->state);
     247           1 :                 ret->ignore = TRUE;
     248           1 :                 return NULL;
     249             :         }
     250             : 
     251          26 :         if (req->flags & EAP_PAX_FLAGS_CE) {
     252           0 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-3 with CE flag set - "
     253             :                            "ignored");
     254           0 :                 ret->ignore = TRUE;
     255           0 :                 return NULL;
     256             :         }
     257             : 
     258          26 :         left = req_plen - sizeof(*req);
     259             : 
     260          26 :         if (left < 2 + EAP_PAX_MAC_LEN) {
     261           0 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-3 with too short "
     262             :                            "payload");
     263           0 :                 ret->ignore = TRUE;
     264           0 :                 return NULL;
     265             :         }
     266             : 
     267          26 :         pos = (const u8 *) (req + 1);
     268          26 :         if (WPA_GET_BE16(pos) != EAP_PAX_MAC_LEN) {
     269           0 :                 wpa_printf(MSG_INFO, "EAP-PAX: PAX_STD-3 with incorrect "
     270             :                            "MAC_CK length %d (expected %d)",
     271           0 :                            WPA_GET_BE16(pos), EAP_PAX_MAC_LEN);
     272           0 :                 ret->ignore = TRUE;
     273           0 :                 return NULL;
     274             :         }
     275          26 :         pos += 2;
     276          26 :         left -= 2;
     277          26 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: MAC_CK(B, CID)",
     278             :                     pos, EAP_PAX_MAC_LEN);
     279          52 :         eap_pax_mac(data->mac_id, data->ck, EAP_PAX_CK_LEN,
     280          26 :                     data->rand.r.y, EAP_PAX_RAND_LEN,
     281          26 :                     (u8 *) data->cid, data->cid_len, NULL, 0, mac);
     282          26 :         if (os_memcmp_const(pos, mac, EAP_PAX_MAC_LEN) != 0) {
     283           0 :                 wpa_printf(MSG_INFO, "EAP-PAX: Invalid MAC_CK(B, CID) "
     284             :                            "received");
     285           0 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: expected MAC_CK(B, CID)",
     286             :                             mac, EAP_PAX_MAC_LEN);
     287           0 :                 ret->methodState = METHOD_DONE;
     288           0 :                 ret->decision = DECISION_FAIL;
     289           0 :                 return NULL;
     290             :         }
     291             : 
     292          26 :         pos += EAP_PAX_MAC_LEN;
     293          26 :         left -= EAP_PAX_MAC_LEN;
     294             : 
     295          26 :         if (left > 0) {
     296           0 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ignored extra payload",
     297             :                             pos, left);
     298             :         }
     299             : 
     300          26 :         wpa_printf(MSG_DEBUG, "EAP-PAX: PAX-ACK (sending)");
     301             : 
     302          26 :         resp = eap_pax_alloc_resp(req, id, EAP_PAX_OP_ACK, EAP_PAX_ICV_LEN);
     303          26 :         if (resp == NULL)
     304           0 :                 return NULL;
     305             : 
     306             :         /* Optional ADE could be added here, if needed */
     307             : 
     308          26 :         rpos = wpabuf_put(resp, EAP_PAX_ICV_LEN);
     309          52 :         eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
     310          52 :                     wpabuf_head(resp), wpabuf_len(resp) - EAP_PAX_ICV_LEN,
     311             :                     NULL, 0, NULL, 0, rpos);
     312          26 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", rpos, EAP_PAX_ICV_LEN);
     313             : 
     314          26 :         data->state = PAX_DONE;
     315          26 :         ret->methodState = METHOD_DONE;
     316          26 :         ret->decision = DECISION_UNCOND_SUCC;
     317          26 :         ret->allowNotifications = FALSE;
     318             : 
     319          26 :         return resp;
     320             : }
     321             : 
     322             : 
     323          76 : static struct wpabuf * eap_pax_process(struct eap_sm *sm, void *priv,
     324             :                                        struct eap_method_ret *ret,
     325             :                                        const struct wpabuf *reqData)
     326             : {
     327          76 :         struct eap_pax_data *data = priv;
     328             :         const struct eap_pax_hdr *req;
     329             :         struct wpabuf *resp;
     330             :         u8 icvbuf[EAP_PAX_ICV_LEN], id;
     331             :         const u8 *icv, *pos;
     332             :         size_t len;
     333             :         u16 flen, mlen;
     334             : 
     335          76 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, reqData, &len);
     336          76 :         if (pos == NULL || len < EAP_PAX_ICV_LEN) {
     337           1 :                 ret->ignore = TRUE;
     338           1 :                 return NULL;
     339             :         }
     340          75 :         id = eap_get_id(reqData);
     341          75 :         req = (const struct eap_pax_hdr *) pos;
     342          75 :         flen = len - EAP_PAX_ICV_LEN;
     343          75 :         mlen = wpabuf_len(reqData) - EAP_PAX_ICV_LEN;
     344             : 
     345         375 :         wpa_printf(MSG_DEBUG, "EAP-PAX: received frame: op_code 0x%x "
     346             :                    "flags 0x%x mac_id 0x%x dh_group_id 0x%x "
     347             :                    "public_key_id 0x%x",
     348         300 :                    req->op_code, req->flags, req->mac_id, req->dh_group_id,
     349          75 :                    req->public_key_id);
     350          75 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: received payload",
     351             :                     pos, len - EAP_PAX_ICV_LEN);
     352             : 
     353          75 :         if (data->state != PAX_INIT && data->mac_id != req->mac_id) {
     354           2 :                 wpa_printf(MSG_INFO, "EAP-PAX: MAC ID changed during "
     355             :                            "authentication (was 0x%d, is 0x%d)",
     356           2 :                            data->mac_id, req->mac_id);
     357           1 :                 ret->ignore = TRUE;
     358           1 :                 return NULL;
     359             :         }
     360             : 
     361          74 :         if (data->state != PAX_INIT && data->dh_group_id != req->dh_group_id) {
     362           2 :                 wpa_printf(MSG_INFO, "EAP-PAX: DH Group ID changed during "
     363             :                            "authentication (was 0x%d, is 0x%d)",
     364           2 :                            data->dh_group_id, req->dh_group_id);
     365           1 :                 ret->ignore = TRUE;
     366           1 :                 return NULL;
     367             :         }
     368             : 
     369         102 :         if (data->state != PAX_INIT &&
     370          29 :             data->public_key_id != req->public_key_id) {
     371           2 :                 wpa_printf(MSG_INFO, "EAP-PAX: Public Key ID changed during "
     372             :                            "authentication (was 0x%d, is 0x%d)",
     373           2 :                            data->public_key_id, req->public_key_id);
     374           1 :                 ret->ignore = TRUE;
     375           1 :                 return NULL;
     376             :         }
     377             : 
     378             :         /* TODO: add support EAP_PAX_HMAC_SHA256_128 */
     379          72 :         if (req->mac_id != EAP_PAX_MAC_HMAC_SHA1_128) {
     380           2 :                 wpa_printf(MSG_INFO, "EAP-PAX: Unsupported MAC ID 0x%x",
     381           2 :                            req->mac_id);
     382           2 :                 ret->ignore = TRUE;
     383           2 :                 return NULL;
     384             :         }
     385             : 
     386          70 :         if (req->dh_group_id != EAP_PAX_DH_GROUP_NONE) {
     387           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: Unsupported DH Group ID 0x%x",
     388           1 :                            req->dh_group_id);
     389           1 :                 ret->ignore = TRUE;
     390           1 :                 return NULL;
     391             :         }
     392             : 
     393          69 :         if (req->public_key_id != EAP_PAX_PUBLIC_KEY_NONE) {
     394           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: Unsupported Public Key ID 0x%x",
     395           1 :                            req->public_key_id);
     396           1 :                 ret->ignore = TRUE;
     397           1 :                 return NULL;
     398             :         }
     399             : 
     400          68 :         if (req->flags & EAP_PAX_FLAGS_MF) {
     401             :                 /* TODO: add support for reassembling fragments */
     402           1 :                 wpa_printf(MSG_INFO, "EAP-PAX: fragmentation not supported - "
     403             :                            "ignored packet");
     404           1 :                 ret->ignore = TRUE;
     405           1 :                 return NULL;
     406             :         }
     407             : 
     408          67 :         icv = pos + len - EAP_PAX_ICV_LEN;
     409          67 :         wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", icv, EAP_PAX_ICV_LEN);
     410          67 :         if (req->op_code == EAP_PAX_OP_STD_1) {
     411          76 :                 eap_pax_mac(req->mac_id, (u8 *) "", 0,
     412          38 :                             wpabuf_head(reqData), mlen, NULL, 0, NULL, 0,
     413             :                             icvbuf);
     414             :         } else {
     415          58 :                 eap_pax_mac(req->mac_id, data->ick, EAP_PAX_ICK_LEN,
     416          29 :                             wpabuf_head(reqData), mlen, NULL, 0, NULL, 0,
     417             :                             icvbuf);
     418             :         }
     419          67 :         if (os_memcmp_const(icv, icvbuf, EAP_PAX_ICV_LEN) != 0) {
     420           3 :                 wpa_printf(MSG_DEBUG, "EAP-PAX: invalid ICV - ignoring the "
     421             :                            "message");
     422           3 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: expected ICV",
     423             :                             icvbuf, EAP_PAX_ICV_LEN);
     424           3 :                 ret->ignore = TRUE;
     425           3 :                 return NULL;
     426             :         }
     427             : 
     428          64 :         ret->ignore = FALSE;
     429          64 :         ret->methodState = METHOD_MAY_CONT;
     430          64 :         ret->decision = DECISION_FAIL;
     431          64 :         ret->allowNotifications = TRUE;
     432             : 
     433          64 :         switch (req->op_code) {
     434             :         case EAP_PAX_OP_STD_1:
     435          36 :                 resp = eap_pax_process_std_1(data, ret, id, req, flen);
     436          36 :                 break;
     437             :         case EAP_PAX_OP_STD_3:
     438          27 :                 resp = eap_pax_process_std_3(data, ret, id, req, flen);
     439          27 :                 break;
     440             :         default:
     441           1 :                 wpa_printf(MSG_DEBUG, "EAP-PAX: ignoring message with unknown "
     442           1 :                            "op_code %d", req->op_code);
     443           1 :                 ret->ignore = TRUE;
     444           1 :                 return NULL;
     445             :         }
     446             : 
     447          63 :         if (ret->methodState == METHOD_DONE) {
     448          26 :                 ret->allowNotifications = FALSE;
     449             :         }
     450             : 
     451          63 :         return resp;
     452             : }
     453             : 
     454             : 
     455          58 : static Boolean eap_pax_isKeyAvailable(struct eap_sm *sm, void *priv)
     456             : {
     457          58 :         struct eap_pax_data *data = priv;
     458          58 :         return data->state == PAX_DONE;
     459             : }
     460             : 
     461             : 
     462          26 : static u8 * eap_pax_getKey(struct eap_sm *sm, void *priv, size_t *len)
     463             : {
     464          26 :         struct eap_pax_data *data = priv;
     465             :         u8 *key;
     466             : 
     467          26 :         if (data->state != PAX_DONE)
     468           0 :                 return NULL;
     469             : 
     470          26 :         key = os_malloc(EAP_MSK_LEN);
     471          26 :         if (key == NULL)
     472           0 :                 return NULL;
     473             : 
     474          26 :         *len = EAP_MSK_LEN;
     475          26 :         eap_pax_kdf(data->mac_id, data->mk, EAP_PAX_MK_LEN,
     476          26 :                     "Master Session Key", data->rand.e, 2 * EAP_PAX_RAND_LEN,
     477             :                     EAP_MSK_LEN, key);
     478             : 
     479          26 :         return key;
     480             : }
     481             : 
     482             : 
     483           1 : static u8 * eap_pax_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
     484             : {
     485           1 :         struct eap_pax_data *data = priv;
     486             :         u8 *key;
     487             : 
     488           1 :         if (data->state != PAX_DONE)
     489           0 :                 return NULL;
     490             : 
     491           1 :         key = os_malloc(EAP_EMSK_LEN);
     492           1 :         if (key == NULL)
     493           0 :                 return NULL;
     494             : 
     495           1 :         *len = EAP_EMSK_LEN;
     496           1 :         eap_pax_kdf(data->mac_id, data->mk, EAP_PAX_MK_LEN,
     497             :                     "Extended Master Session Key",
     498           1 :                     data->rand.e, 2 * EAP_PAX_RAND_LEN,
     499             :                     EAP_EMSK_LEN, key);
     500             : 
     501           1 :         return key;
     502             : }
     503             : 
     504             : 
     505          26 : static u8 * eap_pax_get_session_id(struct eap_sm *sm, void *priv, size_t *len)
     506             : {
     507          26 :         struct eap_pax_data *data = priv;
     508             :         u8 *sid;
     509             : 
     510          26 :         if (data->state != PAX_DONE)
     511           0 :                 return NULL;
     512             : 
     513          26 :         sid = os_malloc(1 + EAP_PAX_MID_LEN);
     514          26 :         if (sid == NULL)
     515           0 :                 return NULL;
     516             : 
     517          26 :         *len = 1 + EAP_PAX_MID_LEN;
     518          26 :         sid[0] = EAP_TYPE_PAX;
     519          26 :         os_memcpy(sid + 1, data->mid, EAP_PAX_MID_LEN);
     520             : 
     521          26 :         return sid;
     522             : }
     523             : 
     524             : 
     525          30 : int eap_peer_pax_register(void)
     526             : {
     527             :         struct eap_method *eap;
     528             :         int ret;
     529             : 
     530          30 :         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
     531             :                                     EAP_VENDOR_IETF, EAP_TYPE_PAX, "PAX");
     532          30 :         if (eap == NULL)
     533           0 :                 return -1;
     534             : 
     535          30 :         eap->init = eap_pax_init;
     536          30 :         eap->deinit = eap_pax_deinit;
     537          30 :         eap->process = eap_pax_process;
     538          30 :         eap->isKeyAvailable = eap_pax_isKeyAvailable;
     539          30 :         eap->getKey = eap_pax_getKey;
     540          30 :         eap->get_emsk = eap_pax_get_emsk;
     541          30 :         eap->getSessionId = eap_pax_get_session_id;
     542             : 
     543          30 :         ret = eap_peer_method_register(eap);
     544          30 :         if (ret)
     545           0 :                 eap_peer_method_free(eap);
     546          30 :         return ret;
     547             : }

Generated by: LCOV version 1.10