wpa_supplicant: Initial Revision 0.8.X
Based on:
commit 0725cc7b7efc434910e89865c42eda7ce61bbf08
Author: Jouni Malinen <j@w1.fi>
Date: Thu Apr 21 20:41:01 2011 +0300
Enable CONFIG_DRIVER_NL80211=y in the default configuration
nl80211 should be preferred over WEXT with any recent Linux
kernel version.
Change-Id: I26aec5afbbd4f4a1f5fd900912545b6f5050de64
Signed-off-by: Dmitry Shmidt <dimitrysh@google.com>
diff --git a/src/eap_server/Makefile b/src/eap_server/Makefile
new file mode 100644
index 0000000..9c41962
--- /dev/null
+++ b/src/eap_server/Makefile
@@ -0,0 +1,8 @@
+all:
+ @echo Nothing to be made.
+
+clean:
+ rm -f *~ *.o *.d
+
+install:
+ @echo Nothing to be made.
diff --git a/src/eap_server/eap.h b/src/eap_server/eap.h
new file mode 100644
index 0000000..6b29075
--- /dev/null
+++ b/src/eap_server/eap.h
@@ -0,0 +1,128 @@
+/*
+ * hostapd / EAP Full Authenticator state machine (RFC 4137)
+ * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef EAP_H
+#define EAP_H
+
+#include "common/defs.h"
+#include "eap_common/eap_defs.h"
+#include "eap_server/eap_methods.h"
+#include "wpabuf.h"
+
+struct eap_sm;
+
+#define EAP_MAX_METHODS 8
+
+#define EAP_TTLS_AUTH_PAP 1
+#define EAP_TTLS_AUTH_CHAP 2
+#define EAP_TTLS_AUTH_MSCHAP 4
+#define EAP_TTLS_AUTH_MSCHAPV2 8
+
+struct eap_user {
+ struct {
+ int vendor;
+ u32 method;
+ } methods[EAP_MAX_METHODS];
+ u8 *password;
+ size_t password_len;
+ int password_hash; /* whether password is hashed with
+ * nt_password_hash() */
+ int phase2;
+ int force_version;
+ int ttls_auth; /* bitfield of
+ * EAP_TTLS_AUTH_{PAP,CHAP,MSCHAP,MSCHAPV2} */
+};
+
+struct eap_eapol_interface {
+ /* Lower layer to full authenticator variables */
+ Boolean eapResp; /* shared with EAPOL Backend Authentication */
+ struct wpabuf *eapRespData;
+ Boolean portEnabled;
+ int retransWhile;
+ Boolean eapRestart; /* shared with EAPOL Authenticator PAE */
+ int eapSRTT;
+ int eapRTTVAR;
+
+ /* Full authenticator to lower layer variables */
+ Boolean eapReq; /* shared with EAPOL Backend Authentication */
+ Boolean eapNoReq; /* shared with EAPOL Backend Authentication */
+ Boolean eapSuccess;
+ Boolean eapFail;
+ Boolean eapTimeout;
+ struct wpabuf *eapReqData;
+ u8 *eapKeyData;
+ size_t eapKeyDataLen;
+ Boolean eapKeyAvailable; /* called keyAvailable in IEEE 802.1X-2004 */
+
+ /* AAA interface to full authenticator variables */
+ Boolean aaaEapReq;
+ Boolean aaaEapNoReq;
+ Boolean aaaSuccess;
+ Boolean aaaFail;
+ struct wpabuf *aaaEapReqData;
+ u8 *aaaEapKeyData;
+ size_t aaaEapKeyDataLen;
+ Boolean aaaEapKeyAvailable;
+ int aaaMethodTimeout;
+
+ /* Full authenticator to AAA interface variables */
+ Boolean aaaEapResp;
+ struct wpabuf *aaaEapRespData;
+ /* aaaIdentity -> eap_get_identity() */
+ Boolean aaaTimeout;
+};
+
+struct eapol_callbacks {
+ int (*get_eap_user)(void *ctx, const u8 *identity, size_t identity_len,
+ int phase2, struct eap_user *user);
+ const char * (*get_eap_req_id_text)(void *ctx, size_t *len);
+};
+
+struct eap_config {
+ void *ssl_ctx;
+ void *msg_ctx;
+ void *eap_sim_db_priv;
+ Boolean backend_auth;
+ int eap_server;
+ u16 pwd_group;
+ u8 *pac_opaque_encr_key;
+ u8 *eap_fast_a_id;
+ size_t eap_fast_a_id_len;
+ char *eap_fast_a_id_info;
+ int eap_fast_prov;
+ int pac_key_lifetime;
+ int pac_key_refresh_time;
+ int eap_sim_aka_result_ind;
+ int tnc;
+ struct wps_context *wps;
+ const struct wpabuf *assoc_wps_ie;
+ const struct wpabuf *assoc_p2p_ie;
+ const u8 *peer_addr;
+ int fragment_size;
+};
+
+
+struct eap_sm * eap_server_sm_init(void *eapol_ctx,
+ struct eapol_callbacks *eapol_cb,
+ struct eap_config *eap_conf);
+void eap_server_sm_deinit(struct eap_sm *sm);
+int eap_server_sm_step(struct eap_sm *sm);
+void eap_sm_notify_cached(struct eap_sm *sm);
+void eap_sm_pending_cb(struct eap_sm *sm);
+int eap_sm_method_pending(struct eap_sm *sm);
+const u8 * eap_get_identity(struct eap_sm *sm, size_t *len);
+struct eap_eapol_interface * eap_get_interface(struct eap_sm *sm);
+void eap_server_clear_identity(struct eap_sm *sm);
+
+#endif /* EAP_H */
diff --git a/src/eap_server/eap_i.h b/src/eap_server/eap_i.h
new file mode 100644
index 0000000..daac746
--- /dev/null
+++ b/src/eap_server/eap_i.h
@@ -0,0 +1,201 @@
+/*
+ * hostapd / EAP Authenticator state machine internal structures (RFC 4137)
+ * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef EAP_I_H
+#define EAP_I_H
+
+#include "wpabuf.h"
+#include "eap_server/eap.h"
+#include "eap_common/eap_common.h"
+
+/* RFC 4137 - EAP Standalone Authenticator */
+
+/**
+ * struct eap_method - EAP method interface
+ * This structure defines the EAP method interface. Each method will need to
+ * register its own EAP type, EAP name, and set of function pointers for method
+ * specific operations. This interface is based on section 5.4 of RFC 4137.
+ */
+struct eap_method {
+ int vendor;
+ EapType method;
+ const char *name;
+
+ void * (*init)(struct eap_sm *sm);
+ void * (*initPickUp)(struct eap_sm *sm);
+ void (*reset)(struct eap_sm *sm, void *priv);
+
+ struct wpabuf * (*buildReq)(struct eap_sm *sm, void *priv, u8 id);
+ int (*getTimeout)(struct eap_sm *sm, void *priv);
+ Boolean (*check)(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData);
+ void (*process)(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData);
+ Boolean (*isDone)(struct eap_sm *sm, void *priv);
+ u8 * (*getKey)(struct eap_sm *sm, void *priv, size_t *len);
+ /* isSuccess is not specified in draft-ietf-eap-statemachine-05.txt,
+ * but it is useful in implementing Policy.getDecision() */
+ Boolean (*isSuccess)(struct eap_sm *sm, void *priv);
+
+ /**
+ * free - Free EAP method data
+ * @method: Pointer to the method data registered with
+ * eap_server_method_register().
+ *
+ * This function will be called when the EAP method is being
+ * unregistered. If the EAP method allocated resources during
+ * registration (e.g., allocated struct eap_method), they should be
+ * freed in this function. No other method functions will be called
+ * after this call. If this function is not defined (i.e., function
+ * pointer is %NULL), a default handler is used to release the method
+ * data with free(method). This is suitable for most cases.
+ */
+ void (*free)(struct eap_method *method);
+
+#define EAP_SERVER_METHOD_INTERFACE_VERSION 1
+ /**
+ * version - Version of the EAP server method interface
+ *
+ * The EAP server method implementation should set this variable to
+ * EAP_SERVER_METHOD_INTERFACE_VERSION. This is used to verify that the
+ * EAP method is using supported API version when using dynamically
+ * loadable EAP methods.
+ */
+ int version;
+
+ /**
+ * next - Pointer to the next EAP method
+ *
+ * This variable is used internally in the EAP method registration code
+ * to create a linked list of registered EAP methods.
+ */
+ struct eap_method *next;
+
+ /**
+ * get_emsk - Get EAP method specific keying extended material (EMSK)
+ * @sm: Pointer to EAP state machine allocated with eap_sm_init()
+ * @priv: Pointer to private EAP method data from eap_method::init()
+ * @len: Pointer to a variable to store EMSK length
+ * Returns: EMSK or %NULL if not available
+ *
+ * This function can be used to get the extended keying material from
+ * the EAP method. The key may already be stored in the method-specific
+ * private data or this function may derive the key.
+ */
+ u8 * (*get_emsk)(struct eap_sm *sm, void *priv, size_t *len);
+};
+
+/**
+ * struct eap_sm - EAP server state machine data
+ */
+struct eap_sm {
+ enum {
+ EAP_DISABLED, EAP_INITIALIZE, EAP_IDLE, EAP_RECEIVED,
+ EAP_INTEGRITY_CHECK, EAP_METHOD_RESPONSE, EAP_METHOD_REQUEST,
+ EAP_PROPOSE_METHOD, EAP_SELECT_ACTION, EAP_SEND_REQUEST,
+ EAP_DISCARD, EAP_NAK, EAP_RETRANSMIT, EAP_SUCCESS, EAP_FAILURE,
+ EAP_TIMEOUT_FAILURE, EAP_PICK_UP_METHOD,
+ EAP_INITIALIZE_PASSTHROUGH, EAP_IDLE2, EAP_RETRANSMIT2,
+ EAP_RECEIVED2, EAP_DISCARD2, EAP_SEND_REQUEST2,
+ EAP_AAA_REQUEST, EAP_AAA_RESPONSE, EAP_AAA_IDLE,
+ EAP_TIMEOUT_FAILURE2, EAP_FAILURE2, EAP_SUCCESS2
+ } EAP_state;
+
+ /* Constants */
+ int MaxRetrans;
+
+ struct eap_eapol_interface eap_if;
+
+ /* Full authenticator state machine local variables */
+
+ /* Long-term (maintained betwen packets) */
+ EapType currentMethod;
+ int currentId;
+ enum {
+ METHOD_PROPOSED, METHOD_CONTINUE, METHOD_END
+ } methodState;
+ int retransCount;
+ struct wpabuf *lastReqData;
+ int methodTimeout;
+
+ /* Short-term (not maintained between packets) */
+ Boolean rxResp;
+ int respId;
+ EapType respMethod;
+ int respVendor;
+ u32 respVendorMethod;
+ Boolean ignore;
+ enum {
+ DECISION_SUCCESS, DECISION_FAILURE, DECISION_CONTINUE,
+ DECISION_PASSTHROUGH
+ } decision;
+
+ /* Miscellaneous variables */
+ const struct eap_method *m; /* selected EAP method */
+ /* not defined in RFC 4137 */
+ Boolean changed;
+ void *eapol_ctx, *msg_ctx;
+ struct eapol_callbacks *eapol_cb;
+ void *eap_method_priv;
+ u8 *identity;
+ size_t identity_len;
+ /* Whether Phase 2 method should validate identity match */
+ int require_identity_match;
+ int lastId; /* Identifier used in the last EAP-Packet */
+ struct eap_user *user;
+ int user_eap_method_index;
+ int init_phase2;
+ void *ssl_ctx;
+ void *eap_sim_db_priv;
+ Boolean backend_auth;
+ Boolean update_user;
+ int eap_server;
+
+ int num_rounds;
+ enum {
+ METHOD_PENDING_NONE, METHOD_PENDING_WAIT, METHOD_PENDING_CONT
+ } method_pending;
+
+ u8 *auth_challenge;
+ u8 *peer_challenge;
+
+ u8 *pac_opaque_encr_key;
+ u8 *eap_fast_a_id;
+ size_t eap_fast_a_id_len;
+ char *eap_fast_a_id_info;
+ enum {
+ NO_PROV, ANON_PROV, AUTH_PROV, BOTH_PROV
+ } eap_fast_prov;
+ int pac_key_lifetime;
+ int pac_key_refresh_time;
+ int eap_sim_aka_result_ind;
+ int tnc;
+ u16 pwd_group;
+ struct wps_context *wps;
+ struct wpabuf *assoc_wps_ie;
+ struct wpabuf *assoc_p2p_ie;
+
+ Boolean start_reauth;
+
+ u8 peer_addr[ETH_ALEN];
+
+ /* Fragmentation size for EAP method init() handler */
+ int fragment_size;
+};
+
+int eap_user_get(struct eap_sm *sm, const u8 *identity, size_t identity_len,
+ int phase2);
+void eap_sm_process_nak(struct eap_sm *sm, const u8 *nak_list, size_t len);
+
+#endif /* EAP_I_H */
diff --git a/src/eap_server/eap_methods.h b/src/eap_server/eap_methods.h
new file mode 100644
index 0000000..4a5296e
--- /dev/null
+++ b/src/eap_server/eap_methods.h
@@ -0,0 +1,54 @@
+/*
+ * EAP server method registration
+ * Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef EAP_SERVER_METHODS_H
+#define EAP_SERVER_METHODS_H
+
+#include "eap_common/eap_defs.h"
+
+const struct eap_method * eap_server_get_eap_method(int vendor,
+ EapType method);
+struct eap_method * eap_server_method_alloc(int version, int vendor,
+ EapType method, const char *name);
+void eap_server_method_free(struct eap_method *method);
+int eap_server_method_register(struct eap_method *method);
+
+EapType eap_server_get_type(const char *name, int *vendor);
+void eap_server_unregister_methods(void);
+const char * eap_server_get_name(int vendor, EapType type);
+
+/* EAP server method registration calls for statically linked in methods */
+int eap_server_identity_register(void);
+int eap_server_md5_register(void);
+int eap_server_tls_register(void);
+int eap_server_mschapv2_register(void);
+int eap_server_peap_register(void);
+int eap_server_tlv_register(void);
+int eap_server_gtc_register(void);
+int eap_server_ttls_register(void);
+int eap_server_sim_register(void);
+int eap_server_aka_register(void);
+int eap_server_aka_prime_register(void);
+int eap_server_pax_register(void);
+int eap_server_psk_register(void);
+int eap_server_sake_register(void);
+int eap_server_gpsk_register(void);
+int eap_server_vendor_test_register(void);
+int eap_server_fast_register(void);
+int eap_server_wsc_register(void);
+int eap_server_ikev2_register(void);
+int eap_server_tnc_register(void);
+int eap_server_pwd_register(void);
+
+#endif /* EAP_SERVER_METHODS_H */
diff --git a/src/eap_server/eap_server.c b/src/eap_server/eap_server.c
new file mode 100644
index 0000000..41416b1
--- /dev/null
+++ b/src/eap_server/eap_server.c
@@ -0,0 +1,1384 @@
+/*
+ * hostapd / EAP Full Authenticator state machine (RFC 4137)
+ * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ *
+ * This state machine is based on the full authenticator state machine defined
+ * in RFC 4137. However, to support backend authentication in RADIUS
+ * authentication server functionality, parts of backend authenticator (also
+ * from RFC 4137) are mixed in. This functionality is enabled by setting
+ * backend_auth configuration variable to TRUE.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+#include "state_machine.h"
+#include "common/wpa_ctrl.h"
+
+#define STATE_MACHINE_DATA struct eap_sm
+#define STATE_MACHINE_DEBUG_PREFIX "EAP"
+
+#define EAP_MAX_AUTH_ROUNDS 50
+
+static void eap_user_free(struct eap_user *user);
+
+
+/* EAP state machines are described in RFC 4137 */
+
+static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount,
+ int eapSRTT, int eapRTTVAR,
+ int methodTimeout);
+static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp);
+static int eap_sm_getId(const struct wpabuf *data);
+static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id);
+static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id);
+static int eap_sm_nextId(struct eap_sm *sm, int id);
+static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list,
+ size_t len);
+static EapType eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor);
+static int eap_sm_Policy_getDecision(struct eap_sm *sm);
+static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, EapType method);
+
+
+static int eap_copy_buf(struct wpabuf **dst, const struct wpabuf *src)
+{
+ if (src == NULL)
+ return -1;
+
+ wpabuf_free(*dst);
+ *dst = wpabuf_dup(src);
+ return *dst ? 0 : -1;
+}
+
+
+static int eap_copy_data(u8 **dst, size_t *dst_len,
+ const u8 *src, size_t src_len)
+{
+ if (src == NULL)
+ return -1;
+
+ os_free(*dst);
+ *dst = os_malloc(src_len);
+ if (*dst) {
+ os_memcpy(*dst, src, src_len);
+ *dst_len = src_len;
+ return 0;
+ } else {
+ *dst_len = 0;
+ return -1;
+ }
+}
+
+#define EAP_COPY(dst, src) \
+ eap_copy_data((dst), (dst ## Len), (src), (src ## Len))
+
+
+/**
+ * eap_user_get - Fetch user information from the database
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ * @identity: Identity (User-Name) of the user
+ * @identity_len: Length of identity in bytes
+ * @phase2: 0 = EAP phase1 user, 1 = EAP phase2 (tunneled) user
+ * Returns: 0 on success, or -1 on failure
+ *
+ * This function is used to fetch user information for EAP. The user will be
+ * selected based on the specified identity. sm->user and
+ * sm->user_eap_method_index are updated for the new user when a matching user
+ * is found. sm->user can be used to get user information (e.g., password).
+ */
+int eap_user_get(struct eap_sm *sm, const u8 *identity, size_t identity_len,
+ int phase2)
+{
+ struct eap_user *user;
+
+ if (sm == NULL || sm->eapol_cb == NULL ||
+ sm->eapol_cb->get_eap_user == NULL)
+ return -1;
+
+ eap_user_free(sm->user);
+ sm->user = NULL;
+
+ user = os_zalloc(sizeof(*user));
+ if (user == NULL)
+ return -1;
+
+ if (sm->eapol_cb->get_eap_user(sm->eapol_ctx, identity,
+ identity_len, phase2, user) != 0) {
+ eap_user_free(user);
+ return -1;
+ }
+
+ sm->user = user;
+ sm->user_eap_method_index = 0;
+
+ return 0;
+}
+
+
+SM_STATE(EAP, DISABLED)
+{
+ SM_ENTRY(EAP, DISABLED);
+ sm->num_rounds = 0;
+}
+
+
+SM_STATE(EAP, INITIALIZE)
+{
+ SM_ENTRY(EAP, INITIALIZE);
+
+ sm->currentId = -1;
+ sm->eap_if.eapSuccess = FALSE;
+ sm->eap_if.eapFail = FALSE;
+ sm->eap_if.eapTimeout = FALSE;
+ os_free(sm->eap_if.eapKeyData);
+ sm->eap_if.eapKeyData = NULL;
+ sm->eap_if.eapKeyDataLen = 0;
+ sm->eap_if.eapKeyAvailable = FALSE;
+ sm->eap_if.eapRestart = FALSE;
+
+ /*
+ * This is not defined in RFC 4137, but method state needs to be
+ * reseted here so that it does not remain in success state when
+ * re-authentication starts.
+ */
+ if (sm->m && sm->eap_method_priv) {
+ sm->m->reset(sm, sm->eap_method_priv);
+ sm->eap_method_priv = NULL;
+ }
+ sm->m = NULL;
+ sm->user_eap_method_index = 0;
+
+ if (sm->backend_auth) {
+ sm->currentMethod = EAP_TYPE_NONE;
+ /* parse rxResp, respId, respMethod */
+ eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
+ if (sm->rxResp) {
+ sm->currentId = sm->respId;
+ }
+ }
+ sm->num_rounds = 0;
+ sm->method_pending = METHOD_PENDING_NONE;
+
+ wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_STARTED
+ MACSTR, MAC2STR(sm->peer_addr));
+}
+
+
+SM_STATE(EAP, PICK_UP_METHOD)
+{
+ SM_ENTRY(EAP, PICK_UP_METHOD);
+
+ if (eap_sm_Policy_doPickUp(sm, sm->respMethod)) {
+ sm->currentMethod = sm->respMethod;
+ if (sm->m && sm->eap_method_priv) {
+ sm->m->reset(sm, sm->eap_method_priv);
+ sm->eap_method_priv = NULL;
+ }
+ sm->m = eap_server_get_eap_method(EAP_VENDOR_IETF,
+ sm->currentMethod);
+ if (sm->m && sm->m->initPickUp) {
+ sm->eap_method_priv = sm->m->initPickUp(sm);
+ if (sm->eap_method_priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP: Failed to "
+ "initialize EAP method %d",
+ sm->currentMethod);
+ sm->m = NULL;
+ sm->currentMethod = EAP_TYPE_NONE;
+ }
+ } else {
+ sm->m = NULL;
+ sm->currentMethod = EAP_TYPE_NONE;
+ }
+ }
+
+ wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD
+ "method=%u", sm->currentMethod);
+}
+
+
+SM_STATE(EAP, IDLE)
+{
+ SM_ENTRY(EAP, IDLE);
+
+ sm->eap_if.retransWhile = eap_sm_calculateTimeout(
+ sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR,
+ sm->methodTimeout);
+}
+
+
+SM_STATE(EAP, RETRANSMIT)
+{
+ SM_ENTRY(EAP, RETRANSMIT);
+
+ sm->retransCount++;
+ if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) {
+ if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0)
+ sm->eap_if.eapReq = TRUE;
+ }
+}
+
+
+SM_STATE(EAP, RECEIVED)
+{
+ SM_ENTRY(EAP, RECEIVED);
+
+ /* parse rxResp, respId, respMethod */
+ eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
+ sm->num_rounds++;
+}
+
+
+SM_STATE(EAP, DISCARD)
+{
+ SM_ENTRY(EAP, DISCARD);
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapNoReq = TRUE;
+}
+
+
+SM_STATE(EAP, SEND_REQUEST)
+{
+ SM_ENTRY(EAP, SEND_REQUEST);
+
+ sm->retransCount = 0;
+ if (sm->eap_if.eapReqData) {
+ if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0)
+ {
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapReq = TRUE;
+ } else {
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapReq = FALSE;
+ }
+ } else {
+ wpa_printf(MSG_INFO, "EAP: SEND_REQUEST - no eapReqData");
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapReq = FALSE;
+ sm->eap_if.eapNoReq = TRUE;
+ }
+}
+
+
+SM_STATE(EAP, INTEGRITY_CHECK)
+{
+ SM_ENTRY(EAP, INTEGRITY_CHECK);
+
+ if (sm->m->check) {
+ sm->ignore = sm->m->check(sm, sm->eap_method_priv,
+ sm->eap_if.eapRespData);
+ }
+}
+
+
+SM_STATE(EAP, METHOD_REQUEST)
+{
+ SM_ENTRY(EAP, METHOD_REQUEST);
+
+ if (sm->m == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP: method not initialized");
+ return;
+ }
+
+ sm->currentId = eap_sm_nextId(sm, sm->currentId);
+ wpa_printf(MSG_DEBUG, "EAP: building EAP-Request: Identifier %d",
+ sm->currentId);
+ sm->lastId = sm->currentId;
+ wpabuf_free(sm->eap_if.eapReqData);
+ sm->eap_if.eapReqData = sm->m->buildReq(sm, sm->eap_method_priv,
+ sm->currentId);
+ if (sm->m->getTimeout)
+ sm->methodTimeout = sm->m->getTimeout(sm, sm->eap_method_priv);
+ else
+ sm->methodTimeout = 0;
+}
+
+
+SM_STATE(EAP, METHOD_RESPONSE)
+{
+ SM_ENTRY(EAP, METHOD_RESPONSE);
+
+ sm->m->process(sm, sm->eap_method_priv, sm->eap_if.eapRespData);
+ if (sm->m->isDone(sm, sm->eap_method_priv)) {
+ eap_sm_Policy_update(sm, NULL, 0);
+ os_free(sm->eap_if.eapKeyData);
+ if (sm->m->getKey) {
+ sm->eap_if.eapKeyData = sm->m->getKey(
+ sm, sm->eap_method_priv,
+ &sm->eap_if.eapKeyDataLen);
+ } else {
+ sm->eap_if.eapKeyData = NULL;
+ sm->eap_if.eapKeyDataLen = 0;
+ }
+ sm->methodState = METHOD_END;
+ } else {
+ sm->methodState = METHOD_CONTINUE;
+ }
+}
+
+
+SM_STATE(EAP, PROPOSE_METHOD)
+{
+ int vendor;
+ EapType type;
+
+ SM_ENTRY(EAP, PROPOSE_METHOD);
+
+ type = eap_sm_Policy_getNextMethod(sm, &vendor);
+ if (vendor == EAP_VENDOR_IETF)
+ sm->currentMethod = type;
+ else
+ sm->currentMethod = EAP_TYPE_EXPANDED;
+ if (sm->m && sm->eap_method_priv) {
+ sm->m->reset(sm, sm->eap_method_priv);
+ sm->eap_method_priv = NULL;
+ }
+ sm->m = eap_server_get_eap_method(vendor, type);
+ if (sm->m) {
+ sm->eap_method_priv = sm->m->init(sm);
+ if (sm->eap_method_priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP: Failed to initialize EAP "
+ "method %d", sm->currentMethod);
+ sm->m = NULL;
+ sm->currentMethod = EAP_TYPE_NONE;
+ }
+ }
+ if (sm->currentMethod == EAP_TYPE_IDENTITY ||
+ sm->currentMethod == EAP_TYPE_NOTIFICATION)
+ sm->methodState = METHOD_CONTINUE;
+ else
+ sm->methodState = METHOD_PROPOSED;
+
+ wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD
+ "vendor=%u method=%u", vendor, sm->currentMethod);
+}
+
+
+SM_STATE(EAP, NAK)
+{
+ const struct eap_hdr *nak;
+ size_t len = 0;
+ const u8 *pos;
+ const u8 *nak_list = NULL;
+
+ SM_ENTRY(EAP, NAK);
+
+ if (sm->eap_method_priv) {
+ sm->m->reset(sm, sm->eap_method_priv);
+ sm->eap_method_priv = NULL;
+ }
+ sm->m = NULL;
+
+ nak = wpabuf_head(sm->eap_if.eapRespData);
+ if (nak && wpabuf_len(sm->eap_if.eapRespData) > sizeof(*nak)) {
+ len = be_to_host16(nak->length);
+ if (len > wpabuf_len(sm->eap_if.eapRespData))
+ len = wpabuf_len(sm->eap_if.eapRespData);
+ pos = (const u8 *) (nak + 1);
+ len -= sizeof(*nak);
+ if (*pos == EAP_TYPE_NAK) {
+ pos++;
+ len--;
+ nak_list = pos;
+ }
+ }
+ eap_sm_Policy_update(sm, nak_list, len);
+}
+
+
+SM_STATE(EAP, SELECT_ACTION)
+{
+ SM_ENTRY(EAP, SELECT_ACTION);
+
+ sm->decision = eap_sm_Policy_getDecision(sm);
+}
+
+
+SM_STATE(EAP, TIMEOUT_FAILURE)
+{
+ SM_ENTRY(EAP, TIMEOUT_FAILURE);
+
+ sm->eap_if.eapTimeout = TRUE;
+}
+
+
+SM_STATE(EAP, FAILURE)
+{
+ SM_ENTRY(EAP, FAILURE);
+
+ wpabuf_free(sm->eap_if.eapReqData);
+ sm->eap_if.eapReqData = eap_sm_buildFailure(sm, sm->currentId);
+ wpabuf_free(sm->lastReqData);
+ sm->lastReqData = NULL;
+ sm->eap_if.eapFail = TRUE;
+
+ wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE
+ MACSTR, MAC2STR(sm->peer_addr));
+}
+
+
+SM_STATE(EAP, SUCCESS)
+{
+ SM_ENTRY(EAP, SUCCESS);
+
+ wpabuf_free(sm->eap_if.eapReqData);
+ sm->eap_if.eapReqData = eap_sm_buildSuccess(sm, sm->currentId);
+ wpabuf_free(sm->lastReqData);
+ sm->lastReqData = NULL;
+ if (sm->eap_if.eapKeyData)
+ sm->eap_if.eapKeyAvailable = TRUE;
+ sm->eap_if.eapSuccess = TRUE;
+
+ wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS
+ MACSTR, MAC2STR(sm->peer_addr));
+}
+
+
+SM_STATE(EAP, INITIALIZE_PASSTHROUGH)
+{
+ SM_ENTRY(EAP, INITIALIZE_PASSTHROUGH);
+
+ wpabuf_free(sm->eap_if.aaaEapRespData);
+ sm->eap_if.aaaEapRespData = NULL;
+}
+
+
+SM_STATE(EAP, IDLE2)
+{
+ SM_ENTRY(EAP, IDLE2);
+
+ sm->eap_if.retransWhile = eap_sm_calculateTimeout(
+ sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR,
+ sm->methodTimeout);
+}
+
+
+SM_STATE(EAP, RETRANSMIT2)
+{
+ SM_ENTRY(EAP, RETRANSMIT2);
+
+ sm->retransCount++;
+ if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) {
+ if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0)
+ sm->eap_if.eapReq = TRUE;
+ }
+}
+
+
+SM_STATE(EAP, RECEIVED2)
+{
+ SM_ENTRY(EAP, RECEIVED2);
+
+ /* parse rxResp, respId, respMethod */
+ eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
+}
+
+
+SM_STATE(EAP, DISCARD2)
+{
+ SM_ENTRY(EAP, DISCARD2);
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapNoReq = TRUE;
+}
+
+
+SM_STATE(EAP, SEND_REQUEST2)
+{
+ SM_ENTRY(EAP, SEND_REQUEST2);
+
+ sm->retransCount = 0;
+ if (sm->eap_if.eapReqData) {
+ if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0)
+ {
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapReq = TRUE;
+ } else {
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapReq = FALSE;
+ }
+ } else {
+ wpa_printf(MSG_INFO, "EAP: SEND_REQUEST2 - no eapReqData");
+ sm->eap_if.eapResp = FALSE;
+ sm->eap_if.eapReq = FALSE;
+ sm->eap_if.eapNoReq = TRUE;
+ }
+}
+
+
+SM_STATE(EAP, AAA_REQUEST)
+{
+ SM_ENTRY(EAP, AAA_REQUEST);
+
+ if (sm->eap_if.eapRespData == NULL) {
+ wpa_printf(MSG_INFO, "EAP: AAA_REQUEST - no eapRespData");
+ return;
+ }
+
+ /*
+ * if (respMethod == IDENTITY)
+ * aaaIdentity = eapRespData
+ * This is already taken care of by the EAP-Identity method which
+ * stores the identity into sm->identity.
+ */
+
+ eap_copy_buf(&sm->eap_if.aaaEapRespData, sm->eap_if.eapRespData);
+}
+
+
+SM_STATE(EAP, AAA_RESPONSE)
+{
+ SM_ENTRY(EAP, AAA_RESPONSE);
+
+ eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
+ sm->currentId = eap_sm_getId(sm->eap_if.eapReqData);
+ sm->methodTimeout = sm->eap_if.aaaMethodTimeout;
+}
+
+
+SM_STATE(EAP, AAA_IDLE)
+{
+ SM_ENTRY(EAP, AAA_IDLE);
+
+ sm->eap_if.aaaFail = FALSE;
+ sm->eap_if.aaaSuccess = FALSE;
+ sm->eap_if.aaaEapReq = FALSE;
+ sm->eap_if.aaaEapNoReq = FALSE;
+ sm->eap_if.aaaEapResp = TRUE;
+}
+
+
+SM_STATE(EAP, TIMEOUT_FAILURE2)
+{
+ SM_ENTRY(EAP, TIMEOUT_FAILURE2);
+
+ sm->eap_if.eapTimeout = TRUE;
+}
+
+
+SM_STATE(EAP, FAILURE2)
+{
+ SM_ENTRY(EAP, FAILURE2);
+
+ eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
+ sm->eap_if.eapFail = TRUE;
+}
+
+
+SM_STATE(EAP, SUCCESS2)
+{
+ SM_ENTRY(EAP, SUCCESS2);
+
+ eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
+
+ sm->eap_if.eapKeyAvailable = sm->eap_if.aaaEapKeyAvailable;
+ if (sm->eap_if.aaaEapKeyAvailable) {
+ EAP_COPY(&sm->eap_if.eapKeyData, sm->eap_if.aaaEapKeyData);
+ } else {
+ os_free(sm->eap_if.eapKeyData);
+ sm->eap_if.eapKeyData = NULL;
+ sm->eap_if.eapKeyDataLen = 0;
+ }
+
+ sm->eap_if.eapSuccess = TRUE;
+
+ /*
+ * Start reauthentication with identity request even though we know the
+ * previously used identity. This is needed to get reauthentication
+ * started properly.
+ */
+ sm->start_reauth = TRUE;
+}
+
+
+SM_STEP(EAP)
+{
+ if (sm->eap_if.eapRestart && sm->eap_if.portEnabled)
+ SM_ENTER_GLOBAL(EAP, INITIALIZE);
+ else if (!sm->eap_if.portEnabled)
+ SM_ENTER_GLOBAL(EAP, DISABLED);
+ else if (sm->num_rounds > EAP_MAX_AUTH_ROUNDS) {
+ if (sm->num_rounds == EAP_MAX_AUTH_ROUNDS + 1) {
+ wpa_printf(MSG_DEBUG, "EAP: more than %d "
+ "authentication rounds - abort",
+ EAP_MAX_AUTH_ROUNDS);
+ sm->num_rounds++;
+ SM_ENTER_GLOBAL(EAP, FAILURE);
+ }
+ } else switch (sm->EAP_state) {
+ case EAP_INITIALIZE:
+ if (sm->backend_auth) {
+ if (!sm->rxResp)
+ SM_ENTER(EAP, SELECT_ACTION);
+ else if (sm->rxResp &&
+ (sm->respMethod == EAP_TYPE_NAK ||
+ (sm->respMethod == EAP_TYPE_EXPANDED &&
+ sm->respVendor == EAP_VENDOR_IETF &&
+ sm->respVendorMethod == EAP_TYPE_NAK)))
+ SM_ENTER(EAP, NAK);
+ else
+ SM_ENTER(EAP, PICK_UP_METHOD);
+ } else {
+ SM_ENTER(EAP, SELECT_ACTION);
+ }
+ break;
+ case EAP_PICK_UP_METHOD:
+ if (sm->currentMethod == EAP_TYPE_NONE) {
+ SM_ENTER(EAP, SELECT_ACTION);
+ } else {
+ SM_ENTER(EAP, METHOD_RESPONSE);
+ }
+ break;
+ case EAP_DISABLED:
+ if (sm->eap_if.portEnabled)
+ SM_ENTER(EAP, INITIALIZE);
+ break;
+ case EAP_IDLE:
+ if (sm->eap_if.retransWhile == 0)
+ SM_ENTER(EAP, RETRANSMIT);
+ else if (sm->eap_if.eapResp)
+ SM_ENTER(EAP, RECEIVED);
+ break;
+ case EAP_RETRANSMIT:
+ if (sm->retransCount > sm->MaxRetrans)
+ SM_ENTER(EAP, TIMEOUT_FAILURE);
+ else
+ SM_ENTER(EAP, IDLE);
+ break;
+ case EAP_RECEIVED:
+ if (sm->rxResp && (sm->respId == sm->currentId) &&
+ (sm->respMethod == EAP_TYPE_NAK ||
+ (sm->respMethod == EAP_TYPE_EXPANDED &&
+ sm->respVendor == EAP_VENDOR_IETF &&
+ sm->respVendorMethod == EAP_TYPE_NAK))
+ && (sm->methodState == METHOD_PROPOSED))
+ SM_ENTER(EAP, NAK);
+ else if (sm->rxResp && (sm->respId == sm->currentId) &&
+ ((sm->respMethod == sm->currentMethod) ||
+ (sm->respMethod == EAP_TYPE_EXPANDED &&
+ sm->respVendor == EAP_VENDOR_IETF &&
+ sm->respVendorMethod == sm->currentMethod)))
+ SM_ENTER(EAP, INTEGRITY_CHECK);
+ else {
+ wpa_printf(MSG_DEBUG, "EAP: RECEIVED->DISCARD: "
+ "rxResp=%d respId=%d currentId=%d "
+ "respMethod=%d currentMethod=%d",
+ sm->rxResp, sm->respId, sm->currentId,
+ sm->respMethod, sm->currentMethod);
+ SM_ENTER(EAP, DISCARD);
+ }
+ break;
+ case EAP_DISCARD:
+ SM_ENTER(EAP, IDLE);
+ break;
+ case EAP_SEND_REQUEST:
+ SM_ENTER(EAP, IDLE);
+ break;
+ case EAP_INTEGRITY_CHECK:
+ if (sm->ignore)
+ SM_ENTER(EAP, DISCARD);
+ else
+ SM_ENTER(EAP, METHOD_RESPONSE);
+ break;
+ case EAP_METHOD_REQUEST:
+ SM_ENTER(EAP, SEND_REQUEST);
+ break;
+ case EAP_METHOD_RESPONSE:
+ /*
+ * Note: Mechanism to allow EAP methods to wait while going
+ * through pending processing is an extension to RFC 4137
+ * which only defines the transits to SELECT_ACTION and
+ * METHOD_REQUEST from this METHOD_RESPONSE state.
+ */
+ if (sm->methodState == METHOD_END)
+ SM_ENTER(EAP, SELECT_ACTION);
+ else if (sm->method_pending == METHOD_PENDING_WAIT) {
+ wpa_printf(MSG_DEBUG, "EAP: Method has pending "
+ "processing - wait before proceeding to "
+ "METHOD_REQUEST state");
+ } else if (sm->method_pending == METHOD_PENDING_CONT) {
+ wpa_printf(MSG_DEBUG, "EAP: Method has completed "
+ "pending processing - reprocess pending "
+ "EAP message");
+ sm->method_pending = METHOD_PENDING_NONE;
+ SM_ENTER(EAP, METHOD_RESPONSE);
+ } else
+ SM_ENTER(EAP, METHOD_REQUEST);
+ break;
+ case EAP_PROPOSE_METHOD:
+ /*
+ * Note: Mechanism to allow EAP methods to wait while going
+ * through pending processing is an extension to RFC 4137
+ * which only defines the transit to METHOD_REQUEST from this
+ * PROPOSE_METHOD state.
+ */
+ if (sm->method_pending == METHOD_PENDING_WAIT) {
+ wpa_printf(MSG_DEBUG, "EAP: Method has pending "
+ "processing - wait before proceeding to "
+ "METHOD_REQUEST state");
+ if (sm->user_eap_method_index > 0)
+ sm->user_eap_method_index--;
+ } else if (sm->method_pending == METHOD_PENDING_CONT) {
+ wpa_printf(MSG_DEBUG, "EAP: Method has completed "
+ "pending processing - reprocess pending "
+ "EAP message");
+ sm->method_pending = METHOD_PENDING_NONE;
+ SM_ENTER(EAP, PROPOSE_METHOD);
+ } else
+ SM_ENTER(EAP, METHOD_REQUEST);
+ break;
+ case EAP_NAK:
+ SM_ENTER(EAP, SELECT_ACTION);
+ break;
+ case EAP_SELECT_ACTION:
+ if (sm->decision == DECISION_FAILURE)
+ SM_ENTER(EAP, FAILURE);
+ else if (sm->decision == DECISION_SUCCESS)
+ SM_ENTER(EAP, SUCCESS);
+ else if (sm->decision == DECISION_PASSTHROUGH)
+ SM_ENTER(EAP, INITIALIZE_PASSTHROUGH);
+ else
+ SM_ENTER(EAP, PROPOSE_METHOD);
+ break;
+ case EAP_TIMEOUT_FAILURE:
+ break;
+ case EAP_FAILURE:
+ break;
+ case EAP_SUCCESS:
+ break;
+
+ case EAP_INITIALIZE_PASSTHROUGH:
+ if (sm->currentId == -1)
+ SM_ENTER(EAP, AAA_IDLE);
+ else
+ SM_ENTER(EAP, AAA_REQUEST);
+ break;
+ case EAP_IDLE2:
+ if (sm->eap_if.eapResp)
+ SM_ENTER(EAP, RECEIVED2);
+ else if (sm->eap_if.retransWhile == 0)
+ SM_ENTER(EAP, RETRANSMIT2);
+ break;
+ case EAP_RETRANSMIT2:
+ if (sm->retransCount > sm->MaxRetrans)
+ SM_ENTER(EAP, TIMEOUT_FAILURE2);
+ else
+ SM_ENTER(EAP, IDLE2);
+ break;
+ case EAP_RECEIVED2:
+ if (sm->rxResp && (sm->respId == sm->currentId))
+ SM_ENTER(EAP, AAA_REQUEST);
+ else
+ SM_ENTER(EAP, DISCARD2);
+ break;
+ case EAP_DISCARD2:
+ SM_ENTER(EAP, IDLE2);
+ break;
+ case EAP_SEND_REQUEST2:
+ SM_ENTER(EAP, IDLE2);
+ break;
+ case EAP_AAA_REQUEST:
+ SM_ENTER(EAP, AAA_IDLE);
+ break;
+ case EAP_AAA_RESPONSE:
+ SM_ENTER(EAP, SEND_REQUEST2);
+ break;
+ case EAP_AAA_IDLE:
+ if (sm->eap_if.aaaFail)
+ SM_ENTER(EAP, FAILURE2);
+ else if (sm->eap_if.aaaSuccess)
+ SM_ENTER(EAP, SUCCESS2);
+ else if (sm->eap_if.aaaEapReq)
+ SM_ENTER(EAP, AAA_RESPONSE);
+ else if (sm->eap_if.aaaTimeout)
+ SM_ENTER(EAP, TIMEOUT_FAILURE2);
+ break;
+ case EAP_TIMEOUT_FAILURE2:
+ break;
+ case EAP_FAILURE2:
+ break;
+ case EAP_SUCCESS2:
+ break;
+ }
+}
+
+
+static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount,
+ int eapSRTT, int eapRTTVAR,
+ int methodTimeout)
+{
+ int rto, i;
+
+ if (methodTimeout) {
+ /*
+ * EAP method (either internal or through AAA server, provided
+ * timeout hint. Use that as-is as a timeout for retransmitting
+ * the EAP request if no response is received.
+ */
+ wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds "
+ "(from EAP method hint)", methodTimeout);
+ return methodTimeout;
+ }
+
+ /*
+ * RFC 3748 recommends algorithms described in RFC 2988 for estimation
+ * of the retransmission timeout. This should be implemented once
+ * round-trip time measurements are available. For nowm a simple
+ * backoff mechanism is used instead if there are no EAP method
+ * specific hints.
+ *
+ * SRTT = smoothed round-trip time
+ * RTTVAR = round-trip time variation
+ * RTO = retransmission timeout
+ */
+
+ /*
+ * RFC 2988, 2.1: before RTT measurement, set RTO to 3 seconds for
+ * initial retransmission and then double the RTO to provide back off
+ * per 5.5. Limit the maximum RTO to 20 seconds per RFC 3748, 4.3
+ * modified RTOmax.
+ */
+ rto = 3;
+ for (i = 0; i < retransCount; i++) {
+ rto *= 2;
+ if (rto >= 20) {
+ rto = 20;
+ break;
+ }
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds "
+ "(from dynamic back off; retransCount=%d)",
+ rto, retransCount);
+
+ return rto;
+}
+
+
+static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp)
+{
+ const struct eap_hdr *hdr;
+ size_t plen;
+
+ /* parse rxResp, respId, respMethod */
+ sm->rxResp = FALSE;
+ sm->respId = -1;
+ sm->respMethod = EAP_TYPE_NONE;
+ sm->respVendor = EAP_VENDOR_IETF;
+ sm->respVendorMethod = EAP_TYPE_NONE;
+
+ if (resp == NULL || wpabuf_len(resp) < sizeof(*hdr)) {
+ wpa_printf(MSG_DEBUG, "EAP: parseEapResp: invalid resp=%p "
+ "len=%lu", resp,
+ resp ? (unsigned long) wpabuf_len(resp) : 0);
+ return;
+ }
+
+ hdr = wpabuf_head(resp);
+ plen = be_to_host16(hdr->length);
+ if (plen > wpabuf_len(resp)) {
+ wpa_printf(MSG_DEBUG, "EAP: Ignored truncated EAP-Packet "
+ "(len=%lu plen=%lu)",
+ (unsigned long) wpabuf_len(resp),
+ (unsigned long) plen);
+ return;
+ }
+
+ sm->respId = hdr->identifier;
+
+ if (hdr->code == EAP_CODE_RESPONSE)
+ sm->rxResp = TRUE;
+
+ if (plen > sizeof(*hdr)) {
+ u8 *pos = (u8 *) (hdr + 1);
+ sm->respMethod = *pos++;
+ if (sm->respMethod == EAP_TYPE_EXPANDED) {
+ if (plen < sizeof(*hdr) + 8) {
+ wpa_printf(MSG_DEBUG, "EAP: Ignored truncated "
+ "expanded EAP-Packet (plen=%lu)",
+ (unsigned long) plen);
+ return;
+ }
+ sm->respVendor = WPA_GET_BE24(pos);
+ pos += 3;
+ sm->respVendorMethod = WPA_GET_BE32(pos);
+ }
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP: parseEapResp: rxResp=%d respId=%d "
+ "respMethod=%u respVendor=%u respVendorMethod=%u",
+ sm->rxResp, sm->respId, sm->respMethod, sm->respVendor,
+ sm->respVendorMethod);
+}
+
+
+static int eap_sm_getId(const struct wpabuf *data)
+{
+ const struct eap_hdr *hdr;
+
+ if (data == NULL || wpabuf_len(data) < sizeof(*hdr))
+ return -1;
+
+ hdr = wpabuf_head(data);
+ wpa_printf(MSG_DEBUG, "EAP: getId: id=%d", hdr->identifier);
+ return hdr->identifier;
+}
+
+
+static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id)
+{
+ struct wpabuf *msg;
+ struct eap_hdr *resp;
+ wpa_printf(MSG_DEBUG, "EAP: Building EAP-Success (id=%d)", id);
+
+ msg = wpabuf_alloc(sizeof(*resp));
+ if (msg == NULL)
+ return NULL;
+ resp = wpabuf_put(msg, sizeof(*resp));
+ resp->code = EAP_CODE_SUCCESS;
+ resp->identifier = id;
+ resp->length = host_to_be16(sizeof(*resp));
+
+ return msg;
+}
+
+
+static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id)
+{
+ struct wpabuf *msg;
+ struct eap_hdr *resp;
+ wpa_printf(MSG_DEBUG, "EAP: Building EAP-Failure (id=%d)", id);
+
+ msg = wpabuf_alloc(sizeof(*resp));
+ if (msg == NULL)
+ return NULL;
+ resp = wpabuf_put(msg, sizeof(*resp));
+ resp->code = EAP_CODE_FAILURE;
+ resp->identifier = id;
+ resp->length = host_to_be16(sizeof(*resp));
+
+ return msg;
+}
+
+
+static int eap_sm_nextId(struct eap_sm *sm, int id)
+{
+ if (id < 0) {
+ /* RFC 3748 Ch 4.1: recommended to initialize Identifier with a
+ * random number */
+ id = rand() & 0xff;
+ if (id != sm->lastId)
+ return id;
+ }
+ return (id + 1) & 0xff;
+}
+
+
+/**
+ * eap_sm_process_nak - Process EAP-Response/Nak
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ * @nak_list: Nak list (allowed methods) from the supplicant
+ * @len: Length of nak_list in bytes
+ *
+ * This function is called when EAP-Response/Nak is received from the
+ * supplicant. This can happen for both phase 1 and phase 2 authentications.
+ */
+void eap_sm_process_nak(struct eap_sm *sm, const u8 *nak_list, size_t len)
+{
+ int i;
+ size_t j;
+
+ if (sm->user == NULL)
+ return;
+
+ wpa_printf(MSG_MSGDUMP, "EAP: processing NAK (current EAP method "
+ "index %d)", sm->user_eap_method_index);
+
+ wpa_hexdump(MSG_MSGDUMP, "EAP: configured methods",
+ (u8 *) sm->user->methods,
+ EAP_MAX_METHODS * sizeof(sm->user->methods[0]));
+ wpa_hexdump(MSG_MSGDUMP, "EAP: list of methods supported by the peer",
+ nak_list, len);
+
+ i = sm->user_eap_method_index;
+ while (i < EAP_MAX_METHODS &&
+ (sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[i].method != EAP_TYPE_NONE)) {
+ if (sm->user->methods[i].vendor != EAP_VENDOR_IETF)
+ goto not_found;
+ for (j = 0; j < len; j++) {
+ if (nak_list[j] == sm->user->methods[i].method) {
+ break;
+ }
+ }
+
+ if (j < len) {
+ /* found */
+ i++;
+ continue;
+ }
+
+ not_found:
+ /* not found - remove from the list */
+ os_memmove(&sm->user->methods[i], &sm->user->methods[i + 1],
+ (EAP_MAX_METHODS - i - 1) *
+ sizeof(sm->user->methods[0]));
+ sm->user->methods[EAP_MAX_METHODS - 1].vendor =
+ EAP_VENDOR_IETF;
+ sm->user->methods[EAP_MAX_METHODS - 1].method = EAP_TYPE_NONE;
+ }
+
+ wpa_hexdump(MSG_MSGDUMP, "EAP: new list of configured methods",
+ (u8 *) sm->user->methods, EAP_MAX_METHODS *
+ sizeof(sm->user->methods[0]));
+}
+
+
+static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list,
+ size_t len)
+{
+ if (nak_list == NULL || sm == NULL || sm->user == NULL)
+ return;
+
+ if (sm->user->phase2) {
+ wpa_printf(MSG_DEBUG, "EAP: EAP-Nak received after Phase2 user"
+ " info was selected - reject");
+ sm->decision = DECISION_FAILURE;
+ return;
+ }
+
+ eap_sm_process_nak(sm, nak_list, len);
+}
+
+
+static EapType eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor)
+{
+ EapType next;
+ int idx = sm->user_eap_method_index;
+
+ /* In theory, there should be no problems with starting
+ * re-authentication with something else than EAP-Request/Identity and
+ * this does indeed work with wpa_supplicant. However, at least Funk
+ * Supplicant seemed to ignore re-auth if it skipped
+ * EAP-Request/Identity.
+ * Re-auth sets currentId == -1, so that can be used here to select
+ * whether Identity needs to be requested again. */
+ if (sm->identity == NULL || sm->currentId == -1) {
+ *vendor = EAP_VENDOR_IETF;
+ next = EAP_TYPE_IDENTITY;
+ sm->update_user = TRUE;
+ } else if (sm->user && idx < EAP_MAX_METHODS &&
+ (sm->user->methods[idx].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[idx].method != EAP_TYPE_NONE)) {
+ *vendor = sm->user->methods[idx].vendor;
+ next = sm->user->methods[idx].method;
+ sm->user_eap_method_index++;
+ } else {
+ *vendor = EAP_VENDOR_IETF;
+ next = EAP_TYPE_NONE;
+ }
+ wpa_printf(MSG_DEBUG, "EAP: getNextMethod: vendor %d type %d",
+ *vendor, next);
+ return next;
+}
+
+
+static int eap_sm_Policy_getDecision(struct eap_sm *sm)
+{
+ if (!sm->eap_server && sm->identity && !sm->start_reauth) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: -> PASSTHROUGH");
+ return DECISION_PASSTHROUGH;
+ }
+
+ if (sm->m && sm->currentMethod != EAP_TYPE_IDENTITY &&
+ sm->m->isSuccess(sm, sm->eap_method_priv)) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: method succeeded -> "
+ "SUCCESS");
+ sm->update_user = TRUE;
+ return DECISION_SUCCESS;
+ }
+
+ if (sm->m && sm->m->isDone(sm, sm->eap_method_priv) &&
+ !sm->m->isSuccess(sm, sm->eap_method_priv)) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: method failed -> "
+ "FAILURE");
+ sm->update_user = TRUE;
+ return DECISION_FAILURE;
+ }
+
+ if ((sm->user == NULL || sm->update_user) && sm->identity &&
+ !sm->start_reauth) {
+ /*
+ * Allow Identity method to be started once to allow identity
+ * selection hint to be sent from the authentication server,
+ * but prevent a loop of Identity requests by only allowing
+ * this to happen once.
+ */
+ int id_req = 0;
+ if (sm->user && sm->currentMethod == EAP_TYPE_IDENTITY &&
+ sm->user->methods[0].vendor == EAP_VENDOR_IETF &&
+ sm->user->methods[0].method == EAP_TYPE_IDENTITY)
+ id_req = 1;
+ if (eap_user_get(sm, sm->identity, sm->identity_len, 0) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: user not "
+ "found from database -> FAILURE");
+ return DECISION_FAILURE;
+ }
+ if (id_req && sm->user &&
+ sm->user->methods[0].vendor == EAP_VENDOR_IETF &&
+ sm->user->methods[0].method == EAP_TYPE_IDENTITY) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: stop "
+ "identity request loop -> FAILURE");
+ sm->update_user = TRUE;
+ return DECISION_FAILURE;
+ }
+ sm->update_user = FALSE;
+ }
+ sm->start_reauth = FALSE;
+
+ if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
+ (sm->user->methods[sm->user_eap_method_index].vendor !=
+ EAP_VENDOR_IETF ||
+ sm->user->methods[sm->user_eap_method_index].method !=
+ EAP_TYPE_NONE)) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: another method "
+ "available -> CONTINUE");
+ return DECISION_CONTINUE;
+ }
+
+ if (sm->identity == NULL || sm->currentId == -1) {
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: no identity known "
+ "yet -> CONTINUE");
+ return DECISION_CONTINUE;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP: getDecision: no more methods available -> "
+ "FAILURE");
+ return DECISION_FAILURE;
+}
+
+
+static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, EapType method)
+{
+ return method == EAP_TYPE_IDENTITY ? TRUE : FALSE;
+}
+
+
+/**
+ * eap_server_sm_step - Step EAP server state machine
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ * Returns: 1 if EAP state was changed or 0 if not
+ *
+ * This function advances EAP state machine to a new state to match with the
+ * current variables. This should be called whenever variables used by the EAP
+ * state machine have changed.
+ */
+int eap_server_sm_step(struct eap_sm *sm)
+{
+ int res = 0;
+ do {
+ sm->changed = FALSE;
+ SM_STEP_RUN(EAP);
+ if (sm->changed)
+ res = 1;
+ } while (sm->changed);
+ return res;
+}
+
+
+static void eap_user_free(struct eap_user *user)
+{
+ if (user == NULL)
+ return;
+ os_free(user->password);
+ user->password = NULL;
+ os_free(user);
+}
+
+
+/**
+ * eap_server_sm_init - Allocate and initialize EAP server state machine
+ * @eapol_ctx: Context data to be used with eapol_cb calls
+ * @eapol_cb: Pointer to EAPOL callback functions
+ * @conf: EAP configuration
+ * Returns: Pointer to the allocated EAP state machine or %NULL on failure
+ *
+ * This function allocates and initializes an EAP state machine.
+ */
+struct eap_sm * eap_server_sm_init(void *eapol_ctx,
+ struct eapol_callbacks *eapol_cb,
+ struct eap_config *conf)
+{
+ struct eap_sm *sm;
+
+ sm = os_zalloc(sizeof(*sm));
+ if (sm == NULL)
+ return NULL;
+ sm->eapol_ctx = eapol_ctx;
+ sm->eapol_cb = eapol_cb;
+ sm->MaxRetrans = 5; /* RFC 3748: max 3-5 retransmissions suggested */
+ sm->ssl_ctx = conf->ssl_ctx;
+ sm->msg_ctx = conf->msg_ctx;
+ sm->eap_sim_db_priv = conf->eap_sim_db_priv;
+ sm->backend_auth = conf->backend_auth;
+ sm->eap_server = conf->eap_server;
+ if (conf->pac_opaque_encr_key) {
+ sm->pac_opaque_encr_key = os_malloc(16);
+ if (sm->pac_opaque_encr_key) {
+ os_memcpy(sm->pac_opaque_encr_key,
+ conf->pac_opaque_encr_key, 16);
+ }
+ }
+ if (conf->eap_fast_a_id) {
+ sm->eap_fast_a_id = os_malloc(conf->eap_fast_a_id_len);
+ if (sm->eap_fast_a_id) {
+ os_memcpy(sm->eap_fast_a_id, conf->eap_fast_a_id,
+ conf->eap_fast_a_id_len);
+ sm->eap_fast_a_id_len = conf->eap_fast_a_id_len;
+ }
+ }
+ if (conf->eap_fast_a_id_info)
+ sm->eap_fast_a_id_info = os_strdup(conf->eap_fast_a_id_info);
+ sm->eap_fast_prov = conf->eap_fast_prov;
+ sm->pac_key_lifetime = conf->pac_key_lifetime;
+ sm->pac_key_refresh_time = conf->pac_key_refresh_time;
+ sm->eap_sim_aka_result_ind = conf->eap_sim_aka_result_ind;
+ sm->tnc = conf->tnc;
+ sm->wps = conf->wps;
+ if (conf->assoc_wps_ie)
+ sm->assoc_wps_ie = wpabuf_dup(conf->assoc_wps_ie);
+ if (conf->assoc_p2p_ie)
+ sm->assoc_p2p_ie = wpabuf_dup(conf->assoc_p2p_ie);
+ if (conf->peer_addr)
+ os_memcpy(sm->peer_addr, conf->peer_addr, ETH_ALEN);
+ sm->fragment_size = conf->fragment_size;
+ sm->pwd_group = conf->pwd_group;
+
+ wpa_printf(MSG_DEBUG, "EAP: Server state machine created");
+
+ return sm;
+}
+
+
+/**
+ * eap_server_sm_deinit - Deinitialize and free an EAP server state machine
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ *
+ * This function deinitializes EAP state machine and frees all allocated
+ * resources.
+ */
+void eap_server_sm_deinit(struct eap_sm *sm)
+{
+ if (sm == NULL)
+ return;
+ wpa_printf(MSG_DEBUG, "EAP: Server state machine removed");
+ if (sm->m && sm->eap_method_priv)
+ sm->m->reset(sm, sm->eap_method_priv);
+ wpabuf_free(sm->eap_if.eapReqData);
+ os_free(sm->eap_if.eapKeyData);
+ wpabuf_free(sm->lastReqData);
+ wpabuf_free(sm->eap_if.eapRespData);
+ os_free(sm->identity);
+ os_free(sm->pac_opaque_encr_key);
+ os_free(sm->eap_fast_a_id);
+ os_free(sm->eap_fast_a_id_info);
+ wpabuf_free(sm->eap_if.aaaEapReqData);
+ wpabuf_free(sm->eap_if.aaaEapRespData);
+ os_free(sm->eap_if.aaaEapKeyData);
+ eap_user_free(sm->user);
+ wpabuf_free(sm->assoc_wps_ie);
+ wpabuf_free(sm->assoc_p2p_ie);
+ os_free(sm);
+}
+
+
+/**
+ * eap_sm_notify_cached - Notify EAP state machine of cached PMK
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ *
+ * This function is called when PMKSA caching is used to skip EAP
+ * authentication.
+ */
+void eap_sm_notify_cached(struct eap_sm *sm)
+{
+ if (sm == NULL)
+ return;
+
+ sm->EAP_state = EAP_SUCCESS;
+}
+
+
+/**
+ * eap_sm_pending_cb - EAP state machine callback for a pending EAP request
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ *
+ * This function is called when data for a pending EAP-Request is received.
+ */
+void eap_sm_pending_cb(struct eap_sm *sm)
+{
+ if (sm == NULL)
+ return;
+ wpa_printf(MSG_DEBUG, "EAP: Callback for pending request received");
+ if (sm->method_pending == METHOD_PENDING_WAIT)
+ sm->method_pending = METHOD_PENDING_CONT;
+}
+
+
+/**
+ * eap_sm_method_pending - Query whether EAP method is waiting for pending data
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ * Returns: 1 if method is waiting for pending data or 0 if not
+ */
+int eap_sm_method_pending(struct eap_sm *sm)
+{
+ if (sm == NULL)
+ return 0;
+ return sm->method_pending == METHOD_PENDING_WAIT;
+}
+
+
+/**
+ * eap_get_identity - Get the user identity (from EAP-Response/Identity)
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ * @len: Buffer for returning identity length
+ * Returns: Pointer to the user identity or %NULL if not available
+ */
+const u8 * eap_get_identity(struct eap_sm *sm, size_t *len)
+{
+ *len = sm->identity_len;
+ return sm->identity;
+}
+
+
+/**
+ * eap_get_interface - Get pointer to EAP-EAPOL interface data
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ * Returns: Pointer to the EAP-EAPOL interface data
+ */
+struct eap_eapol_interface * eap_get_interface(struct eap_sm *sm)
+{
+ return &sm->eap_if;
+}
+
+
+/**
+ * eap_server_clear_identity - Clear EAP identity information
+ * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
+ *
+ * This function can be used to clear the EAP identity information in the EAP
+ * server context. This allows the EAP/Identity method to be used again after
+ * EAPOL-Start or EAPOL-Logoff.
+ */
+void eap_server_clear_identity(struct eap_sm *sm)
+{
+ os_free(sm->identity);
+ sm->identity = NULL;
+}
diff --git a/src/eap_server/eap_server_aka.c b/src/eap_server/eap_server_aka.c
new file mode 100644
index 0000000..42cbdce
--- /dev/null
+++ b/src/eap_server/eap_server_aka.c
@@ -0,0 +1,1278 @@
+/*
+ * hostapd / EAP-AKA (RFC 4187) and EAP-AKA' (draft-arkko-eap-aka-kdf)
+ * Copyright (c) 2005-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/sha256.h"
+#include "crypto/crypto.h"
+#include "crypto/random.h"
+#include "eap_common/eap_sim_common.h"
+#include "eap_server/eap_i.h"
+#include "eap_server/eap_sim_db.h"
+
+
+struct eap_aka_data {
+ u8 mk[EAP_SIM_MK_LEN];
+ u8 nonce_s[EAP_SIM_NONCE_S_LEN];
+ u8 k_aut[EAP_AKA_PRIME_K_AUT_LEN];
+ u8 k_encr[EAP_SIM_K_ENCR_LEN];
+ u8 k_re[EAP_AKA_PRIME_K_RE_LEN]; /* EAP-AKA' only */
+ u8 msk[EAP_SIM_KEYING_DATA_LEN];
+ u8 emsk[EAP_EMSK_LEN];
+ u8 rand[EAP_AKA_RAND_LEN];
+ u8 autn[EAP_AKA_AUTN_LEN];
+ u8 ck[EAP_AKA_CK_LEN];
+ u8 ik[EAP_AKA_IK_LEN];
+ u8 res[EAP_AKA_RES_MAX_LEN];
+ size_t res_len;
+ enum {
+ IDENTITY, CHALLENGE, REAUTH, NOTIFICATION, SUCCESS, FAILURE
+ } state;
+ char *next_pseudonym;
+ char *next_reauth_id;
+ u16 counter;
+ struct eap_sim_reauth *reauth;
+ int auts_reported; /* whether the current AUTS has been reported to the
+ * eap_sim_db */
+ u16 notification;
+ int use_result_ind;
+
+ struct wpabuf *id_msgs;
+ int pending_id;
+ u8 eap_method;
+ u8 *network_name;
+ size_t network_name_len;
+ u16 kdf;
+};
+
+
+static void eap_aka_determine_identity(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ int before_identity, int after_reauth);
+
+
+static const char * eap_aka_state_txt(int state)
+{
+ switch (state) {
+ case IDENTITY:
+ return "IDENTITY";
+ case CHALLENGE:
+ return "CHALLENGE";
+ case REAUTH:
+ return "REAUTH";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ case NOTIFICATION:
+ return "NOTIFICATION";
+ default:
+ return "Unknown?!";
+ }
+}
+
+
+static void eap_aka_state(struct eap_aka_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-AKA: %s -> %s",
+ eap_aka_state_txt(data->state),
+ eap_aka_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_aka_init(struct eap_sm *sm)
+{
+ struct eap_aka_data *data;
+
+ if (sm->eap_sim_db_priv == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: eap_sim_db not configured");
+ return NULL;
+ }
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+
+ data->eap_method = EAP_TYPE_AKA;
+
+ data->state = IDENTITY;
+ eap_aka_determine_identity(sm, data, 1, 0);
+ data->pending_id = -1;
+
+ return data;
+}
+
+
+#ifdef EAP_SERVER_AKA_PRIME
+static void * eap_aka_prime_init(struct eap_sm *sm)
+{
+ struct eap_aka_data *data;
+ /* TODO: make ANID configurable; see 3GPP TS 24.302 */
+ char *network_name = "WLAN";
+
+ if (sm->eap_sim_db_priv == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: eap_sim_db not configured");
+ return NULL;
+ }
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+
+ data->eap_method = EAP_TYPE_AKA_PRIME;
+ data->network_name = os_malloc(os_strlen(network_name));
+ if (data->network_name == NULL) {
+ os_free(data);
+ return NULL;
+ }
+
+ data->network_name_len = os_strlen(network_name);
+ os_memcpy(data->network_name, network_name, data->network_name_len);
+
+ data->state = IDENTITY;
+ eap_aka_determine_identity(sm, data, 1, 0);
+ data->pending_id = -1;
+
+ return data;
+}
+#endif /* EAP_SERVER_AKA_PRIME */
+
+
+static void eap_aka_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_aka_data *data = priv;
+ os_free(data->next_pseudonym);
+ os_free(data->next_reauth_id);
+ wpabuf_free(data->id_msgs);
+ os_free(data->network_name);
+ os_free(data);
+}
+
+
+static int eap_aka_add_id_msg(struct eap_aka_data *data,
+ const struct wpabuf *msg)
+{
+ if (msg == NULL)
+ return -1;
+
+ if (data->id_msgs == NULL) {
+ data->id_msgs = wpabuf_dup(msg);
+ return data->id_msgs == NULL ? -1 : 0;
+ }
+
+ if (wpabuf_resize(&data->id_msgs, wpabuf_len(msg)) < 0)
+ return -1;
+ wpabuf_put_buf(data->id_msgs, msg);
+
+ return 0;
+}
+
+
+static void eap_aka_add_checkcode(struct eap_aka_data *data,
+ struct eap_sim_msg *msg)
+{
+ const u8 *addr;
+ size_t len;
+ u8 hash[SHA256_MAC_LEN];
+
+ wpa_printf(MSG_DEBUG, " AT_CHECKCODE");
+
+ if (data->id_msgs == NULL) {
+ /*
+ * No EAP-AKA/Identity packets were exchanged - send empty
+ * checkcode.
+ */
+ eap_sim_msg_add(msg, EAP_SIM_AT_CHECKCODE, 0, NULL, 0);
+ return;
+ }
+
+ /* Checkcode is SHA1 hash over all EAP-AKA/Identity packets. */
+ addr = wpabuf_head(data->id_msgs);
+ len = wpabuf_len(data->id_msgs);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-AKA: AT_CHECKCODE data", addr, len);
+ if (data->eap_method == EAP_TYPE_AKA_PRIME)
+ sha256_vector(1, &addr, &len, hash);
+ else
+ sha1_vector(1, &addr, &len, hash);
+
+ eap_sim_msg_add(msg, EAP_SIM_AT_CHECKCODE, 0, hash,
+ data->eap_method == EAP_TYPE_AKA_PRIME ?
+ EAP_AKA_PRIME_CHECKCODE_LEN : EAP_AKA_CHECKCODE_LEN);
+}
+
+
+static int eap_aka_verify_checkcode(struct eap_aka_data *data,
+ const u8 *checkcode, size_t checkcode_len)
+{
+ const u8 *addr;
+ size_t len;
+ u8 hash[SHA256_MAC_LEN];
+ size_t hash_len;
+
+ if (checkcode == NULL)
+ return -1;
+
+ if (data->id_msgs == NULL) {
+ if (checkcode_len != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Checkcode from peer "
+ "indicates that AKA/Identity messages were "
+ "used, but they were not");
+ return -1;
+ }
+ return 0;
+ }
+
+ hash_len = data->eap_method == EAP_TYPE_AKA_PRIME ?
+ EAP_AKA_PRIME_CHECKCODE_LEN : EAP_AKA_CHECKCODE_LEN;
+
+ if (checkcode_len != hash_len) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Checkcode from peer indicates "
+ "that AKA/Identity message were not used, but they "
+ "were");
+ return -1;
+ }
+
+ /* Checkcode is SHA1 hash over all EAP-AKA/Identity packets. */
+ addr = wpabuf_head(data->id_msgs);
+ len = wpabuf_len(data->id_msgs);
+ if (data->eap_method == EAP_TYPE_AKA_PRIME)
+ sha256_vector(1, &addr, &len, hash);
+ else
+ sha1_vector(1, &addr, &len, hash);
+
+ if (os_memcmp(hash, checkcode, hash_len) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Mismatch in AT_CHECKCODE");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static struct wpabuf * eap_aka_build_identity(struct eap_sm *sm,
+ struct eap_aka_data *data, u8 id)
+{
+ struct eap_sim_msg *msg;
+ struct wpabuf *buf;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Identity");
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, data->eap_method,
+ EAP_AKA_SUBTYPE_IDENTITY);
+ if (eap_sim_db_identity_known(sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len)) {
+ wpa_printf(MSG_DEBUG, " AT_PERMANENT_ID_REQ");
+ eap_sim_msg_add(msg, EAP_SIM_AT_PERMANENT_ID_REQ, 0, NULL, 0);
+ } else {
+ /*
+ * RFC 4187, Chap. 4.1.4 recommends that identity from EAP is
+ * ignored and the AKA/Identity is used to request the
+ * identity.
+ */
+ wpa_printf(MSG_DEBUG, " AT_ANY_ID_REQ");
+ eap_sim_msg_add(msg, EAP_SIM_AT_ANY_ID_REQ, 0, NULL, 0);
+ }
+ buf = eap_sim_msg_finish(msg, NULL, NULL, 0);
+ if (eap_aka_add_id_msg(data, buf) < 0) {
+ wpabuf_free(buf);
+ return NULL;
+ }
+ data->pending_id = id;
+ return buf;
+}
+
+
+static int eap_aka_build_encr(struct eap_sm *sm, struct eap_aka_data *data,
+ struct eap_sim_msg *msg, u16 counter,
+ const u8 *nonce_s)
+{
+ os_free(data->next_pseudonym);
+ data->next_pseudonym =
+ eap_sim_db_get_next_pseudonym(sm->eap_sim_db_priv, 1);
+ os_free(data->next_reauth_id);
+ if (data->counter <= EAP_AKA_MAX_FAST_REAUTHS) {
+ data->next_reauth_id =
+ eap_sim_db_get_next_reauth_id(sm->eap_sim_db_priv, 1);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Max fast re-authentication "
+ "count exceeded - force full authentication");
+ data->next_reauth_id = NULL;
+ }
+
+ if (data->next_pseudonym == NULL && data->next_reauth_id == NULL &&
+ counter == 0 && nonce_s == NULL)
+ return 0;
+
+ wpa_printf(MSG_DEBUG, " AT_IV");
+ wpa_printf(MSG_DEBUG, " AT_ENCR_DATA");
+ eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, EAP_SIM_AT_ENCR_DATA);
+
+ if (counter > 0) {
+ wpa_printf(MSG_DEBUG, " *AT_COUNTER (%u)", counter);
+ eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, counter, NULL, 0);
+ }
+
+ if (nonce_s) {
+ wpa_printf(MSG_DEBUG, " *AT_NONCE_S");
+ eap_sim_msg_add(msg, EAP_SIM_AT_NONCE_S, 0, nonce_s,
+ EAP_SIM_NONCE_S_LEN);
+ }
+
+ if (data->next_pseudonym) {
+ wpa_printf(MSG_DEBUG, " *AT_NEXT_PSEUDONYM (%s)",
+ data->next_pseudonym);
+ eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_PSEUDONYM,
+ os_strlen(data->next_pseudonym),
+ (u8 *) data->next_pseudonym,
+ os_strlen(data->next_pseudonym));
+ }
+
+ if (data->next_reauth_id) {
+ wpa_printf(MSG_DEBUG, " *AT_NEXT_REAUTH_ID (%s)",
+ data->next_reauth_id);
+ eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_REAUTH_ID,
+ os_strlen(data->next_reauth_id),
+ (u8 *) data->next_reauth_id,
+ os_strlen(data->next_reauth_id));
+ }
+
+ if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Failed to encrypt "
+ "AT_ENCR_DATA");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static struct wpabuf * eap_aka_build_challenge(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ u8 id)
+{
+ struct eap_sim_msg *msg;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Challenge");
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, data->eap_method,
+ EAP_AKA_SUBTYPE_CHALLENGE);
+ wpa_printf(MSG_DEBUG, " AT_RAND");
+ eap_sim_msg_add(msg, EAP_SIM_AT_RAND, 0, data->rand, EAP_AKA_RAND_LEN);
+ wpa_printf(MSG_DEBUG, " AT_AUTN");
+ eap_sim_msg_add(msg, EAP_SIM_AT_AUTN, 0, data->autn, EAP_AKA_AUTN_LEN);
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+ if (data->kdf) {
+ /* Add the selected KDF into the beginning */
+ wpa_printf(MSG_DEBUG, " AT_KDF");
+ eap_sim_msg_add(msg, EAP_SIM_AT_KDF, data->kdf,
+ NULL, 0);
+ }
+ wpa_printf(MSG_DEBUG, " AT_KDF");
+ eap_sim_msg_add(msg, EAP_SIM_AT_KDF, EAP_AKA_PRIME_KDF,
+ NULL, 0);
+ wpa_printf(MSG_DEBUG, " AT_KDF_INPUT");
+ eap_sim_msg_add(msg, EAP_SIM_AT_KDF_INPUT,
+ data->network_name_len,
+ data->network_name, data->network_name_len);
+ }
+
+ if (eap_aka_build_encr(sm, data, msg, 0, NULL)) {
+ eap_sim_msg_free(msg);
+ return NULL;
+ }
+
+ eap_aka_add_checkcode(data, msg);
+
+ if (sm->eap_sim_aka_result_ind) {
+ wpa_printf(MSG_DEBUG, " AT_RESULT_IND");
+ eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
+ }
+
+#ifdef EAP_SERVER_AKA_PRIME
+ if (data->eap_method == EAP_TYPE_AKA) {
+ u16 flags = 0;
+ int i;
+ int aka_prime_preferred = 0;
+
+ i = 0;
+ while (sm->user && i < EAP_MAX_METHODS &&
+ (sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[i].method != EAP_TYPE_NONE)) {
+ if (sm->user->methods[i].vendor == EAP_VENDOR_IETF) {
+ if (sm->user->methods[i].method ==
+ EAP_TYPE_AKA)
+ break;
+ if (sm->user->methods[i].method ==
+ EAP_TYPE_AKA_PRIME) {
+ aka_prime_preferred = 1;
+ break;
+ }
+ }
+ i++;
+ }
+
+ if (aka_prime_preferred)
+ flags |= EAP_AKA_BIDDING_FLAG_D;
+ eap_sim_msg_add(msg, EAP_SIM_AT_BIDDING, flags, NULL, 0);
+ }
+#endif /* EAP_SERVER_AKA_PRIME */
+
+ wpa_printf(MSG_DEBUG, " AT_MAC");
+ eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
+ return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
+}
+
+
+static struct wpabuf * eap_aka_build_reauth(struct eap_sm *sm,
+ struct eap_aka_data *data, u8 id)
+{
+ struct eap_sim_msg *msg;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Re-authentication");
+
+ if (random_get_bytes(data->nonce_s, EAP_SIM_NONCE_S_LEN))
+ return NULL;
+ wpa_hexdump_key(MSG_MSGDUMP, "EAP-AKA: NONCE_S",
+ data->nonce_s, EAP_SIM_NONCE_S_LEN);
+
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+ eap_aka_prime_derive_keys_reauth(data->k_re, data->counter,
+ sm->identity,
+ sm->identity_len,
+ data->nonce_s,
+ data->msk, data->emsk);
+ } else {
+ eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut,
+ data->msk, data->emsk);
+ eap_sim_derive_keys_reauth(data->counter, sm->identity,
+ sm->identity_len, data->nonce_s,
+ data->mk, data->msk, data->emsk);
+ }
+
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, data->eap_method,
+ EAP_AKA_SUBTYPE_REAUTHENTICATION);
+
+ if (eap_aka_build_encr(sm, data, msg, data->counter, data->nonce_s)) {
+ eap_sim_msg_free(msg);
+ return NULL;
+ }
+
+ eap_aka_add_checkcode(data, msg);
+
+ if (sm->eap_sim_aka_result_ind) {
+ wpa_printf(MSG_DEBUG, " AT_RESULT_IND");
+ eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
+ }
+
+ wpa_printf(MSG_DEBUG, " AT_MAC");
+ eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
+ return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
+}
+
+
+static struct wpabuf * eap_aka_build_notification(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ u8 id)
+{
+ struct eap_sim_msg *msg;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Notification");
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, data->eap_method,
+ EAP_AKA_SUBTYPE_NOTIFICATION);
+ wpa_printf(MSG_DEBUG, " AT_NOTIFICATION (%d)", data->notification);
+ eap_sim_msg_add(msg, EAP_SIM_AT_NOTIFICATION, data->notification,
+ NULL, 0);
+ if (data->use_result_ind) {
+ if (data->reauth) {
+ wpa_printf(MSG_DEBUG, " AT_IV");
+ wpa_printf(MSG_DEBUG, " AT_ENCR_DATA");
+ eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV,
+ EAP_SIM_AT_ENCR_DATA);
+ wpa_printf(MSG_DEBUG, " *AT_COUNTER (%u)",
+ data->counter);
+ eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter,
+ NULL, 0);
+
+ if (eap_sim_msg_add_encr_end(msg, data->k_encr,
+ EAP_SIM_AT_PADDING)) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Failed to "
+ "encrypt AT_ENCR_DATA");
+ eap_sim_msg_free(msg);
+ return NULL;
+ }
+ }
+
+ wpa_printf(MSG_DEBUG, " AT_MAC");
+ eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
+ }
+ return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
+}
+
+
+static struct wpabuf * eap_aka_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_aka_data *data = priv;
+
+ data->auts_reported = 0;
+ switch (data->state) {
+ case IDENTITY:
+ return eap_aka_build_identity(sm, data, id);
+ case CHALLENGE:
+ return eap_aka_build_challenge(sm, data, id);
+ case REAUTH:
+ return eap_aka_build_reauth(sm, data, id);
+ case NOTIFICATION:
+ return eap_aka_build_notification(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Unknown state %d in "
+ "buildReq", data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_aka_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_aka_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, data->eap_method, respData,
+ &len);
+ if (pos == NULL || len < 3) {
+ wpa_printf(MSG_INFO, "EAP-AKA: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static Boolean eap_aka_subtype_ok(struct eap_aka_data *data, u8 subtype)
+{
+ if (subtype == EAP_AKA_SUBTYPE_CLIENT_ERROR ||
+ subtype == EAP_AKA_SUBTYPE_AUTHENTICATION_REJECT)
+ return FALSE;
+
+ switch (data->state) {
+ case IDENTITY:
+ if (subtype != EAP_AKA_SUBTYPE_IDENTITY) {
+ wpa_printf(MSG_INFO, "EAP-AKA: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ case CHALLENGE:
+ if (subtype != EAP_AKA_SUBTYPE_CHALLENGE &&
+ subtype != EAP_AKA_SUBTYPE_SYNCHRONIZATION_FAILURE) {
+ wpa_printf(MSG_INFO, "EAP-AKA: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ case REAUTH:
+ if (subtype != EAP_AKA_SUBTYPE_REAUTHENTICATION) {
+ wpa_printf(MSG_INFO, "EAP-AKA: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ case NOTIFICATION:
+ if (subtype != EAP_AKA_SUBTYPE_NOTIFICATION) {
+ wpa_printf(MSG_INFO, "EAP-AKA: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ default:
+ wpa_printf(MSG_INFO, "EAP-AKA: Unexpected state (%d) for "
+ "processing a response", data->state);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_aka_determine_identity(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ int before_identity, int after_reauth)
+{
+ const u8 *identity;
+ size_t identity_len;
+ int res;
+
+ identity = NULL;
+ identity_len = 0;
+
+ if (after_reauth && data->reauth) {
+ identity = data->reauth->identity;
+ identity_len = data->reauth->identity_len;
+ } else if (sm->identity && sm->identity_len > 0 &&
+ sm->identity[0] == EAP_AKA_PERMANENT_PREFIX) {
+ identity = sm->identity;
+ identity_len = sm->identity_len;
+ } else {
+ identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv,
+ sm->identity,
+ sm->identity_len,
+ &identity_len);
+ if (identity == NULL) {
+ data->reauth = eap_sim_db_get_reauth_entry(
+ sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len);
+ if (data->reauth &&
+ data->reauth->aka_prime !=
+ (data->eap_method == EAP_TYPE_AKA_PRIME)) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Reauth data "
+ "was for different AKA version");
+ data->reauth = NULL;
+ }
+ if (data->reauth) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Using fast "
+ "re-authentication");
+ identity = data->reauth->identity;
+ identity_len = data->reauth->identity_len;
+ data->counter = data->reauth->counter;
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+ os_memcpy(data->k_encr,
+ data->reauth->k_encr,
+ EAP_SIM_K_ENCR_LEN);
+ os_memcpy(data->k_aut,
+ data->reauth->k_aut,
+ EAP_AKA_PRIME_K_AUT_LEN);
+ os_memcpy(data->k_re,
+ data->reauth->k_re,
+ EAP_AKA_PRIME_K_RE_LEN);
+ } else {
+ os_memcpy(data->mk, data->reauth->mk,
+ EAP_SIM_MK_LEN);
+ }
+ }
+ }
+ }
+
+ if (identity == NULL ||
+ eap_sim_db_identity_known(sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len) < 0) {
+ if (before_identity) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Permanent user name "
+ "not known - send AKA-Identity request");
+ eap_aka_state(data, IDENTITY);
+ return;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Unknown whether the "
+ "permanent user name is known; try to use "
+ "it");
+ /* eap_sim_db_get_aka_auth() will report failure, if
+ * this identity is not known. */
+ }
+ }
+
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-AKA: Identity",
+ identity, identity_len);
+
+ if (!after_reauth && data->reauth) {
+ eap_aka_state(data, REAUTH);
+ return;
+ }
+
+ res = eap_sim_db_get_aka_auth(sm->eap_sim_db_priv, identity,
+ identity_len, data->rand, data->autn,
+ data->ik, data->ck, data->res,
+ &data->res_len, sm);
+ if (res == EAP_SIM_DB_PENDING) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: AKA authentication data "
+ "not yet available - pending request");
+ sm->method_pending = METHOD_PENDING_WAIT;
+ return;
+ }
+
+#ifdef EAP_SERVER_AKA_PRIME
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+ /* Note: AUTN = (SQN ^ AK) || AMF || MAC which gives us the
+ * needed 6-octet SQN ^AK for CK',IK' derivation */
+ eap_aka_prime_derive_ck_ik_prime(data->ck, data->ik,
+ data->autn,
+ data->network_name,
+ data->network_name_len);
+ }
+#endif /* EAP_SERVER_AKA_PRIME */
+
+ data->reauth = NULL;
+ data->counter = 0; /* reset re-auth counter since this is full auth */
+
+ if (res != 0) {
+ wpa_printf(MSG_INFO, "EAP-AKA: Failed to get AKA "
+ "authentication data for the peer");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+ if (sm->method_pending == METHOD_PENDING_WAIT) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: AKA authentication data "
+ "available - abort pending wait");
+ sm->method_pending = METHOD_PENDING_NONE;
+ }
+
+ identity_len = sm->identity_len;
+ while (identity_len > 0 && sm->identity[identity_len - 1] == '\0') {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Workaround - drop last null "
+ "character from identity");
+ identity_len--;
+ }
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-AKA: Identity for MK derivation",
+ sm->identity, identity_len);
+
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+ eap_aka_prime_derive_keys(identity, identity_len, data->ik,
+ data->ck, data->k_encr, data->k_aut,
+ data->k_re, data->msk, data->emsk);
+ } else {
+ eap_aka_derive_mk(sm->identity, identity_len, data->ik,
+ data->ck, data->mk);
+ eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut,
+ data->msk, data->emsk);
+ }
+
+ eap_aka_state(data, CHALLENGE);
+}
+
+
+static void eap_aka_process_identity(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Processing Identity");
+
+ if (attr->mac || attr->iv || attr->encr_data) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Unexpected attribute "
+ "received in EAP-Response/AKA-Identity");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ if (attr->identity) {
+ os_free(sm->identity);
+ sm->identity = os_malloc(attr->identity_len);
+ if (sm->identity) {
+ os_memcpy(sm->identity, attr->identity,
+ attr->identity_len);
+ sm->identity_len = attr->identity_len;
+ }
+ }
+
+ eap_aka_determine_identity(sm, data, 0, 0);
+ if (eap_get_id(respData) == data->pending_id) {
+ data->pending_id = -1;
+ eap_aka_add_id_msg(data, respData);
+ }
+}
+
+
+static int eap_aka_verify_mac(struct eap_aka_data *data,
+ const struct wpabuf *req,
+ const u8 *mac, const u8 *extra,
+ size_t extra_len)
+{
+ if (data->eap_method == EAP_TYPE_AKA_PRIME)
+ return eap_sim_verify_mac_sha256(data->k_aut, req, mac, extra,
+ extra_len);
+ return eap_sim_verify_mac(data->k_aut, req, mac, extra, extra_len);
+}
+
+
+static void eap_aka_process_challenge(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ const u8 *identity;
+ size_t identity_len;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Processing Challenge");
+
+#ifdef EAP_SERVER_AKA_PRIME
+#if 0
+ /* KDF negotiation; to be enabled only after more than one KDF is
+ * supported */
+ if (data->eap_method == EAP_TYPE_AKA_PRIME &&
+ attr->kdf_count == 1 && attr->mac == NULL) {
+ if (attr->kdf[0] != EAP_AKA_PRIME_KDF) {
+ wpa_printf(MSG_WARNING, "EAP-AKA': Peer selected "
+ "unknown KDF");
+ data->notification =
+ EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ data->kdf = attr->kdf[0];
+
+ /* Allow negotiation to continue with the selected KDF by
+ * sending another Challenge message */
+ wpa_printf(MSG_DEBUG, "EAP-AKA': KDF %d selected", data->kdf);
+ return;
+ }
+#endif
+#endif /* EAP_SERVER_AKA_PRIME */
+
+ if (attr->checkcode &&
+ eap_aka_verify_checkcode(data, attr->checkcode,
+ attr->checkcode_len)) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Invalid AT_CHECKCODE in the "
+ "message");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+ if (attr->mac == NULL ||
+ eap_aka_verify_mac(data, respData, attr->mac, NULL, 0)) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Challenge message "
+ "did not include valid AT_MAC");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ /*
+ * AT_RES is padded, so verify that there is enough room for RES and
+ * that the RES length in bits matches with the expected RES.
+ */
+ if (attr->res == NULL || attr->res_len < data->res_len ||
+ attr->res_len_bits != data->res_len * 8 ||
+ os_memcmp(attr->res, data->res, data->res_len) != 0) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Challenge message did not "
+ "include valid AT_RES (attr len=%lu, res len=%lu "
+ "bits, expected %lu bits)",
+ (unsigned long) attr->res_len,
+ (unsigned long) attr->res_len_bits,
+ (unsigned long) data->res_len * 8);
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Challenge response includes the "
+ "correct AT_MAC");
+ if (sm->eap_sim_aka_result_ind && attr->result_ind) {
+ data->use_result_ind = 1;
+ data->notification = EAP_SIM_SUCCESS;
+ eap_aka_state(data, NOTIFICATION);
+ } else
+ eap_aka_state(data, SUCCESS);
+
+ identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len, &identity_len);
+ if (identity == NULL) {
+ identity = sm->identity;
+ identity_len = sm->identity_len;
+ }
+
+ if (data->next_pseudonym) {
+ eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity,
+ identity_len,
+ data->next_pseudonym);
+ data->next_pseudonym = NULL;
+ }
+ if (data->next_reauth_id) {
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+#ifdef EAP_SERVER_AKA_PRIME
+ eap_sim_db_add_reauth_prime(sm->eap_sim_db_priv,
+ identity,
+ identity_len,
+ data->next_reauth_id,
+ data->counter + 1,
+ data->k_encr, data->k_aut,
+ data->k_re);
+#endif /* EAP_SERVER_AKA_PRIME */
+ } else {
+ eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity,
+ identity_len,
+ data->next_reauth_id,
+ data->counter + 1,
+ data->mk);
+ }
+ data->next_reauth_id = NULL;
+ }
+}
+
+
+static void eap_aka_process_sync_failure(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Processing Synchronization-Failure");
+
+ if (attr->auts == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Synchronization-Failure "
+ "message did not include valid AT_AUTS");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ /* Avoid re-reporting AUTS when processing pending EAP packet by
+ * maintaining a local flag stating whether this AUTS has already been
+ * reported. */
+ if (!data->auts_reported &&
+ eap_sim_db_resynchronize(sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len, attr->auts,
+ data->rand)) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Resynchronization failed");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+ data->auts_reported = 1;
+
+ /* Try again after resynchronization */
+ eap_aka_determine_identity(sm, data, 0, 0);
+}
+
+
+static void eap_aka_process_reauth(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ struct eap_sim_attrs eattr;
+ u8 *decrypted = NULL;
+ const u8 *identity, *id2;
+ size_t identity_len, id2_len;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Processing Reauthentication");
+
+ if (attr->mac == NULL ||
+ eap_aka_verify_mac(data, respData, attr->mac, data->nonce_s,
+ EAP_SIM_NONCE_S_LEN)) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Re-authentication message "
+ "did not include valid AT_MAC");
+ goto fail;
+ }
+
+ if (attr->encr_data == NULL || attr->iv == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Reauthentication "
+ "message did not include encrypted data");
+ goto fail;
+ }
+
+ decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
+ attr->encr_data_len, attr->iv, &eattr,
+ 0);
+ if (decrypted == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Failed to parse encrypted "
+ "data from reauthentication message");
+ goto fail;
+ }
+
+ if (eattr.counter != data->counter) {
+ wpa_printf(MSG_WARNING, "EAP-AKA: Re-authentication message "
+ "used incorrect counter %u, expected %u",
+ eattr.counter, data->counter);
+ goto fail;
+ }
+ os_free(decrypted);
+ decrypted = NULL;
+
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Re-authentication response includes "
+ "the correct AT_MAC");
+
+ if (eattr.counter_too_small) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Re-authentication response "
+ "included AT_COUNTER_TOO_SMALL - starting full "
+ "authentication");
+ eap_aka_determine_identity(sm, data, 0, 1);
+ return;
+ }
+
+ if (sm->eap_sim_aka_result_ind && attr->result_ind) {
+ data->use_result_ind = 1;
+ data->notification = EAP_SIM_SUCCESS;
+ eap_aka_state(data, NOTIFICATION);
+ } else
+ eap_aka_state(data, SUCCESS);
+
+ if (data->reauth) {
+ identity = data->reauth->identity;
+ identity_len = data->reauth->identity_len;
+ } else {
+ identity = sm->identity;
+ identity_len = sm->identity_len;
+ }
+
+ id2 = eap_sim_db_get_permanent(sm->eap_sim_db_priv, identity,
+ identity_len, &id2_len);
+ if (id2) {
+ identity = id2;
+ identity_len = id2_len;
+ }
+
+ if (data->next_pseudonym) {
+ eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity,
+ identity_len, data->next_pseudonym);
+ data->next_pseudonym = NULL;
+ }
+ if (data->next_reauth_id) {
+ if (data->eap_method == EAP_TYPE_AKA_PRIME) {
+#ifdef EAP_SERVER_AKA_PRIME
+ eap_sim_db_add_reauth_prime(sm->eap_sim_db_priv,
+ identity,
+ identity_len,
+ data->next_reauth_id,
+ data->counter + 1,
+ data->k_encr, data->k_aut,
+ data->k_re);
+#endif /* EAP_SERVER_AKA_PRIME */
+ } else {
+ eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity,
+ identity_len,
+ data->next_reauth_id,
+ data->counter + 1,
+ data->mk);
+ }
+ data->next_reauth_id = NULL;
+ } else {
+ eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
+ data->reauth = NULL;
+ }
+
+ return;
+
+fail:
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
+ data->reauth = NULL;
+ os_free(decrypted);
+}
+
+
+static void eap_aka_process_client_error(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Client reported error %d",
+ attr->client_error_code);
+ if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
+ eap_aka_state(data, SUCCESS);
+ else
+ eap_aka_state(data, FAILURE);
+}
+
+
+static void eap_aka_process_authentication_reject(
+ struct eap_sm *sm, struct eap_aka_data *data,
+ struct wpabuf *respData, struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Client rejected authentication");
+ eap_aka_state(data, FAILURE);
+}
+
+
+static void eap_aka_process_notification(struct eap_sm *sm,
+ struct eap_aka_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Client replied to notification");
+ if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
+ eap_aka_state(data, SUCCESS);
+ else
+ eap_aka_state(data, FAILURE);
+}
+
+
+static void eap_aka_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_aka_data *data = priv;
+ const u8 *pos, *end;
+ u8 subtype;
+ size_t len;
+ struct eap_sim_attrs attr;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, data->eap_method, respData,
+ &len);
+ if (pos == NULL || len < 3)
+ return;
+
+ end = pos + len;
+ subtype = *pos;
+ pos += 3;
+
+ if (eap_aka_subtype_ok(data, subtype)) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Unrecognized or unexpected "
+ "EAP-AKA Subtype in EAP Response");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ if (eap_sim_parse_attr(pos, end, &attr,
+ data->eap_method == EAP_TYPE_AKA_PRIME ? 2 : 1,
+ 0)) {
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Failed to parse attributes");
+ data->notification = EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
+ eap_aka_state(data, NOTIFICATION);
+ return;
+ }
+
+ if (subtype == EAP_AKA_SUBTYPE_CLIENT_ERROR) {
+ eap_aka_process_client_error(sm, data, respData, &attr);
+ return;
+ }
+
+ if (subtype == EAP_AKA_SUBTYPE_AUTHENTICATION_REJECT) {
+ eap_aka_process_authentication_reject(sm, data, respData,
+ &attr);
+ return;
+ }
+
+ switch (data->state) {
+ case IDENTITY:
+ eap_aka_process_identity(sm, data, respData, &attr);
+ break;
+ case CHALLENGE:
+ if (subtype == EAP_AKA_SUBTYPE_SYNCHRONIZATION_FAILURE) {
+ eap_aka_process_sync_failure(sm, data, respData,
+ &attr);
+ } else {
+ eap_aka_process_challenge(sm, data, respData, &attr);
+ }
+ break;
+ case REAUTH:
+ eap_aka_process_reauth(sm, data, respData, &attr);
+ break;
+ case NOTIFICATION:
+ eap_aka_process_notification(sm, data, respData, &attr);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-AKA: Unknown state %d in "
+ "process", data->state);
+ break;
+ }
+}
+
+
+static Boolean eap_aka_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_aka_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_aka_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_aka_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_SIM_KEYING_DATA_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->msk, EAP_SIM_KEYING_DATA_LEN);
+ *len = EAP_SIM_KEYING_DATA_LEN;
+ return key;
+}
+
+
+static u8 * eap_aka_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_aka_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->emsk, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+ return key;
+}
+
+
+static Boolean eap_aka_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_aka_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_aka_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_AKA, "AKA");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_aka_init;
+ eap->reset = eap_aka_reset;
+ eap->buildReq = eap_aka_buildReq;
+ eap->check = eap_aka_check;
+ eap->process = eap_aka_process;
+ eap->isDone = eap_aka_isDone;
+ eap->getKey = eap_aka_getKey;
+ eap->isSuccess = eap_aka_isSuccess;
+ eap->get_emsk = eap_aka_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
+
+
+#ifdef EAP_SERVER_AKA_PRIME
+int eap_server_aka_prime_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_AKA_PRIME,
+ "AKA'");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_aka_prime_init;
+ eap->reset = eap_aka_reset;
+ eap->buildReq = eap_aka_buildReq;
+ eap->check = eap_aka_check;
+ eap->process = eap_aka_process;
+ eap->isDone = eap_aka_isDone;
+ eap->getKey = eap_aka_getKey;
+ eap->isSuccess = eap_aka_isSuccess;
+ eap->get_emsk = eap_aka_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+
+ return ret;
+}
+#endif /* EAP_SERVER_AKA_PRIME */
diff --git a/src/eap_server/eap_server_fast.c b/src/eap_server/eap_server_fast.c
new file mode 100644
index 0000000..ba17e98
--- /dev/null
+++ b/src/eap_server/eap_server_fast.c
@@ -0,0 +1,1620 @@
+/*
+ * EAP-FAST server (RFC 4851)
+ * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/aes_wrap.h"
+#include "crypto/sha1.h"
+#include "crypto/tls.h"
+#include "crypto/random.h"
+#include "eap_common/eap_tlv_common.h"
+#include "eap_common/eap_fast_common.h"
+#include "eap_i.h"
+#include "eap_tls_common.h"
+
+
+static void eap_fast_reset(struct eap_sm *sm, void *priv);
+
+
+/* Private PAC-Opaque TLV types */
+#define PAC_OPAQUE_TYPE_PAD 0
+#define PAC_OPAQUE_TYPE_KEY 1
+#define PAC_OPAQUE_TYPE_LIFETIME 2
+#define PAC_OPAQUE_TYPE_IDENTITY 3
+
+struct eap_fast_data {
+ struct eap_ssl_data ssl;
+ enum {
+ START, PHASE1, PHASE2_START, PHASE2_ID, PHASE2_METHOD,
+ CRYPTO_BINDING, REQUEST_PAC, SUCCESS, FAILURE
+ } state;
+
+ int fast_version;
+ const struct eap_method *phase2_method;
+ void *phase2_priv;
+ int force_version;
+ int peer_version;
+
+ u8 crypto_binding_nonce[32];
+ int final_result;
+
+ struct eap_fast_key_block_provisioning *key_block_p;
+
+ u8 simck[EAP_FAST_SIMCK_LEN];
+ u8 cmk[EAP_FAST_CMK_LEN];
+ int simck_idx;
+
+ u8 pac_opaque_encr[16];
+ u8 *srv_id;
+ size_t srv_id_len;
+ char *srv_id_info;
+
+ int anon_provisioning;
+ int send_new_pac; /* server triggered re-keying of Tunnel PAC */
+ struct wpabuf *pending_phase2_resp;
+ u8 *identity; /* from PAC-Opaque */
+ size_t identity_len;
+ int eap_seq;
+ int tnc_started;
+
+ int pac_key_lifetime;
+ int pac_key_refresh_time;
+};
+
+
+static int eap_fast_process_phase2_start(struct eap_sm *sm,
+ struct eap_fast_data *data);
+
+
+static const char * eap_fast_state_txt(int state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case PHASE1:
+ return "PHASE1";
+ case PHASE2_START:
+ return "PHASE2_START";
+ case PHASE2_ID:
+ return "PHASE2_ID";
+ case PHASE2_METHOD:
+ return "PHASE2_METHOD";
+ case CRYPTO_BINDING:
+ return "CRYPTO_BINDING";
+ case REQUEST_PAC:
+ return "REQUEST_PAC";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "Unknown?!";
+ }
+}
+
+
+static void eap_fast_state(struct eap_fast_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-FAST: %s -> %s",
+ eap_fast_state_txt(data->state),
+ eap_fast_state_txt(state));
+ data->state = state;
+}
+
+
+static EapType eap_fast_req_failure(struct eap_sm *sm,
+ struct eap_fast_data *data)
+{
+ /* TODO: send Result TLV(FAILURE) */
+ eap_fast_state(data, FAILURE);
+ return EAP_TYPE_NONE;
+}
+
+
+static int eap_fast_session_ticket_cb(void *ctx, const u8 *ticket, size_t len,
+ const u8 *client_random,
+ const u8 *server_random,
+ u8 *master_secret)
+{
+ struct eap_fast_data *data = ctx;
+ const u8 *pac_opaque;
+ size_t pac_opaque_len;
+ u8 *buf, *pos, *end, *pac_key = NULL;
+ os_time_t lifetime = 0;
+ struct os_time now;
+ u8 *identity = NULL;
+ size_t identity_len = 0;
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: SessionTicket callback");
+ wpa_hexdump(MSG_DEBUG, "EAP-FAST: SessionTicket (PAC-Opaque)",
+ ticket, len);
+
+ if (len < 4 || WPA_GET_BE16(ticket) != PAC_TYPE_PAC_OPAQUE) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Ignore invalid "
+ "SessionTicket");
+ return 0;
+ }
+
+ pac_opaque_len = WPA_GET_BE16(ticket + 2);
+ pac_opaque = ticket + 4;
+ if (pac_opaque_len < 8 || pac_opaque_len % 8 ||
+ pac_opaque_len > len - 4) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Ignore invalid PAC-Opaque "
+ "(len=%lu left=%lu)",
+ (unsigned long) pac_opaque_len,
+ (unsigned long) len);
+ return 0;
+ }
+ wpa_hexdump(MSG_DEBUG, "EAP-FAST: Received PAC-Opaque",
+ pac_opaque, pac_opaque_len);
+
+ buf = os_malloc(pac_opaque_len - 8);
+ if (buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to allocate memory "
+ "for decrypting PAC-Opaque");
+ return 0;
+ }
+
+ if (aes_unwrap(data->pac_opaque_encr, (pac_opaque_len - 8) / 8,
+ pac_opaque, buf) < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to decrypt "
+ "PAC-Opaque");
+ os_free(buf);
+ /*
+ * This may have been caused by server changing the PAC-Opaque
+ * encryption key, so just ignore this PAC-Opaque instead of
+ * failing the authentication completely. Provisioning can now
+ * be used to provision a new PAC.
+ */
+ return 0;
+ }
+
+ end = buf + pac_opaque_len - 8;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-FAST: Decrypted PAC-Opaque",
+ buf, end - buf);
+
+ pos = buf;
+ while (pos + 1 < end) {
+ if (pos + 2 + pos[1] > end)
+ break;
+
+ switch (*pos) {
+ case PAC_OPAQUE_TYPE_PAD:
+ pos = end;
+ break;
+ case PAC_OPAQUE_TYPE_KEY:
+ if (pos[1] != EAP_FAST_PAC_KEY_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Invalid "
+ "PAC-Key length %d", pos[1]);
+ os_free(buf);
+ return -1;
+ }
+ pac_key = pos + 2;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-FAST: PAC-Key from "
+ "decrypted PAC-Opaque",
+ pac_key, EAP_FAST_PAC_KEY_LEN);
+ break;
+ case PAC_OPAQUE_TYPE_LIFETIME:
+ if (pos[1] != 4) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Invalid "
+ "PAC-Key lifetime length %d",
+ pos[1]);
+ os_free(buf);
+ return -1;
+ }
+ lifetime = WPA_GET_BE32(pos + 2);
+ break;
+ case PAC_OPAQUE_TYPE_IDENTITY:
+ identity = pos + 2;
+ identity_len = pos[1];
+ break;
+ }
+
+ pos += 2 + pos[1];
+ }
+
+ if (pac_key == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: No PAC-Key included in "
+ "PAC-Opaque");
+ os_free(buf);
+ return -1;
+ }
+
+ if (identity) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-FAST: Identity from "
+ "PAC-Opaque", identity, identity_len);
+ os_free(data->identity);
+ data->identity = os_malloc(identity_len);
+ if (data->identity) {
+ os_memcpy(data->identity, identity, identity_len);
+ data->identity_len = identity_len;
+ }
+ }
+
+ if (os_get_time(&now) < 0 || lifetime <= 0 || now.sec > lifetime) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: PAC-Key not valid anymore "
+ "(lifetime=%ld now=%ld)", lifetime, now.sec);
+ data->send_new_pac = 2;
+ /*
+ * Allow PAC to be used to allow a PAC update with some level
+ * of server authentication (i.e., do not fall back to full TLS
+ * handshake since we cannot be sure that the peer would be
+ * able to validate server certificate now). However, reject
+ * the authentication since the PAC was not valid anymore. Peer
+ * can connect again with the newly provisioned PAC after this.
+ */
+ } else if (lifetime - now.sec < data->pac_key_refresh_time) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: PAC-Key soft timeout; send "
+ "an update if authentication succeeds");
+ data->send_new_pac = 1;
+ }
+
+ eap_fast_derive_master_secret(pac_key, server_random, client_random,
+ master_secret);
+
+ os_free(buf);
+
+ return 1;
+}
+
+
+static void eap_fast_derive_key_auth(struct eap_sm *sm,
+ struct eap_fast_data *data)
+{
+ u8 *sks;
+
+ /* RFC 4851, Section 5.1:
+ * Extra key material after TLS key_block: session_key_seed[40]
+ */
+
+ sks = eap_fast_derive_key(sm->ssl_ctx, data->ssl.conn, "key expansion",
+ EAP_FAST_SKS_LEN);
+ if (sks == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to derive "
+ "session_key_seed");
+ return;
+ }
+
+ /*
+ * RFC 4851, Section 5.2:
+ * S-IMCK[0] = session_key_seed
+ */
+ wpa_hexdump_key(MSG_DEBUG,
+ "EAP-FAST: session_key_seed (SKS = S-IMCK[0])",
+ sks, EAP_FAST_SKS_LEN);
+ data->simck_idx = 0;
+ os_memcpy(data->simck, sks, EAP_FAST_SIMCK_LEN);
+ os_free(sks);
+}
+
+
+static void eap_fast_derive_key_provisioning(struct eap_sm *sm,
+ struct eap_fast_data *data)
+{
+ os_free(data->key_block_p);
+ data->key_block_p = (struct eap_fast_key_block_provisioning *)
+ eap_fast_derive_key(sm->ssl_ctx, data->ssl.conn,
+ "key expansion",
+ sizeof(*data->key_block_p));
+ if (data->key_block_p == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to derive key block");
+ return;
+ }
+ /*
+ * RFC 4851, Section 5.2:
+ * S-IMCK[0] = session_key_seed
+ */
+ wpa_hexdump_key(MSG_DEBUG,
+ "EAP-FAST: session_key_seed (SKS = S-IMCK[0])",
+ data->key_block_p->session_key_seed,
+ sizeof(data->key_block_p->session_key_seed));
+ data->simck_idx = 0;
+ os_memcpy(data->simck, data->key_block_p->session_key_seed,
+ EAP_FAST_SIMCK_LEN);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-FAST: server_challenge",
+ data->key_block_p->server_challenge,
+ sizeof(data->key_block_p->server_challenge));
+ wpa_hexdump_key(MSG_DEBUG, "EAP-FAST: client_challenge",
+ data->key_block_p->client_challenge,
+ sizeof(data->key_block_p->client_challenge));
+}
+
+
+static int eap_fast_get_phase2_key(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ u8 *isk, size_t isk_len)
+{
+ u8 *key;
+ size_t key_len;
+
+ os_memset(isk, 0, isk_len);
+
+ if (data->phase2_method == NULL || data->phase2_priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Phase 2 method not "
+ "available");
+ return -1;
+ }
+
+ if (data->phase2_method->getKey == NULL)
+ return 0;
+
+ if ((key = data->phase2_method->getKey(sm, data->phase2_priv,
+ &key_len)) == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Could not get key material "
+ "from Phase 2");
+ return -1;
+ }
+
+ if (key_len > isk_len)
+ key_len = isk_len;
+ if (key_len == 32 &&
+ data->phase2_method->vendor == EAP_VENDOR_IETF &&
+ data->phase2_method->method == EAP_TYPE_MSCHAPV2) {
+ /*
+ * EAP-FAST uses reverse order for MS-MPPE keys when deriving
+ * MSK from EAP-MSCHAPv2. Swap the keys here to get the correct
+ * ISK for EAP-FAST cryptobinding.
+ */
+ os_memcpy(isk, key + 16, 16);
+ os_memcpy(isk + 16, key, 16);
+ } else
+ os_memcpy(isk, key, key_len);
+ os_free(key);
+
+ return 0;
+}
+
+
+static int eap_fast_update_icmk(struct eap_sm *sm, struct eap_fast_data *data)
+{
+ u8 isk[32], imck[60];
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Deriving ICMK[%d] (S-IMCK and CMK)",
+ data->simck_idx + 1);
+
+ /*
+ * RFC 4851, Section 5.2:
+ * IMCK[j] = T-PRF(S-IMCK[j-1], "Inner Methods Compound Keys",
+ * MSK[j], 60)
+ * S-IMCK[j] = first 40 octets of IMCK[j]
+ * CMK[j] = last 20 octets of IMCK[j]
+ */
+
+ if (eap_fast_get_phase2_key(sm, data, isk, sizeof(isk)) < 0)
+ return -1;
+ wpa_hexdump_key(MSG_MSGDUMP, "EAP-FAST: ISK[j]", isk, sizeof(isk));
+ sha1_t_prf(data->simck, EAP_FAST_SIMCK_LEN,
+ "Inner Methods Compound Keys",
+ isk, sizeof(isk), imck, sizeof(imck));
+ data->simck_idx++;
+ os_memcpy(data->simck, imck, EAP_FAST_SIMCK_LEN);
+ wpa_hexdump_key(MSG_MSGDUMP, "EAP-FAST: S-IMCK[j]",
+ data->simck, EAP_FAST_SIMCK_LEN);
+ os_memcpy(data->cmk, imck + EAP_FAST_SIMCK_LEN, EAP_FAST_CMK_LEN);
+ wpa_hexdump_key(MSG_MSGDUMP, "EAP-FAST: CMK[j]",
+ data->cmk, EAP_FAST_CMK_LEN);
+
+ return 0;
+}
+
+
+static void * eap_fast_init(struct eap_sm *sm)
+{
+ struct eap_fast_data *data;
+ u8 ciphers[5] = {
+ TLS_CIPHER_ANON_DH_AES128_SHA,
+ TLS_CIPHER_AES128_SHA,
+ TLS_CIPHER_RSA_DHE_AES128_SHA,
+ TLS_CIPHER_RC4_SHA,
+ TLS_CIPHER_NONE
+ };
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->fast_version = EAP_FAST_VERSION;
+ data->force_version = -1;
+ if (sm->user && sm->user->force_version >= 0) {
+ data->force_version = sm->user->force_version;
+ wpa_printf(MSG_DEBUG, "EAP-FAST: forcing version %d",
+ data->force_version);
+ data->fast_version = data->force_version;
+ }
+ data->state = START;
+
+ if (eap_server_tls_ssl_init(sm, &data->ssl, 0)) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Failed to initialize SSL.");
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+
+ if (tls_connection_set_cipher_list(sm->ssl_ctx, data->ssl.conn,
+ ciphers) < 0) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Failed to set TLS cipher "
+ "suites");
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+
+ if (tls_connection_set_session_ticket_cb(sm->ssl_ctx, data->ssl.conn,
+ eap_fast_session_ticket_cb,
+ data) < 0) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Failed to set SessionTicket "
+ "callback");
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+
+ if (sm->pac_opaque_encr_key == NULL) {
+ wpa_printf(MSG_INFO, "EAP-FAST: No PAC-Opaque encryption key "
+ "configured");
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+ os_memcpy(data->pac_opaque_encr, sm->pac_opaque_encr_key,
+ sizeof(data->pac_opaque_encr));
+
+ if (sm->eap_fast_a_id == NULL) {
+ wpa_printf(MSG_INFO, "EAP-FAST: No A-ID configured");
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+ data->srv_id = os_malloc(sm->eap_fast_a_id_len);
+ if (data->srv_id == NULL) {
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+ os_memcpy(data->srv_id, sm->eap_fast_a_id, sm->eap_fast_a_id_len);
+ data->srv_id_len = sm->eap_fast_a_id_len;
+
+ if (sm->eap_fast_a_id_info == NULL) {
+ wpa_printf(MSG_INFO, "EAP-FAST: No A-ID-Info configured");
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+ data->srv_id_info = os_strdup(sm->eap_fast_a_id_info);
+ if (data->srv_id_info == NULL) {
+ eap_fast_reset(sm, data);
+ return NULL;
+ }
+
+ /* PAC-Key lifetime in seconds (hard limit) */
+ data->pac_key_lifetime = sm->pac_key_lifetime;
+
+ /*
+ * PAC-Key refresh time in seconds (soft limit on remaining hard
+ * limit). The server will generate a new PAC-Key when this number of
+ * seconds (or fewer) of the lifetime remains.
+ */
+ data->pac_key_refresh_time = sm->pac_key_refresh_time;
+
+ return data;
+}
+
+
+static void eap_fast_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_fast_data *data = priv;
+ if (data == NULL)
+ return;
+ if (data->phase2_priv && data->phase2_method)
+ data->phase2_method->reset(sm, data->phase2_priv);
+ eap_server_tls_ssl_deinit(sm, &data->ssl);
+ os_free(data->srv_id);
+ os_free(data->srv_id_info);
+ os_free(data->key_block_p);
+ wpabuf_free(data->pending_phase2_resp);
+ os_free(data->identity);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_fast_build_start(struct eap_sm *sm,
+ struct eap_fast_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_FAST,
+ 1 + sizeof(struct pac_tlv_hdr) + data->srv_id_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-FAST: Failed to allocate memory for"
+ " request");
+ eap_fast_state(data, FAILURE);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_TLS_FLAGS_START | data->fast_version);
+
+ /* RFC 4851, 4.1.1. Authority ID Data */
+ eap_fast_put_tlv(req, PAC_TYPE_A_ID, data->srv_id, data->srv_id_len);
+
+ eap_fast_state(data, PHASE1);
+
+ return req;
+}
+
+
+static int eap_fast_phase1_done(struct eap_sm *sm, struct eap_fast_data *data)
+{
+ char cipher[64];
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Phase1 done, starting Phase2");
+
+ if (tls_get_cipher(sm->ssl_ctx, data->ssl.conn, cipher, sizeof(cipher))
+ < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to get cipher "
+ "information");
+ eap_fast_state(data, FAILURE);
+ return -1;
+ }
+ data->anon_provisioning = os_strstr(cipher, "ADH") != NULL;
+
+ if (data->anon_provisioning) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Anonymous provisioning");
+ eap_fast_derive_key_provisioning(sm, data);
+ } else
+ eap_fast_derive_key_auth(sm, data);
+
+ eap_fast_state(data, PHASE2_START);
+
+ return 0;
+}
+
+
+static struct wpabuf * eap_fast_build_phase2_req(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ u8 id)
+{
+ struct wpabuf *req;
+
+ if (data->phase2_priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Phase 2 method not "
+ "initialized");
+ return NULL;
+ }
+ req = data->phase2_method->buildReq(sm, data->phase2_priv, id);
+ if (req == NULL)
+ return NULL;
+
+ wpa_hexdump_buf_key(MSG_MSGDUMP, "EAP-FAST: Phase 2 EAP-Request", req);
+ return eap_fast_tlv_eap_payload(req);
+}
+
+
+static struct wpabuf * eap_fast_build_crypto_binding(
+ struct eap_sm *sm, struct eap_fast_data *data)
+{
+ struct wpabuf *buf;
+ struct eap_tlv_result_tlv *result;
+ struct eap_tlv_crypto_binding_tlv *binding;
+
+ buf = wpabuf_alloc(2 * sizeof(*result) + sizeof(*binding));
+ if (buf == NULL)
+ return NULL;
+
+ if (data->send_new_pac || data->anon_provisioning ||
+ data->phase2_method)
+ data->final_result = 0;
+ else
+ data->final_result = 1;
+
+ if (!data->final_result || data->eap_seq > 1) {
+ /* Intermediate-Result */
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Add Intermediate-Result TLV "
+ "(status=SUCCESS)");
+ result = wpabuf_put(buf, sizeof(*result));
+ result->tlv_type = host_to_be16(
+ EAP_TLV_TYPE_MANDATORY |
+ EAP_TLV_INTERMEDIATE_RESULT_TLV);
+ result->length = host_to_be16(2);
+ result->status = host_to_be16(EAP_TLV_RESULT_SUCCESS);
+ }
+
+ if (data->final_result) {
+ /* Result TLV */
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Add Result TLV "
+ "(status=SUCCESS)");
+ result = wpabuf_put(buf, sizeof(*result));
+ result->tlv_type = host_to_be16(EAP_TLV_TYPE_MANDATORY |
+ EAP_TLV_RESULT_TLV);
+ result->length = host_to_be16(2);
+ result->status = host_to_be16(EAP_TLV_RESULT_SUCCESS);
+ }
+
+ /* Crypto-Binding TLV */
+ binding = wpabuf_put(buf, sizeof(*binding));
+ binding->tlv_type = host_to_be16(EAP_TLV_TYPE_MANDATORY |
+ EAP_TLV_CRYPTO_BINDING_TLV);
+ binding->length = host_to_be16(sizeof(*binding) -
+ sizeof(struct eap_tlv_hdr));
+ binding->version = EAP_FAST_VERSION;
+ binding->received_version = data->peer_version;
+ binding->subtype = EAP_TLV_CRYPTO_BINDING_SUBTYPE_REQUEST;
+ if (random_get_bytes(binding->nonce, sizeof(binding->nonce)) < 0) {
+ wpabuf_free(buf);
+ return NULL;
+ }
+
+ /*
+ * RFC 4851, Section 4.2.8:
+ * The nonce in a request MUST have its least significant bit set to 0.
+ */
+ binding->nonce[sizeof(binding->nonce) - 1] &= ~0x01;
+
+ os_memcpy(data->crypto_binding_nonce, binding->nonce,
+ sizeof(binding->nonce));
+
+ /*
+ * RFC 4851, Section 5.3:
+ * CMK = CMK[j]
+ * Compound-MAC = HMAC-SHA1( CMK, Crypto-Binding TLV )
+ */
+
+ hmac_sha1(data->cmk, EAP_FAST_CMK_LEN,
+ (u8 *) binding, sizeof(*binding),
+ binding->compound_mac);
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Add Crypto-Binding TLV: Version %d "
+ "Received Version %d SubType %d",
+ binding->version, binding->received_version,
+ binding->subtype);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-FAST: NONCE",
+ binding->nonce, sizeof(binding->nonce));
+ wpa_hexdump(MSG_MSGDUMP, "EAP-FAST: Compound MAC",
+ binding->compound_mac, sizeof(binding->compound_mac));
+
+ return buf;
+}
+
+
+static struct wpabuf * eap_fast_build_pac(struct eap_sm *sm,
+ struct eap_fast_data *data)
+{
+ u8 pac_key[EAP_FAST_PAC_KEY_LEN];
+ u8 *pac_buf, *pac_opaque;
+ struct wpabuf *buf;
+ u8 *pos;
+ size_t buf_len, srv_id_info_len, pac_len;
+ struct eap_tlv_hdr *pac_tlv;
+ struct pac_tlv_hdr *pac_info;
+ struct eap_tlv_result_tlv *result;
+ struct os_time now;
+
+ if (random_get_bytes(pac_key, EAP_FAST_PAC_KEY_LEN) < 0 ||
+ os_get_time(&now) < 0)
+ return NULL;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-FAST: Generated PAC-Key",
+ pac_key, EAP_FAST_PAC_KEY_LEN);
+
+ pac_len = (2 + EAP_FAST_PAC_KEY_LEN) + (2 + 4) +
+ (2 + sm->identity_len) + 8;
+ pac_buf = os_malloc(pac_len);
+ if (pac_buf == NULL)
+ return NULL;
+
+ srv_id_info_len = os_strlen(data->srv_id_info);
+
+ pos = pac_buf;
+ *pos++ = PAC_OPAQUE_TYPE_KEY;
+ *pos++ = EAP_FAST_PAC_KEY_LEN;
+ os_memcpy(pos, pac_key, EAP_FAST_PAC_KEY_LEN);
+ pos += EAP_FAST_PAC_KEY_LEN;
+
+ *pos++ = PAC_OPAQUE_TYPE_LIFETIME;
+ *pos++ = 4;
+ WPA_PUT_BE32(pos, now.sec + data->pac_key_lifetime);
+ pos += 4;
+
+ if (sm->identity) {
+ *pos++ = PAC_OPAQUE_TYPE_IDENTITY;
+ *pos++ = sm->identity_len;
+ os_memcpy(pos, sm->identity, sm->identity_len);
+ pos += sm->identity_len;
+ }
+
+ pac_len = pos - pac_buf;
+ while (pac_len % 8) {
+ *pos++ = PAC_OPAQUE_TYPE_PAD;
+ pac_len++;
+ }
+
+ pac_opaque = os_malloc(pac_len + 8);
+ if (pac_opaque == NULL) {
+ os_free(pac_buf);
+ return NULL;
+ }
+ if (aes_wrap(data->pac_opaque_encr, pac_len / 8, pac_buf,
+ pac_opaque) < 0) {
+ os_free(pac_buf);
+ os_free(pac_opaque);
+ return NULL;
+ }
+ os_free(pac_buf);
+
+ pac_len += 8;
+ wpa_hexdump(MSG_DEBUG, "EAP-FAST: PAC-Opaque",
+ pac_opaque, pac_len);
+
+ buf_len = sizeof(*pac_tlv) +
+ sizeof(struct pac_tlv_hdr) + EAP_FAST_PAC_KEY_LEN +
+ sizeof(struct pac_tlv_hdr) + pac_len +
+ data->srv_id_len + srv_id_info_len + 100 + sizeof(*result);
+ buf = wpabuf_alloc(buf_len);
+ if (buf == NULL) {
+ os_free(pac_opaque);
+ return NULL;
+ }
+
+ /* Result TLV */
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Add Result TLV (status=SUCCESS)");
+ result = wpabuf_put(buf, sizeof(*result));
+ WPA_PUT_BE16((u8 *) &result->tlv_type,
+ EAP_TLV_TYPE_MANDATORY | EAP_TLV_RESULT_TLV);
+ WPA_PUT_BE16((u8 *) &result->length, 2);
+ WPA_PUT_BE16((u8 *) &result->status, EAP_TLV_RESULT_SUCCESS);
+
+ /* PAC TLV */
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Add PAC TLV");
+ pac_tlv = wpabuf_put(buf, sizeof(*pac_tlv));
+ pac_tlv->tlv_type = host_to_be16(EAP_TLV_TYPE_MANDATORY |
+ EAP_TLV_PAC_TLV);
+
+ /* PAC-Key */
+ eap_fast_put_tlv(buf, PAC_TYPE_PAC_KEY, pac_key, EAP_FAST_PAC_KEY_LEN);
+
+ /* PAC-Opaque */
+ eap_fast_put_tlv(buf, PAC_TYPE_PAC_OPAQUE, pac_opaque, pac_len);
+ os_free(pac_opaque);
+
+ /* PAC-Info */
+ pac_info = wpabuf_put(buf, sizeof(*pac_info));
+ pac_info->type = host_to_be16(PAC_TYPE_PAC_INFO);
+
+ /* PAC-Lifetime (inside PAC-Info) */
+ eap_fast_put_tlv_hdr(buf, PAC_TYPE_CRED_LIFETIME, 4);
+ wpabuf_put_be32(buf, now.sec + data->pac_key_lifetime);
+
+ /* A-ID (inside PAC-Info) */
+ eap_fast_put_tlv(buf, PAC_TYPE_A_ID, data->srv_id, data->srv_id_len);
+
+ /* Note: headers may be misaligned after A-ID */
+
+ if (sm->identity) {
+ eap_fast_put_tlv(buf, PAC_TYPE_I_ID, sm->identity,
+ sm->identity_len);
+ }
+
+ /* A-ID-Info (inside PAC-Info) */
+ eap_fast_put_tlv(buf, PAC_TYPE_A_ID_INFO, data->srv_id_info,
+ srv_id_info_len);
+
+ /* PAC-Type (inside PAC-Info) */
+ eap_fast_put_tlv_hdr(buf, PAC_TYPE_PAC_TYPE, 2);
+ wpabuf_put_be16(buf, PAC_TYPE_TUNNEL_PAC);
+
+ /* Update PAC-Info and PAC TLV Length fields */
+ pos = wpabuf_put(buf, 0);
+ pac_info->len = host_to_be16(pos - (u8 *) (pac_info + 1));
+ pac_tlv->length = host_to_be16(pos - (u8 *) (pac_tlv + 1));
+
+ return buf;
+}
+
+
+static int eap_fast_encrypt_phase2(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ struct wpabuf *plain, int piggyback)
+{
+ struct wpabuf *encr;
+
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-FAST: Encrypting Phase 2 TLVs",
+ plain);
+ encr = eap_server_tls_encrypt(sm, &data->ssl, plain);
+ wpabuf_free(plain);
+
+ if (data->ssl.tls_out && piggyback) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Piggyback Phase 2 data "
+ "(len=%d) with last Phase 1 Message (len=%d "
+ "used=%d)",
+ (int) wpabuf_len(encr),
+ (int) wpabuf_len(data->ssl.tls_out),
+ (int) data->ssl.tls_out_pos);
+ if (wpabuf_resize(&data->ssl.tls_out, wpabuf_len(encr)) < 0) {
+ wpa_printf(MSG_WARNING, "EAP-FAST: Failed to resize "
+ "output buffer");
+ wpabuf_free(encr);
+ return -1;
+ }
+ wpabuf_put_buf(data->ssl.tls_out, encr);
+ wpabuf_free(encr);
+ } else {
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = encr;
+ }
+
+ return 0;
+}
+
+
+static struct wpabuf * eap_fast_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_fast_data *data = priv;
+ struct wpabuf *req = NULL;
+ int piggyback = 0;
+
+ if (data->ssl.state == FRAG_ACK) {
+ return eap_server_tls_build_ack(id, EAP_TYPE_FAST,
+ data->fast_version);
+ }
+
+ if (data->ssl.state == WAIT_FRAG_ACK) {
+ return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_FAST,
+ data->fast_version, id);
+ }
+
+ switch (data->state) {
+ case START:
+ return eap_fast_build_start(sm, data, id);
+ case PHASE1:
+ if (tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
+ if (eap_fast_phase1_done(sm, data) < 0)
+ return NULL;
+ if (data->state == PHASE2_START) {
+ /*
+ * Try to generate Phase 2 data to piggyback
+ * with the end of Phase 1 to avoid extra
+ * roundtrip.
+ */
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Try to start "
+ "Phase 2");
+ if (eap_fast_process_phase2_start(sm, data))
+ break;
+ req = eap_fast_build_phase2_req(sm, data, id);
+ piggyback = 1;
+ }
+ }
+ break;
+ case PHASE2_ID:
+ case PHASE2_METHOD:
+ req = eap_fast_build_phase2_req(sm, data, id);
+ break;
+ case CRYPTO_BINDING:
+ req = eap_fast_build_crypto_binding(sm, data);
+ if (data->phase2_method) {
+ /*
+ * Include the start of the next EAP method in the
+ * sequence in the same message with Crypto-Binding to
+ * save a round-trip.
+ */
+ struct wpabuf *eap;
+ eap = eap_fast_build_phase2_req(sm, data, id);
+ req = wpabuf_concat(req, eap);
+ eap_fast_state(data, PHASE2_METHOD);
+ }
+ break;
+ case REQUEST_PAC:
+ req = eap_fast_build_pac(sm, data);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-FAST: %s - unexpected state %d",
+ __func__, data->state);
+ return NULL;
+ }
+
+ if (req &&
+ eap_fast_encrypt_phase2(sm, data, req, piggyback) < 0)
+ return NULL;
+
+ return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_FAST,
+ data->fast_version, id);
+}
+
+
+static Boolean eap_fast_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_FAST, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static int eap_fast_phase2_init(struct eap_sm *sm, struct eap_fast_data *data,
+ EapType eap_type)
+{
+ if (data->phase2_priv && data->phase2_method) {
+ data->phase2_method->reset(sm, data->phase2_priv);
+ data->phase2_method = NULL;
+ data->phase2_priv = NULL;
+ }
+ data->phase2_method = eap_server_get_eap_method(EAP_VENDOR_IETF,
+ eap_type);
+ if (!data->phase2_method)
+ return -1;
+
+ if (data->key_block_p) {
+ sm->auth_challenge = data->key_block_p->server_challenge;
+ sm->peer_challenge = data->key_block_p->client_challenge;
+ }
+ sm->init_phase2 = 1;
+ data->phase2_priv = data->phase2_method->init(sm);
+ sm->init_phase2 = 0;
+ sm->auth_challenge = NULL;
+ sm->peer_challenge = NULL;
+
+ return data->phase2_priv == NULL ? -1 : 0;
+}
+
+
+static void eap_fast_process_phase2_response(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ u8 *in_data, size_t in_len)
+{
+ u8 next_type = EAP_TYPE_NONE;
+ struct eap_hdr *hdr;
+ u8 *pos;
+ size_t left;
+ struct wpabuf buf;
+ const struct eap_method *m = data->phase2_method;
+ void *priv = data->phase2_priv;
+
+ if (priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: %s - Phase2 not "
+ "initialized?!", __func__);
+ return;
+ }
+
+ hdr = (struct eap_hdr *) in_data;
+ pos = (u8 *) (hdr + 1);
+
+ if (in_len > sizeof(*hdr) && *pos == EAP_TYPE_NAK) {
+ left = in_len - sizeof(*hdr);
+ wpa_hexdump(MSG_DEBUG, "EAP-FAST: Phase2 type Nak'ed; "
+ "allowed types", pos + 1, left - 1);
+#ifdef EAP_SERVER_TNC
+ if (m && m->vendor == EAP_VENDOR_IETF &&
+ m->method == EAP_TYPE_TNC) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Peer Nak'ed required "
+ "TNC negotiation");
+ next_type = eap_fast_req_failure(sm, data);
+ eap_fast_phase2_init(sm, data, next_type);
+ return;
+ }
+#endif /* EAP_SERVER_TNC */
+ eap_sm_process_nak(sm, pos + 1, left - 1);
+ if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
+ sm->user->methods[sm->user_eap_method_index].method !=
+ EAP_TYPE_NONE) {
+ next_type = sm->user->methods[
+ sm->user_eap_method_index++].method;
+ wpa_printf(MSG_DEBUG, "EAP-FAST: try EAP type %d",
+ next_type);
+ } else {
+ next_type = eap_fast_req_failure(sm, data);
+ }
+ eap_fast_phase2_init(sm, data, next_type);
+ return;
+ }
+
+ wpabuf_set(&buf, in_data, in_len);
+
+ if (m->check(sm, priv, &buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Phase2 check() asked to "
+ "ignore the packet");
+ next_type = eap_fast_req_failure(sm, data);
+ return;
+ }
+
+ m->process(sm, priv, &buf);
+
+ if (!m->isDone(sm, priv))
+ return;
+
+ if (!m->isSuccess(sm, priv)) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Phase2 method failed");
+ next_type = eap_fast_req_failure(sm, data);
+ eap_fast_phase2_init(sm, data, next_type);
+ return;
+ }
+
+ switch (data->state) {
+ case PHASE2_ID:
+ if (eap_user_get(sm, sm->identity, sm->identity_len, 1) != 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-FAST: Phase2 "
+ "Identity not found in the user "
+ "database",
+ sm->identity, sm->identity_len);
+ next_type = eap_fast_req_failure(sm, data);
+ break;
+ }
+
+ eap_fast_state(data, PHASE2_METHOD);
+ if (data->anon_provisioning) {
+ /*
+ * Only EAP-MSCHAPv2 is allowed for anonymous
+ * provisioning.
+ */
+ next_type = EAP_TYPE_MSCHAPV2;
+ sm->user_eap_method_index = 0;
+ } else {
+ next_type = sm->user->methods[0].method;
+ sm->user_eap_method_index = 1;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-FAST: try EAP type %d", next_type);
+ break;
+ case PHASE2_METHOD:
+ case CRYPTO_BINDING:
+ eap_fast_update_icmk(sm, data);
+ eap_fast_state(data, CRYPTO_BINDING);
+ data->eap_seq++;
+ next_type = EAP_TYPE_NONE;
+#ifdef EAP_SERVER_TNC
+ if (sm->tnc && !data->tnc_started) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Initialize TNC");
+ next_type = EAP_TYPE_TNC;
+ data->tnc_started = 1;
+ }
+#endif /* EAP_SERVER_TNC */
+ break;
+ case FAILURE:
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-FAST: %s - unexpected state %d",
+ __func__, data->state);
+ break;
+ }
+
+ eap_fast_phase2_init(sm, data, next_type);
+}
+
+
+static void eap_fast_process_phase2_eap(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ u8 *in_data, size_t in_len)
+{
+ struct eap_hdr *hdr;
+ size_t len;
+
+ hdr = (struct eap_hdr *) in_data;
+ if (in_len < (int) sizeof(*hdr)) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Too short Phase 2 "
+ "EAP frame (len=%lu)", (unsigned long) in_len);
+ eap_fast_req_failure(sm, data);
+ return;
+ }
+ len = be_to_host16(hdr->length);
+ if (len > in_len) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Length mismatch in "
+ "Phase 2 EAP frame (len=%lu hdr->length=%lu)",
+ (unsigned long) in_len, (unsigned long) len);
+ eap_fast_req_failure(sm, data);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Received Phase 2: code=%d "
+ "identifier=%d length=%lu", hdr->code, hdr->identifier,
+ (unsigned long) len);
+ switch (hdr->code) {
+ case EAP_CODE_RESPONSE:
+ eap_fast_process_phase2_response(sm, data, (u8 *) hdr, len);
+ break;
+ default:
+ wpa_printf(MSG_INFO, "EAP-FAST: Unexpected code=%d in "
+ "Phase 2 EAP header", hdr->code);
+ break;
+ }
+}
+
+
+static int eap_fast_parse_tlvs(struct wpabuf *data,
+ struct eap_fast_tlv_parse *tlv)
+{
+ int mandatory, tlv_type, len, res;
+ u8 *pos, *end;
+
+ os_memset(tlv, 0, sizeof(*tlv));
+
+ pos = wpabuf_mhead(data);
+ end = pos + wpabuf_len(data);
+ while (pos + 4 < end) {
+ mandatory = pos[0] & 0x80;
+ tlv_type = WPA_GET_BE16(pos) & 0x3fff;
+ pos += 2;
+ len = WPA_GET_BE16(pos);
+ pos += 2;
+ if (pos + len > end) {
+ wpa_printf(MSG_INFO, "EAP-FAST: TLV overflow");
+ return -1;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Received Phase 2: "
+ "TLV type %d length %d%s",
+ tlv_type, len, mandatory ? " (mandatory)" : "");
+
+ res = eap_fast_parse_tlv(tlv, tlv_type, pos, len);
+ if (res == -2)
+ break;
+ if (res < 0) {
+ if (mandatory) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Nak unknown "
+ "mandatory TLV type %d", tlv_type);
+ /* TODO: generate Nak TLV */
+ break;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Ignored "
+ "unknown optional TLV type %d",
+ tlv_type);
+ }
+ }
+
+ pos += len;
+ }
+
+ return 0;
+}
+
+
+static int eap_fast_validate_crypto_binding(
+ struct eap_fast_data *data, struct eap_tlv_crypto_binding_tlv *b,
+ size_t bind_len)
+{
+ u8 cmac[SHA1_MAC_LEN];
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Reply Crypto-Binding TLV: "
+ "Version %d Received Version %d SubType %d",
+ b->version, b->received_version, b->subtype);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-FAST: NONCE",
+ b->nonce, sizeof(b->nonce));
+ wpa_hexdump(MSG_MSGDUMP, "EAP-FAST: Compound MAC",
+ b->compound_mac, sizeof(b->compound_mac));
+
+ if (b->version != EAP_FAST_VERSION ||
+ b->received_version != EAP_FAST_VERSION) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Unexpected version "
+ "in Crypto-Binding: version %d "
+ "received_version %d", b->version,
+ b->received_version);
+ return -1;
+ }
+
+ if (b->subtype != EAP_TLV_CRYPTO_BINDING_SUBTYPE_RESPONSE) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Unexpected subtype in "
+ "Crypto-Binding: %d", b->subtype);
+ return -1;
+ }
+
+ if (os_memcmp(data->crypto_binding_nonce, b->nonce, 31) != 0 ||
+ (data->crypto_binding_nonce[31] | 1) != b->nonce[31]) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Invalid nonce in "
+ "Crypto-Binding");
+ return -1;
+ }
+
+ os_memcpy(cmac, b->compound_mac, sizeof(cmac));
+ os_memset(b->compound_mac, 0, sizeof(cmac));
+ wpa_hexdump(MSG_MSGDUMP, "EAP-FAST: Crypto-Binding TLV for "
+ "Compound MAC calculation",
+ (u8 *) b, bind_len);
+ hmac_sha1(data->cmk, EAP_FAST_CMK_LEN, (u8 *) b, bind_len,
+ b->compound_mac);
+ if (os_memcmp(cmac, b->compound_mac, sizeof(cmac)) != 0) {
+ wpa_hexdump(MSG_MSGDUMP,
+ "EAP-FAST: Calculated Compound MAC",
+ b->compound_mac, sizeof(cmac));
+ wpa_printf(MSG_INFO, "EAP-FAST: Compound MAC did not "
+ "match");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int eap_fast_pac_type(u8 *pac, size_t len, u16 type)
+{
+ struct eap_tlv_pac_type_tlv *tlv;
+
+ if (pac == NULL || len != sizeof(*tlv))
+ return 0;
+
+ tlv = (struct eap_tlv_pac_type_tlv *) pac;
+
+ return be_to_host16(tlv->tlv_type) == PAC_TYPE_PAC_TYPE &&
+ be_to_host16(tlv->length) == 2 &&
+ be_to_host16(tlv->pac_type) == type;
+}
+
+
+static void eap_fast_process_phase2_tlvs(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ struct wpabuf *in_data)
+{
+ struct eap_fast_tlv_parse tlv;
+ int check_crypto_binding = data->state == CRYPTO_BINDING;
+
+ if (eap_fast_parse_tlvs(in_data, &tlv) < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to parse received "
+ "Phase 2 TLVs");
+ return;
+ }
+
+ if (tlv.result == EAP_TLV_RESULT_FAILURE) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Result TLV indicated "
+ "failure");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ if (data->state == REQUEST_PAC) {
+ u16 type, len, res;
+ if (tlv.pac == NULL || tlv.pac_len < 6) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: No PAC "
+ "Acknowledgement received");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ type = WPA_GET_BE16(tlv.pac);
+ len = WPA_GET_BE16(tlv.pac + 2);
+ res = WPA_GET_BE16(tlv.pac + 4);
+
+ if (type != PAC_TYPE_PAC_ACKNOWLEDGEMENT || len != 2 ||
+ res != EAP_TLV_RESULT_SUCCESS) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: PAC TLV did not "
+ "contain acknowledgement");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: PAC-Acknowledgement received "
+ "- PAC provisioning succeeded");
+ eap_fast_state(data, (data->anon_provisioning ||
+ data->send_new_pac == 2) ?
+ FAILURE : SUCCESS);
+ return;
+ }
+
+ if (check_crypto_binding) {
+ if (tlv.crypto_binding == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: No Crypto-Binding "
+ "TLV received");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ if (data->final_result &&
+ tlv.result != EAP_TLV_RESULT_SUCCESS) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Crypto-Binding TLV "
+ "without Success Result");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ if (!data->final_result &&
+ tlv.iresult != EAP_TLV_RESULT_SUCCESS) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Crypto-Binding TLV "
+ "without intermediate Success Result");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ if (eap_fast_validate_crypto_binding(data, tlv.crypto_binding,
+ tlv.crypto_binding_len)) {
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Valid Crypto-Binding TLV "
+ "received");
+ if (data->final_result) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Authentication "
+ "completed successfully");
+ }
+
+ if (data->anon_provisioning &&
+ sm->eap_fast_prov != ANON_PROV &&
+ sm->eap_fast_prov != BOTH_PROV) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Client is trying to "
+ "use unauthenticated provisioning which is "
+ "disabled");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ if (sm->eap_fast_prov != AUTH_PROV &&
+ sm->eap_fast_prov != BOTH_PROV &&
+ tlv.request_action == EAP_TLV_ACTION_PROCESS_TLV &&
+ eap_fast_pac_type(tlv.pac, tlv.pac_len,
+ PAC_TYPE_TUNNEL_PAC)) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Client is trying to "
+ "use authenticated provisioning which is "
+ "disabled");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ if (data->anon_provisioning ||
+ (tlv.request_action == EAP_TLV_ACTION_PROCESS_TLV &&
+ eap_fast_pac_type(tlv.pac, tlv.pac_len,
+ PAC_TYPE_TUNNEL_PAC))) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Requested a new "
+ "Tunnel PAC");
+ eap_fast_state(data, REQUEST_PAC);
+ } else if (data->send_new_pac) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Server triggered "
+ "re-keying of Tunnel PAC");
+ eap_fast_state(data, REQUEST_PAC);
+ } else if (data->final_result)
+ eap_fast_state(data, SUCCESS);
+ }
+
+ if (tlv.eap_payload_tlv) {
+ eap_fast_process_phase2_eap(sm, data, tlv.eap_payload_tlv,
+ tlv.eap_payload_tlv_len);
+ }
+}
+
+
+static void eap_fast_process_phase2(struct eap_sm *sm,
+ struct eap_fast_data *data,
+ struct wpabuf *in_buf)
+{
+ struct wpabuf *in_decrypted;
+
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Received %lu bytes encrypted data for"
+ " Phase 2", (unsigned long) wpabuf_len(in_buf));
+
+ if (data->pending_phase2_resp) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Pending Phase 2 response - "
+ "skip decryption and use old data");
+ eap_fast_process_phase2_tlvs(sm, data,
+ data->pending_phase2_resp);
+ wpabuf_free(data->pending_phase2_resp);
+ data->pending_phase2_resp = NULL;
+ return;
+ }
+
+ in_decrypted = tls_connection_decrypt(sm->ssl_ctx, data->ssl.conn,
+ in_buf);
+ if (in_decrypted == NULL) {
+ wpa_printf(MSG_INFO, "EAP-FAST: Failed to decrypt Phase 2 "
+ "data");
+ eap_fast_state(data, FAILURE);
+ return;
+ }
+
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-FAST: Decrypted Phase 2 TLVs",
+ in_decrypted);
+
+ eap_fast_process_phase2_tlvs(sm, data, in_decrypted);
+
+ if (sm->method_pending == METHOD_PENDING_WAIT) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Phase2 method is in "
+ "pending wait state - save decrypted response");
+ wpabuf_free(data->pending_phase2_resp);
+ data->pending_phase2_resp = in_decrypted;
+ return;
+ }
+
+ wpabuf_free(in_decrypted);
+}
+
+
+static int eap_fast_process_version(struct eap_sm *sm, void *priv,
+ int peer_version)
+{
+ struct eap_fast_data *data = priv;
+
+ data->peer_version = peer_version;
+
+ if (data->force_version >= 0 && peer_version != data->force_version) {
+ wpa_printf(MSG_INFO, "EAP-FAST: peer did not select the forced"
+ " version (forced=%d peer=%d) - reject",
+ data->force_version, peer_version);
+ return -1;
+ }
+
+ if (peer_version < data->fast_version) {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: peer ver=%d, own ver=%d; "
+ "use version %d",
+ peer_version, data->fast_version, peer_version);
+ data->fast_version = peer_version;
+ }
+
+ return 0;
+}
+
+
+static int eap_fast_process_phase1(struct eap_sm *sm,
+ struct eap_fast_data *data)
+{
+ if (eap_server_tls_phase1(sm, &data->ssl) < 0) {
+ wpa_printf(MSG_INFO, "EAP-FAST: TLS processing failed");
+ eap_fast_state(data, FAILURE);
+ return -1;
+ }
+
+ if (!tls_connection_established(sm->ssl_ctx, data->ssl.conn) ||
+ wpabuf_len(data->ssl.tls_out) > 0)
+ return 1;
+
+ /*
+ * Phase 1 was completed with the received message (e.g., when using
+ * abbreviated handshake), so Phase 2 can be started immediately
+ * without having to send through an empty message to the peer.
+ */
+
+ return eap_fast_phase1_done(sm, data);
+}
+
+
+static int eap_fast_process_phase2_start(struct eap_sm *sm,
+ struct eap_fast_data *data)
+{
+ u8 next_type;
+
+ if (data->identity) {
+ os_free(sm->identity);
+ sm->identity = data->identity;
+ data->identity = NULL;
+ sm->identity_len = data->identity_len;
+ data->identity_len = 0;
+ sm->require_identity_match = 1;
+ if (eap_user_get(sm, sm->identity, sm->identity_len, 1) != 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-FAST: "
+ "Phase2 Identity not found "
+ "in the user database",
+ sm->identity, sm->identity_len);
+ next_type = eap_fast_req_failure(sm, data);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Identity already "
+ "known - skip Phase 2 Identity Request");
+ next_type = sm->user->methods[0].method;
+ sm->user_eap_method_index = 1;
+ }
+
+ eap_fast_state(data, PHASE2_METHOD);
+ } else {
+ eap_fast_state(data, PHASE2_ID);
+ next_type = EAP_TYPE_IDENTITY;
+ }
+
+ return eap_fast_phase2_init(sm, data, next_type);
+}
+
+
+static void eap_fast_process_msg(struct eap_sm *sm, void *priv,
+ const struct wpabuf *respData)
+{
+ struct eap_fast_data *data = priv;
+
+ switch (data->state) {
+ case PHASE1:
+ if (eap_fast_process_phase1(sm, data))
+ break;
+
+ /* fall through to PHASE2_START */
+ case PHASE2_START:
+ eap_fast_process_phase2_start(sm, data);
+ break;
+ case PHASE2_ID:
+ case PHASE2_METHOD:
+ case CRYPTO_BINDING:
+ case REQUEST_PAC:
+ eap_fast_process_phase2(sm, data, data->ssl.tls_in);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-FAST: Unexpected state %d in %s",
+ data->state, __func__);
+ break;
+ }
+}
+
+
+static void eap_fast_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_fast_data *data = priv;
+ if (eap_server_tls_process(sm, &data->ssl, respData, data,
+ EAP_TYPE_FAST, eap_fast_process_version,
+ eap_fast_process_msg) < 0)
+ eap_fast_state(data, FAILURE);
+}
+
+
+static Boolean eap_fast_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_fast_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_fast_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_fast_data *data = priv;
+ u8 *eapKeyData;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ eapKeyData = os_malloc(EAP_FAST_KEY_LEN);
+ if (eapKeyData == NULL)
+ return NULL;
+
+ eap_fast_derive_eap_msk(data->simck, eapKeyData);
+ *len = EAP_FAST_KEY_LEN;
+
+ return eapKeyData;
+}
+
+
+static u8 * eap_fast_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_fast_data *data = priv;
+ u8 *eapKeyData;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ eapKeyData = os_malloc(EAP_EMSK_LEN);
+ if (eapKeyData == NULL)
+ return NULL;
+
+ eap_fast_derive_eap_emsk(data->simck, eapKeyData);
+ *len = EAP_EMSK_LEN;
+
+ return eapKeyData;
+}
+
+
+static Boolean eap_fast_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_fast_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_fast_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_FAST, "FAST");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_fast_init;
+ eap->reset = eap_fast_reset;
+ eap->buildReq = eap_fast_buildReq;
+ eap->check = eap_fast_check;
+ eap->process = eap_fast_process;
+ eap->isDone = eap_fast_isDone;
+ eap->getKey = eap_fast_getKey;
+ eap->get_emsk = eap_fast_get_emsk;
+ eap->isSuccess = eap_fast_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_gpsk.c b/src/eap_server/eap_server_gpsk.c
new file mode 100644
index 0000000..a794806
--- /dev/null
+++ b/src/eap_server/eap_server_gpsk.c
@@ -0,0 +1,634 @@
+/*
+ * hostapd / EAP-GPSK (RFC 5433) server
+ * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/random.h"
+#include "eap_server/eap_i.h"
+#include "eap_common/eap_gpsk_common.h"
+
+
+struct eap_gpsk_data {
+ enum { GPSK_1, GPSK_3, SUCCESS, FAILURE } state;
+ u8 rand_server[EAP_GPSK_RAND_LEN];
+ u8 rand_peer[EAP_GPSK_RAND_LEN];
+ u8 msk[EAP_MSK_LEN];
+ u8 emsk[EAP_EMSK_LEN];
+ u8 sk[EAP_GPSK_MAX_SK_LEN];
+ size_t sk_len;
+ u8 pk[EAP_GPSK_MAX_PK_LEN];
+ size_t pk_len;
+ u8 *id_peer;
+ size_t id_peer_len;
+ u8 *id_server;
+ size_t id_server_len;
+#define MAX_NUM_CSUITES 2
+ struct eap_gpsk_csuite csuite_list[MAX_NUM_CSUITES];
+ size_t csuite_count;
+ int vendor; /* CSuite/Vendor */
+ int specifier; /* CSuite/Specifier */
+};
+
+
+static const char * eap_gpsk_state_txt(int state)
+{
+ switch (state) {
+ case GPSK_1:
+ return "GPSK-1";
+ case GPSK_3:
+ return "GPSK-3";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "?";
+ }
+}
+
+
+static void eap_gpsk_state(struct eap_gpsk_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: %s -> %s",
+ eap_gpsk_state_txt(data->state),
+ eap_gpsk_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_gpsk_init(struct eap_sm *sm)
+{
+ struct eap_gpsk_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = GPSK_1;
+
+ /* TODO: add support for configuring ID_Server */
+ data->id_server = (u8 *) os_strdup("hostapd");
+ if (data->id_server)
+ data->id_server_len = os_strlen((char *) data->id_server);
+
+ data->csuite_count = 0;
+ if (eap_gpsk_supported_ciphersuite(EAP_GPSK_VENDOR_IETF,
+ EAP_GPSK_CIPHER_AES)) {
+ WPA_PUT_BE32(data->csuite_list[data->csuite_count].vendor,
+ EAP_GPSK_VENDOR_IETF);
+ WPA_PUT_BE16(data->csuite_list[data->csuite_count].specifier,
+ EAP_GPSK_CIPHER_AES);
+ data->csuite_count++;
+ }
+ if (eap_gpsk_supported_ciphersuite(EAP_GPSK_VENDOR_IETF,
+ EAP_GPSK_CIPHER_SHA256)) {
+ WPA_PUT_BE32(data->csuite_list[data->csuite_count].vendor,
+ EAP_GPSK_VENDOR_IETF);
+ WPA_PUT_BE16(data->csuite_list[data->csuite_count].specifier,
+ EAP_GPSK_CIPHER_SHA256);
+ data->csuite_count++;
+ }
+
+ return data;
+}
+
+
+static void eap_gpsk_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_gpsk_data *data = priv;
+ os_free(data->id_server);
+ os_free(data->id_peer);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_gpsk_build_gpsk_1(struct eap_sm *sm,
+ struct eap_gpsk_data *data, u8 id)
+{
+ size_t len;
+ struct wpabuf *req;
+
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Request/GPSK-1");
+
+ if (random_get_bytes(data->rand_server, EAP_GPSK_RAND_LEN)) {
+ wpa_printf(MSG_ERROR, "EAP-GPSK: Failed to get random data");
+ eap_gpsk_state(data, FAILURE);
+ return NULL;
+ }
+ wpa_hexdump(MSG_MSGDUMP, "EAP-GPSK: RAND_Server",
+ data->rand_server, EAP_GPSK_RAND_LEN);
+
+ len = 1 + 2 + data->id_server_len + EAP_GPSK_RAND_LEN + 2 +
+ data->csuite_count * sizeof(struct eap_gpsk_csuite);
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-GPSK: Failed to allocate memory "
+ "for request/GPSK-1");
+ eap_gpsk_state(data, FAILURE);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_GPSK_OPCODE_GPSK_1);
+ wpabuf_put_be16(req, data->id_server_len);
+ wpabuf_put_data(req, data->id_server, data->id_server_len);
+ wpabuf_put_data(req, data->rand_server, EAP_GPSK_RAND_LEN);
+ wpabuf_put_be16(req,
+ data->csuite_count * sizeof(struct eap_gpsk_csuite));
+ wpabuf_put_data(req, data->csuite_list,
+ data->csuite_count * sizeof(struct eap_gpsk_csuite));
+
+ return req;
+}
+
+
+static struct wpabuf * eap_gpsk_build_gpsk_3(struct eap_sm *sm,
+ struct eap_gpsk_data *data, u8 id)
+{
+ u8 *pos, *start;
+ size_t len, miclen;
+ struct eap_gpsk_csuite *csuite;
+ struct wpabuf *req;
+
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Request/GPSK-3");
+
+ miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
+ len = 1 + 2 * EAP_GPSK_RAND_LEN + 2 + data->id_server_len +
+ sizeof(struct eap_gpsk_csuite) + 2 + miclen;
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GPSK, len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-GPSK: Failed to allocate memory "
+ "for request/GPSK-3");
+ eap_gpsk_state(data, FAILURE);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_GPSK_OPCODE_GPSK_3);
+ start = wpabuf_put(req, 0);
+
+ wpabuf_put_data(req, data->rand_peer, EAP_GPSK_RAND_LEN);
+ wpabuf_put_data(req, data->rand_server, EAP_GPSK_RAND_LEN);
+ wpabuf_put_be16(req, data->id_server_len);
+ wpabuf_put_data(req, data->id_server, data->id_server_len);
+ csuite = wpabuf_put(req, sizeof(*csuite));
+ WPA_PUT_BE32(csuite->vendor, data->vendor);
+ WPA_PUT_BE16(csuite->specifier, data->specifier);
+
+ /* no PD_Payload_2 */
+ wpabuf_put_be16(req, 0);
+
+ pos = wpabuf_put(req, miclen);
+ if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
+ data->specifier, start, pos - start, pos) < 0)
+ {
+ os_free(req);
+ eap_gpsk_state(data, FAILURE);
+ return NULL;
+ }
+
+ return req;
+}
+
+
+static struct wpabuf * eap_gpsk_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_gpsk_data *data = priv;
+
+ switch (data->state) {
+ case GPSK_1:
+ return eap_gpsk_build_gpsk_1(sm, data, id);
+ case GPSK_3:
+ return eap_gpsk_build_gpsk_3(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown state %d in buildReq",
+ data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_gpsk_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_gpsk_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GPSK, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-GPSK: Invalid frame");
+ return TRUE;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Received frame: opcode=%d", *pos);
+
+ if (data->state == GPSK_1 && *pos == EAP_GPSK_OPCODE_GPSK_2)
+ return FALSE;
+
+ if (data->state == GPSK_3 && *pos == EAP_GPSK_OPCODE_GPSK_4)
+ return FALSE;
+
+ wpa_printf(MSG_INFO, "EAP-GPSK: Unexpected opcode=%d in state=%d",
+ *pos, data->state);
+
+ return TRUE;
+}
+
+
+static void eap_gpsk_process_gpsk_2(struct eap_sm *sm,
+ struct eap_gpsk_data *data,
+ const u8 *payload, size_t payloadlen)
+{
+ const u8 *pos, *end;
+ u16 alen;
+ const struct eap_gpsk_csuite *csuite;
+ size_t i, miclen;
+ u8 mic[EAP_GPSK_MAX_MIC_LEN];
+
+ if (data->state != GPSK_1)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Response/GPSK-2");
+
+ pos = payload;
+ end = payload + payloadlen;
+
+ if (end - pos < 2) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "ID_Peer length");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ alen = WPA_GET_BE16(pos);
+ pos += 2;
+ if (end - pos < alen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "ID_Peer");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ os_free(data->id_peer);
+ data->id_peer = os_malloc(alen);
+ if (data->id_peer == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Not enough memory to store "
+ "%d-octet ID_Peer", alen);
+ return;
+ }
+ os_memcpy(data->id_peer, pos, alen);
+ data->id_peer_len = alen;
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-GPSK: ID_Peer",
+ data->id_peer, data->id_peer_len);
+ pos += alen;
+
+ if (end - pos < 2) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "ID_Server length");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ alen = WPA_GET_BE16(pos);
+ pos += 2;
+ if (end - pos < alen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "ID_Server");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (alen != data->id_server_len ||
+ os_memcmp(pos, data->id_server, alen) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: ID_Server in GPSK-1 and "
+ "GPSK-2 did not match");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ pos += alen;
+
+ if (end - pos < EAP_GPSK_RAND_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "RAND_Peer");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ os_memcpy(data->rand_peer, pos, EAP_GPSK_RAND_LEN);
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Peer",
+ data->rand_peer, EAP_GPSK_RAND_LEN);
+ pos += EAP_GPSK_RAND_LEN;
+
+ if (end - pos < EAP_GPSK_RAND_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "RAND_Server");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (os_memcmp(data->rand_server, pos, EAP_GPSK_RAND_LEN) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-1 and "
+ "GPSK-2 did not match");
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-1",
+ data->rand_server, EAP_GPSK_RAND_LEN);
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: RAND_Server in GPSK-2",
+ pos, EAP_GPSK_RAND_LEN);
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ pos += EAP_GPSK_RAND_LEN;
+
+ if (end - pos < 2) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "CSuite_List length");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ alen = WPA_GET_BE16(pos);
+ pos += 2;
+ if (end - pos < alen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "CSuite_List");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (alen != data->csuite_count * sizeof(struct eap_gpsk_csuite) ||
+ os_memcmp(pos, data->csuite_list, alen) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_List in GPSK-1 and "
+ "GPSK-2 did not match");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ pos += alen;
+
+ if (end - pos < (int) sizeof(*csuite)) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "CSuite_Sel");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ csuite = (const struct eap_gpsk_csuite *) pos;
+ for (i = 0; i < data->csuite_count; i++) {
+ if (os_memcmp(csuite, &data->csuite_list[i], sizeof(*csuite))
+ == 0)
+ break;
+ }
+ if (i == data->csuite_count) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Peer selected unsupported "
+ "ciphersuite %d:%d",
+ WPA_GET_BE32(csuite->vendor),
+ WPA_GET_BE16(csuite->specifier));
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ data->vendor = WPA_GET_BE32(csuite->vendor);
+ data->specifier = WPA_GET_BE16(csuite->specifier);
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: CSuite_Sel %d:%d",
+ data->vendor, data->specifier);
+ pos += sizeof(*csuite);
+
+ if (end - pos < 2) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "PD_Payload_1 length");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ alen = WPA_GET_BE16(pos);
+ pos += 2;
+ if (end - pos < alen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "PD_Payload_1");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: PD_Payload_1", pos, alen);
+ pos += alen;
+
+ if (sm->user == NULL || sm->user->password == NULL) {
+ wpa_printf(MSG_INFO, "EAP-GPSK: No PSK/password configured "
+ "for the user");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+
+ if (eap_gpsk_derive_keys(sm->user->password, sm->user->password_len,
+ data->vendor, data->specifier,
+ data->rand_peer, data->rand_server,
+ data->id_peer, data->id_peer_len,
+ data->id_server, data->id_server_len,
+ data->msk, data->emsk,
+ data->sk, &data->sk_len,
+ data->pk, &data->pk_len) < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to derive keys");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+
+ miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
+ if (end - pos < (int) miclen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for MIC "
+ "(left=%lu miclen=%lu)",
+ (unsigned long) (end - pos),
+ (unsigned long) miclen);
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
+ data->specifier, payload, pos - payload, mic)
+ < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to compute MIC");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (os_memcmp(mic, pos, miclen) != 0) {
+ wpa_printf(MSG_INFO, "EAP-GPSK: Incorrect MIC in GPSK-2");
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Received MIC", pos, miclen);
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Computed MIC", mic, miclen);
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ pos += miclen;
+
+ if (pos != end) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignored %lu bytes of extra "
+ "data in the end of GPSK-2",
+ (unsigned long) (end - pos));
+ }
+
+ eap_gpsk_state(data, GPSK_3);
+}
+
+
+static void eap_gpsk_process_gpsk_4(struct eap_sm *sm,
+ struct eap_gpsk_data *data,
+ const u8 *payload, size_t payloadlen)
+{
+ const u8 *pos, *end;
+ u16 alen;
+ size_t miclen;
+ u8 mic[EAP_GPSK_MAX_MIC_LEN];
+
+ if (data->state != GPSK_3)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Received Response/GPSK-4");
+
+ pos = payload;
+ end = payload + payloadlen;
+
+ if (end - pos < 2) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "PD_Payload_1 length");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ alen = WPA_GET_BE16(pos);
+ pos += 2;
+ if (end - pos < alen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Too short message for "
+ "PD_Payload_1");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: PD_Payload_1", pos, alen);
+ pos += alen;
+
+ miclen = eap_gpsk_mic_len(data->vendor, data->specifier);
+ if (end - pos < (int) miclen) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Message too short for MIC "
+ "(left=%lu miclen=%lu)",
+ (unsigned long) (end - pos),
+ (unsigned long) miclen);
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (eap_gpsk_compute_mic(data->sk, data->sk_len, data->vendor,
+ data->specifier, payload, pos - payload, mic)
+ < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to compute MIC");
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ if (os_memcmp(mic, pos, miclen) != 0) {
+ wpa_printf(MSG_INFO, "EAP-GPSK: Incorrect MIC in GPSK-4");
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Received MIC", pos, miclen);
+ wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Computed MIC", mic, miclen);
+ eap_gpsk_state(data, FAILURE);
+ return;
+ }
+ pos += miclen;
+
+ if (pos != end) {
+ wpa_printf(MSG_DEBUG, "EAP-GPSK: Ignored %lu bytes of extra "
+ "data in the end of GPSK-4",
+ (unsigned long) (end - pos));
+ }
+
+ eap_gpsk_state(data, SUCCESS);
+}
+
+
+static void eap_gpsk_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_gpsk_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GPSK, respData, &len);
+ if (pos == NULL || len < 1)
+ return;
+
+ switch (*pos) {
+ case EAP_GPSK_OPCODE_GPSK_2:
+ eap_gpsk_process_gpsk_2(sm, data, pos + 1, len - 1);
+ break;
+ case EAP_GPSK_OPCODE_GPSK_4:
+ eap_gpsk_process_gpsk_4(sm, data, pos + 1, len - 1);
+ break;
+ }
+}
+
+
+static Boolean eap_gpsk_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_gpsk_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_gpsk_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_gpsk_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_MSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->msk, EAP_MSK_LEN);
+ *len = EAP_MSK_LEN;
+
+ return key;
+}
+
+
+static u8 * eap_gpsk_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_gpsk_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->emsk, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+
+ return key;
+}
+
+
+static Boolean eap_gpsk_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_gpsk_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_gpsk_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_GPSK, "GPSK");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_gpsk_init;
+ eap->reset = eap_gpsk_reset;
+ eap->buildReq = eap_gpsk_buildReq;
+ eap->check = eap_gpsk_check;
+ eap->process = eap_gpsk_process;
+ eap->isDone = eap_gpsk_isDone;
+ eap->getKey = eap_gpsk_getKey;
+ eap->isSuccess = eap_gpsk_isSuccess;
+ eap->get_emsk = eap_gpsk_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_gtc.c b/src/eap_server/eap_server_gtc.c
new file mode 100644
index 0000000..79b9696
--- /dev/null
+++ b/src/eap_server/eap_server_gtc.c
@@ -0,0 +1,230 @@
+/*
+ * hostapd / EAP-GTC (RFC 3748)
+ * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+
+
+struct eap_gtc_data {
+ enum { CONTINUE, SUCCESS, FAILURE } state;
+ int prefix;
+};
+
+
+static void * eap_gtc_init(struct eap_sm *sm)
+{
+ struct eap_gtc_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = CONTINUE;
+
+#ifdef EAP_SERVER_FAST
+ if (sm->m && sm->m->vendor == EAP_VENDOR_IETF &&
+ sm->m->method == EAP_TYPE_FAST) {
+ wpa_printf(MSG_DEBUG, "EAP-GTC: EAP-FAST tunnel - use prefix "
+ "with challenge/response");
+ data->prefix = 1;
+ }
+#endif /* EAP_SERVER_FAST */
+
+ return data;
+}
+
+
+static void eap_gtc_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_gtc_data *data = priv;
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_gtc_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_gtc_data *data = priv;
+ struct wpabuf *req;
+ char *msg;
+ size_t msg_len;
+
+ msg = data->prefix ? "CHALLENGE=Password" : "Password";
+
+ msg_len = os_strlen(msg);
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_GTC, msg_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-GTC: Failed to allocate memory for "
+ "request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ wpabuf_put_data(req, msg, msg_len);
+
+ data->state = CONTINUE;
+
+ return req;
+}
+
+
+static Boolean eap_gtc_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GTC, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-GTC: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_gtc_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_gtc_data *data = priv;
+ const u8 *pos;
+ size_t rlen;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_GTC, respData, &rlen);
+ if (pos == NULL || rlen < 1)
+ return; /* Should not happen - frame already validated */
+
+ wpa_hexdump_ascii_key(MSG_MSGDUMP, "EAP-GTC: Response", pos, rlen);
+
+#ifdef EAP_SERVER_FAST
+ if (data->prefix) {
+ const u8 *pos2, *end;
+ /* "RESPONSE=<user>\0<password>" */
+ if (rlen < 10) {
+ wpa_printf(MSG_DEBUG, "EAP-GTC: Too short response "
+ "for EAP-FAST prefix");
+ data->state = FAILURE;
+ return;
+ }
+
+ end = pos + rlen;
+ pos += 9;
+ pos2 = pos;
+ while (pos2 < end && *pos2)
+ pos2++;
+ if (pos2 == end) {
+ wpa_printf(MSG_DEBUG, "EAP-GTC: No password in "
+ "response to EAP-FAST prefix");
+ data->state = FAILURE;
+ return;
+ }
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-GTC: Response user",
+ pos, pos2 - pos);
+ if (sm->identity && sm->require_identity_match &&
+ (pos2 - pos != (int) sm->identity_len ||
+ os_memcmp(pos, sm->identity, sm->identity_len))) {
+ wpa_printf(MSG_DEBUG, "EAP-GTC: Phase 2 Identity did "
+ "not match with required Identity");
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-GTC: Expected "
+ "identity",
+ sm->identity, sm->identity_len);
+ data->state = FAILURE;
+ return;
+ } else {
+ os_free(sm->identity);
+ sm->identity_len = pos2 - pos;
+ sm->identity = os_malloc(sm->identity_len);
+ if (sm->identity == NULL) {
+ data->state = FAILURE;
+ return;
+ }
+ os_memcpy(sm->identity, pos, sm->identity_len);
+ }
+
+ if (eap_user_get(sm, sm->identity, sm->identity_len, 1) != 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-GTC: Phase2 "
+ "Identity not found in the user "
+ "database",
+ sm->identity, sm->identity_len);
+ data->state = FAILURE;
+ return;
+ }
+
+ pos = pos2 + 1;
+ rlen = end - pos;
+ wpa_hexdump_ascii_key(MSG_MSGDUMP,
+ "EAP-GTC: Response password",
+ pos, rlen);
+ }
+#endif /* EAP_SERVER_FAST */
+
+ if (sm->user == NULL || sm->user->password == NULL ||
+ sm->user->password_hash) {
+ wpa_printf(MSG_INFO, "EAP-GTC: Plaintext password not "
+ "configured");
+ data->state = FAILURE;
+ return;
+ }
+
+ if (rlen != sm->user->password_len ||
+ os_memcmp(pos, sm->user->password, rlen) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-GTC: Done - Failure");
+ data->state = FAILURE;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-GTC: Done - Success");
+ data->state = SUCCESS;
+ }
+}
+
+
+static Boolean eap_gtc_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_gtc_data *data = priv;
+ return data->state != CONTINUE;
+}
+
+
+static Boolean eap_gtc_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_gtc_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_gtc_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_GTC, "GTC");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_gtc_init;
+ eap->reset = eap_gtc_reset;
+ eap->buildReq = eap_gtc_buildReq;
+ eap->check = eap_gtc_check;
+ eap->process = eap_gtc_process;
+ eap->isDone = eap_gtc_isDone;
+ eap->isSuccess = eap_gtc_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_identity.c b/src/eap_server/eap_server_identity.c
new file mode 100644
index 0000000..cd8da2a
--- /dev/null
+++ b/src/eap_server/eap_server_identity.c
@@ -0,0 +1,180 @@
+/*
+ * hostapd / EAP-Identity
+ * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+
+
+struct eap_identity_data {
+ enum { CONTINUE, SUCCESS, FAILURE } state;
+ int pick_up;
+};
+
+
+static void * eap_identity_init(struct eap_sm *sm)
+{
+ struct eap_identity_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = CONTINUE;
+
+ return data;
+}
+
+
+static void * eap_identity_initPickUp(struct eap_sm *sm)
+{
+ struct eap_identity_data *data;
+ data = eap_identity_init(sm);
+ if (data) {
+ data->pick_up = 1;
+ }
+ return data;
+}
+
+
+static void eap_identity_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_identity_data *data = priv;
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_identity_buildReq(struct eap_sm *sm, void *priv,
+ u8 id)
+{
+ struct eap_identity_data *data = priv;
+ struct wpabuf *req;
+ const char *req_data;
+ size_t req_data_len;
+
+ if (sm->eapol_cb->get_eap_req_id_text) {
+ req_data = sm->eapol_cb->get_eap_req_id_text(sm->eapol_ctx,
+ &req_data_len);
+ } else {
+ req_data = NULL;
+ req_data_len = 0;
+ }
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_IDENTITY, req_data_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-Identity: Failed to allocate "
+ "memory for request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ wpabuf_put_data(req, req_data, req_data_len);
+
+ return req;
+}
+
+
+static Boolean eap_identity_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_IDENTITY,
+ respData, &len);
+ if (pos == NULL) {
+ wpa_printf(MSG_INFO, "EAP-Identity: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_identity_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_identity_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ if (data->pick_up) {
+ if (eap_identity_check(sm, data, respData)) {
+ wpa_printf(MSG_DEBUG, "EAP-Identity: failed to pick "
+ "up already started negotiation");
+ data->state = FAILURE;
+ return;
+ }
+ data->pick_up = 0;
+ }
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_IDENTITY,
+ respData, &len);
+ if (pos == NULL)
+ return; /* Should not happen - frame already validated */
+
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-Identity: Peer identity", pos, len);
+ if (sm->identity)
+ sm->update_user = TRUE;
+ os_free(sm->identity);
+ sm->identity = os_malloc(len ? len : 1);
+ if (sm->identity == NULL) {
+ data->state = FAILURE;
+ } else {
+ os_memcpy(sm->identity, pos, len);
+ sm->identity_len = len;
+ data->state = SUCCESS;
+ }
+}
+
+
+static Boolean eap_identity_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_identity_data *data = priv;
+ return data->state != CONTINUE;
+}
+
+
+static Boolean eap_identity_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_identity_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_identity_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_IDENTITY,
+ "Identity");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_identity_init;
+ eap->initPickUp = eap_identity_initPickUp;
+ eap->reset = eap_identity_reset;
+ eap->buildReq = eap_identity_buildReq;
+ eap->check = eap_identity_check;
+ eap->process = eap_identity_process;
+ eap->isDone = eap_identity_isDone;
+ eap->isSuccess = eap_identity_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_ikev2.c b/src/eap_server/eap_server_ikev2.c
new file mode 100644
index 0000000..ec4fa87
--- /dev/null
+++ b/src/eap_server/eap_server_ikev2.c
@@ -0,0 +1,539 @@
+/*
+ * EAP-IKEv2 server (RFC 5106)
+ * Copyright (c) 2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+#include "eap_common/eap_ikev2_common.h"
+#include "ikev2.h"
+
+
+struct eap_ikev2_data {
+ struct ikev2_initiator_data ikev2;
+ enum { MSG, FRAG_ACK, WAIT_FRAG_ACK, DONE, FAIL } state;
+ struct wpabuf *in_buf;
+ struct wpabuf *out_buf;
+ size_t out_used;
+ size_t fragment_size;
+ int keys_ready;
+ u8 keymat[EAP_MSK_LEN + EAP_EMSK_LEN];
+ int keymat_ok;
+};
+
+
+static const u8 * eap_ikev2_get_shared_secret(void *ctx, const u8 *IDr,
+ size_t IDr_len,
+ size_t *secret_len)
+{
+ struct eap_sm *sm = ctx;
+
+ if (IDr == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: No IDr received - default "
+ "to user identity from EAP-Identity");
+ IDr = sm->identity;
+ IDr_len = sm->identity_len;
+ }
+
+ if (eap_user_get(sm, IDr, IDr_len, 0) < 0 || sm->user == NULL ||
+ sm->user->password == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: No user entry found");
+ return NULL;
+ }
+
+ *secret_len = sm->user->password_len;
+ return sm->user->password;
+}
+
+
+static const char * eap_ikev2_state_txt(int state)
+{
+ switch (state) {
+ case MSG:
+ return "MSG";
+ case FRAG_ACK:
+ return "FRAG_ACK";
+ case WAIT_FRAG_ACK:
+ return "WAIT_FRAG_ACK";
+ case DONE:
+ return "DONE";
+ case FAIL:
+ return "FAIL";
+ default:
+ return "?";
+ }
+}
+
+
+static void eap_ikev2_state(struct eap_ikev2_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: %s -> %s",
+ eap_ikev2_state_txt(data->state),
+ eap_ikev2_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_ikev2_init(struct eap_sm *sm)
+{
+ struct eap_ikev2_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = MSG;
+ data->fragment_size = sm->fragment_size > 0 ? sm->fragment_size :
+ IKEV2_FRAGMENT_SIZE;
+ data->ikev2.state = SA_INIT;
+ data->ikev2.peer_auth = PEER_AUTH_SECRET;
+ data->ikev2.key_pad = (u8 *) os_strdup("Key Pad for EAP-IKEv2");
+ if (data->ikev2.key_pad == NULL)
+ goto failed;
+ data->ikev2.key_pad_len = 21;
+
+ /* TODO: make proposals configurable */
+ data->ikev2.proposal.proposal_num = 1;
+ data->ikev2.proposal.integ = AUTH_HMAC_SHA1_96;
+ data->ikev2.proposal.prf = PRF_HMAC_SHA1;
+ data->ikev2.proposal.encr = ENCR_AES_CBC;
+ data->ikev2.proposal.dh = DH_GROUP2_1024BIT_MODP;
+
+ data->ikev2.IDi = (u8 *) os_strdup("hostapd");
+ data->ikev2.IDi_len = 7;
+
+ data->ikev2.get_shared_secret = eap_ikev2_get_shared_secret;
+ data->ikev2.cb_ctx = sm;
+
+ return data;
+
+failed:
+ ikev2_initiator_deinit(&data->ikev2);
+ os_free(data);
+ return NULL;
+}
+
+
+static void eap_ikev2_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_ikev2_data *data = priv;
+ wpabuf_free(data->in_buf);
+ wpabuf_free(data->out_buf);
+ ikev2_initiator_deinit(&data->ikev2);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_ikev2_build_msg(struct eap_ikev2_data *data, u8 id)
+{
+ struct wpabuf *req;
+ u8 flags;
+ size_t send_len, plen, icv_len = 0;
+
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Generating Request");
+
+ flags = 0;
+ send_len = wpabuf_len(data->out_buf) - data->out_used;
+ if (1 + send_len > data->fragment_size) {
+ send_len = data->fragment_size - 1;
+ flags |= IKEV2_FLAGS_MORE_FRAGMENTS;
+ if (data->out_used == 0) {
+ flags |= IKEV2_FLAGS_LENGTH_INCLUDED;
+ send_len -= 4;
+ }
+ }
+
+ plen = 1 + send_len;
+ if (flags & IKEV2_FLAGS_LENGTH_INCLUDED)
+ plen += 4;
+ if (data->keys_ready) {
+ const struct ikev2_integ_alg *integ;
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Add Integrity Checksum "
+ "Data");
+ flags |= IKEV2_FLAGS_ICV_INCLUDED;
+ integ = ikev2_get_integ(data->ikev2.proposal.integ);
+ if (integ == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Unknown INTEG "
+ "transform / cannot generate ICV");
+ return NULL;
+ }
+ icv_len = integ->hash_len;
+
+ plen += icv_len;
+ }
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_IKEV2, plen,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL)
+ return NULL;
+
+ wpabuf_put_u8(req, flags); /* Flags */
+ if (flags & IKEV2_FLAGS_LENGTH_INCLUDED)
+ wpabuf_put_be32(req, wpabuf_len(data->out_buf));
+
+ wpabuf_put_data(req, wpabuf_head_u8(data->out_buf) + data->out_used,
+ send_len);
+ data->out_used += send_len;
+
+ if (flags & IKEV2_FLAGS_ICV_INCLUDED) {
+ const u8 *msg = wpabuf_head(req);
+ size_t len = wpabuf_len(req);
+ ikev2_integ_hash(data->ikev2.proposal.integ,
+ data->ikev2.keys.SK_ai,
+ data->ikev2.keys.SK_integ_len,
+ msg, len, wpabuf_put(req, icv_len));
+ }
+
+ if (data->out_used == wpabuf_len(data->out_buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Sending out %lu bytes "
+ "(message sent completely)",
+ (unsigned long) send_len);
+ wpabuf_free(data->out_buf);
+ data->out_buf = NULL;
+ data->out_used = 0;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Sending out %lu bytes "
+ "(%lu more to send)", (unsigned long) send_len,
+ (unsigned long) wpabuf_len(data->out_buf) -
+ data->out_used);
+ eap_ikev2_state(data, WAIT_FRAG_ACK);
+ }
+
+ return req;
+}
+
+
+static struct wpabuf * eap_ikev2_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_ikev2_data *data = priv;
+
+ switch (data->state) {
+ case MSG:
+ if (data->out_buf == NULL) {
+ data->out_buf = ikev2_initiator_build(&data->ikev2);
+ if (data->out_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Failed to "
+ "generate IKEv2 message");
+ return NULL;
+ }
+ data->out_used = 0;
+ }
+ /* pass through */
+ case WAIT_FRAG_ACK:
+ return eap_ikev2_build_msg(data, id);
+ case FRAG_ACK:
+ return eap_ikev2_build_frag_ack(id, EAP_CODE_REQUEST);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Unexpected state %d in "
+ "buildReq", data->state);
+ return NULL;
+ }
+}
+
+
+static Boolean eap_ikev2_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_IKEV2, respData,
+ &len);
+ if (pos == NULL) {
+ wpa_printf(MSG_INFO, "EAP-IKEV2: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static int eap_ikev2_process_icv(struct eap_ikev2_data *data,
+ const struct wpabuf *respData,
+ u8 flags, const u8 *pos, const u8 **end)
+{
+ if (flags & IKEV2_FLAGS_ICV_INCLUDED) {
+ int icv_len = eap_ikev2_validate_icv(
+ data->ikev2.proposal.integ, &data->ikev2.keys, 0,
+ respData, pos, *end);
+ if (icv_len < 0)
+ return -1;
+ /* Hide Integrity Checksum Data from further processing */
+ *end -= icv_len;
+ } else if (data->keys_ready) {
+ wpa_printf(MSG_INFO, "EAP-IKEV2: The message should have "
+ "included integrity checksum");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int eap_ikev2_process_cont(struct eap_ikev2_data *data,
+ const u8 *buf, size_t len)
+{
+ /* Process continuation of a pending message */
+ if (len > wpabuf_tailroom(data->in_buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Fragment overflow");
+ eap_ikev2_state(data, FAIL);
+ return -1;
+ }
+
+ wpabuf_put_data(data->in_buf, buf, len);
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Received %lu bytes, waiting for %lu "
+ "bytes more", (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->in_buf));
+
+ return 0;
+}
+
+
+static int eap_ikev2_process_fragment(struct eap_ikev2_data *data,
+ u8 flags, u32 message_length,
+ const u8 *buf, size_t len)
+{
+ /* Process a fragment that is not the last one of the message */
+ if (data->in_buf == NULL && !(flags & IKEV2_FLAGS_LENGTH_INCLUDED)) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: No Message Length field in "
+ "a fragmented packet");
+ return -1;
+ }
+
+ if (data->in_buf == NULL) {
+ /* First fragment of the message */
+ data->in_buf = wpabuf_alloc(message_length);
+ if (data->in_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: No memory for "
+ "message");
+ return -1;
+ }
+ wpabuf_put_data(data->in_buf, buf, len);
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Received %lu bytes in first "
+ "fragment, waiting for %lu bytes more",
+ (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->in_buf));
+ }
+
+ return 0;
+}
+
+
+static int eap_ikev2_server_keymat(struct eap_ikev2_data *data)
+{
+ if (eap_ikev2_derive_keymat(
+ data->ikev2.proposal.prf, &data->ikev2.keys,
+ data->ikev2.i_nonce, data->ikev2.i_nonce_len,
+ data->ikev2.r_nonce, data->ikev2.r_nonce_len,
+ data->keymat) < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Failed to derive "
+ "key material");
+ return -1;
+ }
+ data->keymat_ok = 1;
+ return 0;
+}
+
+
+static void eap_ikev2_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_ikev2_data *data = priv;
+ const u8 *start, *pos, *end;
+ size_t len;
+ u8 flags;
+ u32 message_length = 0;
+ struct wpabuf tmpbuf;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_IKEV2, respData,
+ &len);
+ if (pos == NULL)
+ return; /* Should not happen; message already verified */
+
+ start = pos;
+ end = start + len;
+
+ if (len == 0) {
+ /* fragment ack */
+ flags = 0;
+ } else
+ flags = *pos++;
+
+ if (eap_ikev2_process_icv(data, respData, flags, pos, &end) < 0) {
+ eap_ikev2_state(data, FAIL);
+ return;
+ }
+
+ if (flags & IKEV2_FLAGS_LENGTH_INCLUDED) {
+ if (end - pos < 4) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Message underflow");
+ eap_ikev2_state(data, FAIL);
+ return;
+ }
+ message_length = WPA_GET_BE32(pos);
+ pos += 4;
+
+ if (message_length < (u32) (end - pos)) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Invalid Message "
+ "Length (%d; %ld remaining in this msg)",
+ message_length, (long) (end - pos));
+ eap_ikev2_state(data, FAIL);
+ return;
+ }
+ }
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Received packet: Flags 0x%x "
+ "Message Length %u", flags, message_length);
+
+ if (data->state == WAIT_FRAG_ACK) {
+ if (len != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Unexpected payload "
+ "in WAIT_FRAG_ACK state");
+ eap_ikev2_state(data, FAIL);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Fragment acknowledged");
+ eap_ikev2_state(data, MSG);
+ return;
+ }
+
+ if (data->in_buf && eap_ikev2_process_cont(data, pos, end - pos) < 0) {
+ eap_ikev2_state(data, FAIL);
+ return;
+ }
+
+ if (flags & IKEV2_FLAGS_MORE_FRAGMENTS) {
+ if (eap_ikev2_process_fragment(data, flags, message_length,
+ pos, end - pos) < 0)
+ eap_ikev2_state(data, FAIL);
+ else
+ eap_ikev2_state(data, FRAG_ACK);
+ return;
+ } else if (data->state == FRAG_ACK) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: All fragments received");
+ data->state = MSG;
+ }
+
+ if (data->in_buf == NULL) {
+ /* Wrap unfragmented messages as wpabuf without extra copy */
+ wpabuf_set(&tmpbuf, pos, end - pos);
+ data->in_buf = &tmpbuf;
+ }
+
+ if (ikev2_initiator_process(&data->ikev2, data->in_buf) < 0) {
+ if (data->in_buf == &tmpbuf)
+ data->in_buf = NULL;
+ eap_ikev2_state(data, FAIL);
+ return;
+ }
+
+ switch (data->ikev2.state) {
+ case SA_AUTH:
+ /* SA_INIT was sent out, so message have to be
+ * integrity protected from now on. */
+ data->keys_ready = 1;
+ break;
+ case IKEV2_DONE:
+ if (data->state == FAIL)
+ break;
+ wpa_printf(MSG_DEBUG, "EAP-IKEV2: Authentication completed "
+ "successfully");
+ if (eap_ikev2_server_keymat(data))
+ break;
+ eap_ikev2_state(data, DONE);
+ break;
+ default:
+ break;
+ }
+
+ if (data->in_buf != &tmpbuf)
+ wpabuf_free(data->in_buf);
+ data->in_buf = NULL;
+}
+
+
+static Boolean eap_ikev2_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_ikev2_data *data = priv;
+ return data->state == DONE || data->state == FAIL;
+}
+
+
+static Boolean eap_ikev2_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_ikev2_data *data = priv;
+ return data->state == DONE && data->ikev2.state == IKEV2_DONE &&
+ data->keymat_ok;
+}
+
+
+static u8 * eap_ikev2_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_ikev2_data *data = priv;
+ u8 *key;
+
+ if (data->state != DONE || !data->keymat_ok)
+ return NULL;
+
+ key = os_malloc(EAP_MSK_LEN);
+ if (key) {
+ os_memcpy(key, data->keymat, EAP_MSK_LEN);
+ *len = EAP_MSK_LEN;
+ }
+
+ return key;
+}
+
+
+static u8 * eap_ikev2_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_ikev2_data *data = priv;
+ u8 *key;
+
+ if (data->state != DONE || !data->keymat_ok)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key) {
+ os_memcpy(key, data->keymat + EAP_MSK_LEN, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+ }
+
+ return key;
+}
+
+
+int eap_server_ikev2_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_IKEV2,
+ "IKEV2");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_ikev2_init;
+ eap->reset = eap_ikev2_reset;
+ eap->buildReq = eap_ikev2_buildReq;
+ eap->check = eap_ikev2_check;
+ eap->process = eap_ikev2_process;
+ eap->isDone = eap_ikev2_isDone;
+ eap->getKey = eap_ikev2_getKey;
+ eap->isSuccess = eap_ikev2_isSuccess;
+ eap->get_emsk = eap_ikev2_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_md5.c b/src/eap_server/eap_server_md5.c
new file mode 100644
index 0000000..d03ec53
--- /dev/null
+++ b/src/eap_server/eap_server_md5.c
@@ -0,0 +1,177 @@
+/*
+ * hostapd / EAP-MD5 server
+ * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/random.h"
+#include "eap_i.h"
+#include "eap_common/chap.h"
+
+
+#define CHALLENGE_LEN 16
+
+struct eap_md5_data {
+ u8 challenge[CHALLENGE_LEN];
+ enum { CONTINUE, SUCCESS, FAILURE } state;
+};
+
+
+static void * eap_md5_init(struct eap_sm *sm)
+{
+ struct eap_md5_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = CONTINUE;
+
+ return data;
+}
+
+
+static void eap_md5_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_md5_data *data = priv;
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_md5_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_md5_data *data = priv;
+ struct wpabuf *req;
+
+ if (random_get_bytes(data->challenge, CHALLENGE_LEN)) {
+ wpa_printf(MSG_ERROR, "EAP-MD5: Failed to get random data");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MD5, 1 + CHALLENGE_LEN,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-MD5: Failed to allocate memory for "
+ "request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, CHALLENGE_LEN);
+ wpabuf_put_data(req, data->challenge, CHALLENGE_LEN);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-MD5: Challenge", data->challenge,
+ CHALLENGE_LEN);
+
+ data->state = CONTINUE;
+
+ return req;
+}
+
+
+static Boolean eap_md5_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MD5, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-MD5: Invalid frame");
+ return TRUE;
+ }
+ if (*pos != CHAP_MD5_LEN || 1 + CHAP_MD5_LEN > len) {
+ wpa_printf(MSG_INFO, "EAP-MD5: Invalid response "
+ "(response_len=%d payload_len=%lu",
+ *pos, (unsigned long) len);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_md5_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_md5_data *data = priv;
+ const u8 *pos;
+ size_t plen;
+ u8 hash[CHAP_MD5_LEN], id;
+
+ if (sm->user == NULL || sm->user->password == NULL ||
+ sm->user->password_hash) {
+ wpa_printf(MSG_INFO, "EAP-MD5: Plaintext password not "
+ "configured");
+ data->state = FAILURE;
+ return;
+ }
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MD5, respData, &plen);
+ if (pos == NULL || *pos != CHAP_MD5_LEN || plen < 1 + CHAP_MD5_LEN)
+ return; /* Should not happen - frame already validated */
+
+ pos++; /* Skip response len */
+ wpa_hexdump(MSG_MSGDUMP, "EAP-MD5: Response", pos, CHAP_MD5_LEN);
+
+ id = eap_get_id(respData);
+ chap_md5(id, sm->user->password, sm->user->password_len,
+ data->challenge, CHALLENGE_LEN, hash);
+
+ if (os_memcmp(hash, pos, CHAP_MD5_LEN) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-MD5: Done - Success");
+ data->state = SUCCESS;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-MD5: Done - Failure");
+ data->state = FAILURE;
+ }
+}
+
+
+static Boolean eap_md5_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_md5_data *data = priv;
+ return data->state != CONTINUE;
+}
+
+
+static Boolean eap_md5_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_md5_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_md5_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_MD5, "MD5");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_md5_init;
+ eap->reset = eap_md5_reset;
+ eap->buildReq = eap_md5_buildReq;
+ eap->check = eap_md5_check;
+ eap->process = eap_md5_process;
+ eap->isDone = eap_md5_isDone;
+ eap->isSuccess = eap_md5_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_methods.c b/src/eap_server/eap_server_methods.c
new file mode 100644
index 0000000..900a5dd
--- /dev/null
+++ b/src/eap_server/eap_server_methods.c
@@ -0,0 +1,175 @@
+/*
+ * EAP server method registration
+ * Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+#include "eap_methods.h"
+
+
+static struct eap_method *eap_methods;
+
+
+/**
+ * eap_server_get_eap_method - Get EAP method based on type number
+ * @vendor: EAP Vendor-Id (0 = IETF)
+ * @method: EAP type number
+ * Returns: Pointer to EAP method or %NULL if not found
+ */
+const struct eap_method * eap_server_get_eap_method(int vendor, EapType method)
+{
+ struct eap_method *m;
+ for (m = eap_methods; m; m = m->next) {
+ if (m->vendor == vendor && m->method == method)
+ return m;
+ }
+ return NULL;
+}
+
+
+/**
+ * eap_server_get_type - Get EAP type for the given EAP method name
+ * @name: EAP method name, e.g., TLS
+ * @vendor: Buffer for returning EAP Vendor-Id
+ * Returns: EAP method type or %EAP_TYPE_NONE if not found
+ *
+ * This function maps EAP type names into EAP type numbers based on the list of
+ * EAP methods included in the build.
+ */
+EapType eap_server_get_type(const char *name, int *vendor)
+{
+ struct eap_method *m;
+ for (m = eap_methods; m; m = m->next) {
+ if (os_strcmp(m->name, name) == 0) {
+ *vendor = m->vendor;
+ return m->method;
+ }
+ }
+ *vendor = EAP_VENDOR_IETF;
+ return EAP_TYPE_NONE;
+}
+
+
+/**
+ * eap_server_method_alloc - Allocate EAP server method structure
+ * @version: Version of the EAP server method interface (set to
+ * EAP_SERVER_METHOD_INTERFACE_VERSION)
+ * @vendor: EAP Vendor-ID (EAP_VENDOR_*) (0 = IETF)
+ * @method: EAP type number (EAP_TYPE_*)
+ * @name: Name of the method (e.g., "TLS")
+ * Returns: Allocated EAP method structure or %NULL on failure
+ *
+ * The returned structure should be freed with eap_server_method_free() when it
+ * is not needed anymore.
+ */
+struct eap_method * eap_server_method_alloc(int version, int vendor,
+ EapType method, const char *name)
+{
+ struct eap_method *eap;
+ eap = os_zalloc(sizeof(*eap));
+ if (eap == NULL)
+ return NULL;
+ eap->version = version;
+ eap->vendor = vendor;
+ eap->method = method;
+ eap->name = name;
+ return eap;
+}
+
+
+/**
+ * eap_server_method_free - Free EAP server method structure
+ * @method: Method structure allocated with eap_server_method_alloc()
+ */
+void eap_server_method_free(struct eap_method *method)
+{
+ os_free(method);
+}
+
+
+/**
+ * eap_server_method_register - Register an EAP server method
+ * @method: EAP method to register
+ * Returns: 0 on success, -1 on invalid method, or -2 if a matching EAP method
+ * has already been registered
+ *
+ * Each EAP server method needs to call this function to register itself as a
+ * supported EAP method.
+ */
+int eap_server_method_register(struct eap_method *method)
+{
+ struct eap_method *m, *last = NULL;
+
+ if (method == NULL || method->name == NULL ||
+ method->version != EAP_SERVER_METHOD_INTERFACE_VERSION)
+ return -1;
+
+ for (m = eap_methods; m; m = m->next) {
+ if ((m->vendor == method->vendor &&
+ m->method == method->method) ||
+ os_strcmp(m->name, method->name) == 0)
+ return -2;
+ last = m;
+ }
+
+ if (last)
+ last->next = method;
+ else
+ eap_methods = method;
+
+ return 0;
+}
+
+
+/**
+ * eap_server_unregister_methods - Unregister EAP server methods
+ *
+ * This function is called at program termination to unregister all EAP server
+ * methods.
+ */
+void eap_server_unregister_methods(void)
+{
+ struct eap_method *m;
+
+ while (eap_methods) {
+ m = eap_methods;
+ eap_methods = eap_methods->next;
+
+ if (m->free)
+ m->free(m);
+ else
+ eap_server_method_free(m);
+ }
+}
+
+
+/**
+ * eap_server_get_name - Get EAP method name for the given EAP type
+ * @vendor: EAP Vendor-Id (0 = IETF)
+ * @type: EAP method type
+ * Returns: EAP method name, e.g., TLS, or %NULL if not found
+ *
+ * This function maps EAP type numbers into EAP type names based on the list of
+ * EAP methods included in the build.
+ */
+const char * eap_server_get_name(int vendor, EapType type)
+{
+ struct eap_method *m;
+ for (m = eap_methods; m; m = m->next) {
+ if (m->vendor == vendor && m->method == type)
+ return m->name;
+ }
+ return NULL;
+}
diff --git a/src/eap_server/eap_server_mschapv2.c b/src/eap_server/eap_server_mschapv2.c
new file mode 100644
index 0000000..64120a4
--- /dev/null
+++ b/src/eap_server/eap_server_mschapv2.c
@@ -0,0 +1,575 @@
+/*
+ * hostapd / EAP-MSCHAPv2 (draft-kamath-pppext-eap-mschapv2-00.txt) server
+ * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/ms_funcs.h"
+#include "crypto/random.h"
+#include "eap_i.h"
+
+
+struct eap_mschapv2_hdr {
+ u8 op_code; /* MSCHAPV2_OP_* */
+ u8 mschapv2_id; /* must be changed for challenges, but not for
+ * success/failure */
+ u8 ms_length[2]; /* Note: misaligned; length - 5 */
+ /* followed by data */
+} STRUCT_PACKED;
+
+#define MSCHAPV2_OP_CHALLENGE 1
+#define MSCHAPV2_OP_RESPONSE 2
+#define MSCHAPV2_OP_SUCCESS 3
+#define MSCHAPV2_OP_FAILURE 4
+#define MSCHAPV2_OP_CHANGE_PASSWORD 7
+
+#define MSCHAPV2_RESP_LEN 49
+
+#define ERROR_RESTRICTED_LOGON_HOURS 646
+#define ERROR_ACCT_DISABLED 647
+#define ERROR_PASSWD_EXPIRED 648
+#define ERROR_NO_DIALIN_PERMISSION 649
+#define ERROR_AUTHENTICATION_FAILURE 691
+#define ERROR_CHANGING_PASSWORD 709
+
+#define PASSWD_CHANGE_CHAL_LEN 16
+#define MSCHAPV2_KEY_LEN 16
+
+
+#define CHALLENGE_LEN 16
+
+struct eap_mschapv2_data {
+ u8 auth_challenge[CHALLENGE_LEN];
+ int auth_challenge_from_tls;
+ u8 *peer_challenge;
+ u8 auth_response[20];
+ enum { CHALLENGE, SUCCESS_REQ, FAILURE_REQ, SUCCESS, FAILURE } state;
+ u8 resp_mschapv2_id;
+ u8 master_key[16];
+ int master_key_valid;
+};
+
+
+static void * eap_mschapv2_init(struct eap_sm *sm)
+{
+ struct eap_mschapv2_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = CHALLENGE;
+
+ if (sm->auth_challenge) {
+ os_memcpy(data->auth_challenge, sm->auth_challenge,
+ CHALLENGE_LEN);
+ data->auth_challenge_from_tls = 1;
+ }
+
+ if (sm->peer_challenge) {
+ data->peer_challenge = os_malloc(CHALLENGE_LEN);
+ if (data->peer_challenge == NULL) {
+ os_free(data);
+ return NULL;
+ }
+ os_memcpy(data->peer_challenge, sm->peer_challenge,
+ CHALLENGE_LEN);
+ }
+
+ return data;
+}
+
+
+static void eap_mschapv2_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_mschapv2_data *data = priv;
+ if (data == NULL)
+ return;
+
+ os_free(data->peer_challenge);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_mschapv2_build_challenge(
+ struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_mschapv2_hdr *ms;
+ char *name = "hostapd"; /* TODO: make this configurable */
+ size_t ms_len;
+
+ if (!data->auth_challenge_from_tls &&
+ random_get_bytes(data->auth_challenge, CHALLENGE_LEN)) {
+ wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to get random "
+ "data");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ ms_len = sizeof(*ms) + 1 + CHALLENGE_LEN + os_strlen(name);
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to allocate memory"
+ " for request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ ms = wpabuf_put(req, sizeof(*ms));
+ ms->op_code = MSCHAPV2_OP_CHALLENGE;
+ ms->mschapv2_id = id;
+ WPA_PUT_BE16(ms->ms_length, ms_len);
+
+ wpabuf_put_u8(req, CHALLENGE_LEN);
+ if (!data->auth_challenge_from_tls)
+ wpabuf_put_data(req, data->auth_challenge, CHALLENGE_LEN);
+ else
+ wpabuf_put(req, CHALLENGE_LEN);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: Challenge",
+ data->auth_challenge, CHALLENGE_LEN);
+ wpabuf_put_data(req, name, os_strlen(name));
+
+ return req;
+}
+
+
+static struct wpabuf * eap_mschapv2_build_success_req(
+ struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_mschapv2_hdr *ms;
+ u8 *msg;
+ char *message = "OK";
+ size_t ms_len;
+
+ ms_len = sizeof(*ms) + 2 + 2 * sizeof(data->auth_response) + 1 + 2 +
+ os_strlen(message);
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to allocate memory"
+ " for request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ ms = wpabuf_put(req, sizeof(*ms));
+ ms->op_code = MSCHAPV2_OP_SUCCESS;
+ ms->mschapv2_id = data->resp_mschapv2_id;
+ WPA_PUT_BE16(ms->ms_length, ms_len);
+ msg = (u8 *) (ms + 1);
+
+ wpabuf_put_u8(req, 'S');
+ wpabuf_put_u8(req, '=');
+ wpa_snprintf_hex_uppercase(
+ wpabuf_put(req, sizeof(data->auth_response) * 2),
+ sizeof(data->auth_response) * 2 + 1,
+ data->auth_response, sizeof(data->auth_response));
+ wpabuf_put_u8(req, ' ');
+ wpabuf_put_u8(req, 'M');
+ wpabuf_put_u8(req, '=');
+ wpabuf_put_data(req, message, os_strlen(message));
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: Success Request Message",
+ msg, ms_len - sizeof(*ms));
+
+ return req;
+}
+
+
+static struct wpabuf * eap_mschapv2_build_failure_req(
+ struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_mschapv2_hdr *ms;
+ char *message = "E=691 R=0 C=00000000000000000000000000000000 V=3 "
+ "M=FAILED";
+ size_t ms_len;
+
+ ms_len = sizeof(*ms) + os_strlen(message);
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to allocate memory"
+ " for request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ ms = wpabuf_put(req, sizeof(*ms));
+ ms->op_code = MSCHAPV2_OP_FAILURE;
+ ms->mschapv2_id = data->resp_mschapv2_id;
+ WPA_PUT_BE16(ms->ms_length, ms_len);
+
+ wpabuf_put_data(req, message, os_strlen(message));
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: Failure Request Message",
+ (u8 *) message, os_strlen(message));
+
+ return req;
+}
+
+
+static struct wpabuf * eap_mschapv2_buildReq(struct eap_sm *sm, void *priv,
+ u8 id)
+{
+ struct eap_mschapv2_data *data = priv;
+
+ switch (data->state) {
+ case CHALLENGE:
+ return eap_mschapv2_build_challenge(sm, data, id);
+ case SUCCESS_REQ:
+ return eap_mschapv2_build_success_req(sm, data, id);
+ case FAILURE_REQ:
+ return eap_mschapv2_build_failure_req(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Unknown state %d in "
+ "buildReq", data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_mschapv2_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_mschapv2_data *data = priv;
+ struct eap_mschapv2_hdr *resp;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
+ &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Invalid frame");
+ return TRUE;
+ }
+
+ resp = (struct eap_mschapv2_hdr *) pos;
+ if (data->state == CHALLENGE &&
+ resp->op_code != MSCHAPV2_OP_RESPONSE) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Expected Response - "
+ "ignore op %d", resp->op_code);
+ return TRUE;
+ }
+
+ if (data->state == SUCCESS_REQ &&
+ resp->op_code != MSCHAPV2_OP_SUCCESS &&
+ resp->op_code != MSCHAPV2_OP_FAILURE) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Expected Success or "
+ "Failure - ignore op %d", resp->op_code);
+ return TRUE;
+ }
+
+ if (data->state == FAILURE_REQ &&
+ resp->op_code != MSCHAPV2_OP_FAILURE) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Expected Failure "
+ "- ignore op %d", resp->op_code);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_mschapv2_process_response(struct eap_sm *sm,
+ struct eap_mschapv2_data *data,
+ struct wpabuf *respData)
+{
+ struct eap_mschapv2_hdr *resp;
+ const u8 *pos, *end, *peer_challenge, *nt_response, *name;
+ u8 flags;
+ size_t len, name_len, i;
+ u8 expected[24];
+ const u8 *username, *user;
+ size_t username_len, user_len;
+ int res;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
+ &len);
+ if (pos == NULL || len < 1)
+ return; /* Should not happen - frame already validated */
+
+ end = pos + len;
+ resp = (struct eap_mschapv2_hdr *) pos;
+ pos = (u8 *) (resp + 1);
+
+ if (len < sizeof(*resp) + 1 + 49 ||
+ resp->op_code != MSCHAPV2_OP_RESPONSE ||
+ pos[0] != 49) {
+ wpa_hexdump_buf(MSG_DEBUG, "EAP-MSCHAPV2: Invalid response",
+ respData);
+ data->state = FAILURE;
+ return;
+ }
+ data->resp_mschapv2_id = resp->mschapv2_id;
+ pos++;
+ peer_challenge = pos;
+ pos += 16 + 8;
+ nt_response = pos;
+ pos += 24;
+ flags = *pos++;
+ name = pos;
+ name_len = end - name;
+
+ if (data->peer_challenge) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Using pre-configured "
+ "Peer-Challenge");
+ peer_challenge = data->peer_challenge;
+ }
+ wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: Peer-Challenge",
+ peer_challenge, 16);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: NT-Response", nt_response, 24);
+ wpa_printf(MSG_MSGDUMP, "EAP-MSCHAPV2: Flags 0x%x", flags);
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: Name", name, name_len);
+
+ /* MSCHAPv2 does not include optional domain name in the
+ * challenge-response calculation, so remove domain prefix
+ * (if present). */
+ username = sm->identity;
+ username_len = sm->identity_len;
+ for (i = 0; i < username_len; i++) {
+ if (username[i] == '\\') {
+ username_len -= i + 1;
+ username += i + 1;
+ break;
+ }
+ }
+
+ user = name;
+ user_len = name_len;
+ for (i = 0; i < user_len; i++) {
+ if (user[i] == '\\') {
+ user_len -= i + 1;
+ user += i + 1;
+ break;
+ }
+ }
+
+ if (username_len != user_len ||
+ os_memcmp(username, user, username_len) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Mismatch in user names");
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Expected user "
+ "name", username, username_len);
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Received user "
+ "name", user, user_len);
+ data->state = FAILURE;
+ return;
+ }
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: User name",
+ username, username_len);
+
+ if (sm->user->password_hash) {
+ res = generate_nt_response_pwhash(data->auth_challenge,
+ peer_challenge,
+ username, username_len,
+ sm->user->password,
+ expected);
+ } else {
+ res = generate_nt_response(data->auth_challenge,
+ peer_challenge,
+ username, username_len,
+ sm->user->password,
+ sm->user->password_len,
+ expected);
+ }
+ if (res) {
+ data->state = FAILURE;
+ return;
+ }
+
+ if (os_memcmp(nt_response, expected, 24) == 0) {
+ const u8 *pw_hash;
+ u8 pw_hash_buf[16], pw_hash_hash[16];
+
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Correct NT-Response");
+ data->state = SUCCESS_REQ;
+
+ /* Authenticator response is not really needed yet, but
+ * calculate it here so that peer_challenge and username need
+ * not be saved. */
+ if (sm->user->password_hash) {
+ pw_hash = sm->user->password;
+ } else {
+ nt_password_hash(sm->user->password,
+ sm->user->password_len,
+ pw_hash_buf);
+ pw_hash = pw_hash_buf;
+ }
+ generate_authenticator_response_pwhash(
+ pw_hash, peer_challenge, data->auth_challenge,
+ username, username_len, nt_response,
+ data->auth_response);
+
+ hash_nt_password_hash(pw_hash, pw_hash_hash);
+ get_master_key(pw_hash_hash, nt_response, data->master_key);
+ data->master_key_valid = 1;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-MSCHAPV2: Derived Master Key",
+ data->master_key, MSCHAPV2_KEY_LEN);
+ } else {
+ wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: Expected NT-Response",
+ expected, 24);
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Invalid NT-Response");
+ data->state = FAILURE_REQ;
+ }
+}
+
+
+static void eap_mschapv2_process_success_resp(struct eap_sm *sm,
+ struct eap_mschapv2_data *data,
+ struct wpabuf *respData)
+{
+ struct eap_mschapv2_hdr *resp;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
+ &len);
+ if (pos == NULL || len < 1)
+ return; /* Should not happen - frame already validated */
+
+ resp = (struct eap_mschapv2_hdr *) pos;
+
+ if (resp->op_code == MSCHAPV2_OP_SUCCESS) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received Success Response"
+ " - authentication completed successfully");
+ data->state = SUCCESS;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Did not receive Success "
+ "Response - peer rejected authentication");
+ data->state = FAILURE;
+ }
+}
+
+
+static void eap_mschapv2_process_failure_resp(struct eap_sm *sm,
+ struct eap_mschapv2_data *data,
+ struct wpabuf *respData)
+{
+ struct eap_mschapv2_hdr *resp;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
+ &len);
+ if (pos == NULL || len < 1)
+ return; /* Should not happen - frame already validated */
+
+ resp = (struct eap_mschapv2_hdr *) pos;
+
+ if (resp->op_code == MSCHAPV2_OP_FAILURE) {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received Failure Response"
+ " - authentication failed");
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Did not receive Failure "
+ "Response - authentication failed");
+ }
+
+ data->state = FAILURE;
+}
+
+
+static void eap_mschapv2_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_mschapv2_data *data = priv;
+
+ if (sm->user == NULL || sm->user->password == NULL) {
+ wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Password not configured");
+ data->state = FAILURE;
+ return;
+ }
+
+ switch (data->state) {
+ case CHALLENGE:
+ eap_mschapv2_process_response(sm, data, respData);
+ break;
+ case SUCCESS_REQ:
+ eap_mschapv2_process_success_resp(sm, data, respData);
+ break;
+ case FAILURE_REQ:
+ eap_mschapv2_process_failure_resp(sm, data, respData);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Unknown state %d in "
+ "process", data->state);
+ break;
+ }
+}
+
+
+static Boolean eap_mschapv2_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_mschapv2_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_mschapv2_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_mschapv2_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS || !data->master_key_valid)
+ return NULL;
+
+ *len = 2 * MSCHAPV2_KEY_LEN;
+ key = os_malloc(*len);
+ if (key == NULL)
+ return NULL;
+ /* MSK = server MS-MPPE-Recv-Key | MS-MPPE-Send-Key */
+ get_asymetric_start_key(data->master_key, key, MSCHAPV2_KEY_LEN, 0, 1);
+ get_asymetric_start_key(data->master_key, key + MSCHAPV2_KEY_LEN,
+ MSCHAPV2_KEY_LEN, 1, 1);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-MSCHAPV2: Derived key", key, *len);
+
+ return key;
+}
+
+
+static Boolean eap_mschapv2_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_mschapv2_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_mschapv2_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2,
+ "MSCHAPV2");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_mschapv2_init;
+ eap->reset = eap_mschapv2_reset;
+ eap->buildReq = eap_mschapv2_buildReq;
+ eap->check = eap_mschapv2_check;
+ eap->process = eap_mschapv2_process;
+ eap->isDone = eap_mschapv2_isDone;
+ eap->getKey = eap_mschapv2_getKey;
+ eap->isSuccess = eap_mschapv2_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_pax.c b/src/eap_server/eap_server_pax.c
new file mode 100644
index 0000000..4d64269
--- /dev/null
+++ b/src/eap_server/eap_server_pax.c
@@ -0,0 +1,570 @@
+/*
+ * hostapd / EAP-PAX (RFC 4746) server
+ * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/random.h"
+#include "eap_server/eap_i.h"
+#include "eap_common/eap_pax_common.h"
+
+/*
+ * Note: only PAX_STD subprotocol is currently supported
+ *
+ * TODO: Add support with PAX_SEC with the mandatory to implement ciphersuite
+ * (HMAC_SHA1_128, IANA DH Group 14 (2048 bits), RSA-PKCS1-V1_5) and
+ * recommended ciphersuite (HMAC_SHA256_128, IANA DH Group 15 (3072 bits),
+ * RSAES-OAEP).
+ */
+
+struct eap_pax_data {
+ enum { PAX_STD_1, PAX_STD_3, SUCCESS, FAILURE } state;
+ u8 mac_id;
+ union {
+ u8 e[2 * EAP_PAX_RAND_LEN];
+ struct {
+ u8 x[EAP_PAX_RAND_LEN]; /* server rand */
+ u8 y[EAP_PAX_RAND_LEN]; /* client rand */
+ } r;
+ } rand;
+ u8 ak[EAP_PAX_AK_LEN];
+ u8 mk[EAP_PAX_MK_LEN];
+ u8 ck[EAP_PAX_CK_LEN];
+ u8 ick[EAP_PAX_ICK_LEN];
+ int keys_set;
+ char *cid;
+ size_t cid_len;
+};
+
+
+static void * eap_pax_init(struct eap_sm *sm)
+{
+ struct eap_pax_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = PAX_STD_1;
+ /*
+ * TODO: make this configurable once EAP_PAX_HMAC_SHA256_128 is
+ * supported
+ */
+ data->mac_id = EAP_PAX_MAC_HMAC_SHA1_128;
+
+ return data;
+}
+
+
+static void eap_pax_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_pax_data *data = priv;
+ os_free(data->cid);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_pax_build_std_1(struct eap_sm *sm,
+ struct eap_pax_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_pax_hdr *pax;
+ u8 *pos;
+
+ wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-1 (sending)");
+
+ if (random_get_bytes(data->rand.r.x, EAP_PAX_RAND_LEN)) {
+ wpa_printf(MSG_ERROR, "EAP-PAX: Failed to get random data");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PAX,
+ sizeof(*pax) + 2 + EAP_PAX_RAND_LEN +
+ EAP_PAX_ICV_LEN, EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-PAX: Failed to allocate memory "
+ "request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ pax = wpabuf_put(req, sizeof(*pax));
+ pax->op_code = EAP_PAX_OP_STD_1;
+ pax->flags = 0;
+ pax->mac_id = data->mac_id;
+ pax->dh_group_id = EAP_PAX_DH_GROUP_NONE;
+ pax->public_key_id = EAP_PAX_PUBLIC_KEY_NONE;
+
+ wpabuf_put_be16(req, EAP_PAX_RAND_LEN);
+ wpabuf_put_data(req, data->rand.r.x, EAP_PAX_RAND_LEN);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: A = X (server rand)",
+ data->rand.r.x, EAP_PAX_RAND_LEN);
+
+ pos = wpabuf_put(req, EAP_PAX_MAC_LEN);
+ eap_pax_mac(data->mac_id, (u8 *) "", 0,
+ wpabuf_mhead(req), wpabuf_len(req) - EAP_PAX_ICV_LEN,
+ NULL, 0, NULL, 0, pos);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", pos, EAP_PAX_ICV_LEN);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_pax_build_std_3(struct eap_sm *sm,
+ struct eap_pax_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_pax_hdr *pax;
+ u8 *pos;
+
+ wpa_printf(MSG_DEBUG, "EAP-PAX: PAX_STD-3 (sending)");
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PAX,
+ sizeof(*pax) + 2 + EAP_PAX_MAC_LEN +
+ EAP_PAX_ICV_LEN, EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-PAX: Failed to allocate memory "
+ "request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ pax = wpabuf_put(req, sizeof(*pax));
+ pax->op_code = EAP_PAX_OP_STD_3;
+ pax->flags = 0;
+ pax->mac_id = data->mac_id;
+ pax->dh_group_id = EAP_PAX_DH_GROUP_NONE;
+ pax->public_key_id = EAP_PAX_PUBLIC_KEY_NONE;
+
+ wpabuf_put_be16(req, EAP_PAX_MAC_LEN);
+ pos = wpabuf_put(req, EAP_PAX_MAC_LEN);
+ eap_pax_mac(data->mac_id, data->ck, EAP_PAX_CK_LEN,
+ data->rand.r.y, EAP_PAX_RAND_LEN,
+ (u8 *) data->cid, data->cid_len, NULL, 0, pos);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: MAC_CK(B, CID)",
+ pos, EAP_PAX_MAC_LEN);
+ pos += EAP_PAX_MAC_LEN;
+
+ /* Optional ADE could be added here, if needed */
+
+ pos = wpabuf_put(req, EAP_PAX_MAC_LEN);
+ eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
+ wpabuf_mhead(req), wpabuf_len(req) - EAP_PAX_ICV_LEN,
+ NULL, 0, NULL, 0, pos);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", pos, EAP_PAX_ICV_LEN);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_pax_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_pax_data *data = priv;
+
+ switch (data->state) {
+ case PAX_STD_1:
+ return eap_pax_build_std_1(sm, data, id);
+ case PAX_STD_3:
+ return eap_pax_build_std_3(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Unknown state %d in buildReq",
+ data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_pax_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_pax_data *data = priv;
+ struct eap_pax_hdr *resp;
+ const u8 *pos;
+ size_t len, mlen;
+ u8 icvbuf[EAP_PAX_ICV_LEN], *icv;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, respData, &len);
+ if (pos == NULL || len < sizeof(*resp)) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Invalid frame");
+ return TRUE;
+ }
+
+ mlen = sizeof(struct eap_hdr) + 1 + len;
+ resp = (struct eap_pax_hdr *) pos;
+
+ wpa_printf(MSG_DEBUG, "EAP-PAX: received frame: op_code 0x%x "
+ "flags 0x%x mac_id 0x%x dh_group_id 0x%x "
+ "public_key_id 0x%x",
+ resp->op_code, resp->flags, resp->mac_id, resp->dh_group_id,
+ resp->public_key_id);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: received payload",
+ (u8 *) (resp + 1), len - sizeof(*resp) - EAP_PAX_ICV_LEN);
+
+ if (data->state == PAX_STD_1 &&
+ resp->op_code != EAP_PAX_OP_STD_2) {
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Expected PAX_STD-2 - "
+ "ignore op %d", resp->op_code);
+ return TRUE;
+ }
+
+ if (data->state == PAX_STD_3 &&
+ resp->op_code != EAP_PAX_OP_ACK) {
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Expected PAX-ACK - "
+ "ignore op %d", resp->op_code);
+ return TRUE;
+ }
+
+ if (resp->op_code != EAP_PAX_OP_STD_2 &&
+ resp->op_code != EAP_PAX_OP_ACK) {
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Unknown op_code 0x%x",
+ resp->op_code);
+ }
+
+ if (data->mac_id != resp->mac_id) {
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Expected MAC ID 0x%x, "
+ "received 0x%x", data->mac_id, resp->mac_id);
+ return TRUE;
+ }
+
+ if (resp->dh_group_id != EAP_PAX_DH_GROUP_NONE) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Expected DH Group ID 0x%x, "
+ "received 0x%x", EAP_PAX_DH_GROUP_NONE,
+ resp->dh_group_id);
+ return TRUE;
+ }
+
+ if (resp->public_key_id != EAP_PAX_PUBLIC_KEY_NONE) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Expected Public Key ID 0x%x, "
+ "received 0x%x", EAP_PAX_PUBLIC_KEY_NONE,
+ resp->public_key_id);
+ return TRUE;
+ }
+
+ if (resp->flags & EAP_PAX_FLAGS_MF) {
+ /* TODO: add support for reassembling fragments */
+ wpa_printf(MSG_INFO, "EAP-PAX: fragmentation not supported");
+ return TRUE;
+ }
+
+ if (resp->flags & EAP_PAX_FLAGS_CE) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Unexpected CE flag");
+ return TRUE;
+ }
+
+ if (data->keys_set) {
+ if (len - sizeof(*resp) < EAP_PAX_ICV_LEN) {
+ wpa_printf(MSG_INFO, "EAP-PAX: No ICV in the packet");
+ return TRUE;
+ }
+ icv = wpabuf_mhead_u8(respData) + mlen - EAP_PAX_ICV_LEN;
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", icv, EAP_PAX_ICV_LEN);
+ eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
+ wpabuf_mhead(respData),
+ wpabuf_len(respData) - EAP_PAX_ICV_LEN,
+ NULL, 0, NULL, 0, icvbuf);
+ if (os_memcmp(icvbuf, icv, EAP_PAX_ICV_LEN) != 0) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Invalid ICV");
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Expected ICV",
+ icvbuf, EAP_PAX_ICV_LEN);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+
+static void eap_pax_process_std_2(struct eap_sm *sm,
+ struct eap_pax_data *data,
+ struct wpabuf *respData)
+{
+ struct eap_pax_hdr *resp;
+ u8 mac[EAP_PAX_MAC_LEN], icvbuf[EAP_PAX_ICV_LEN];
+ const u8 *pos;
+ size_t len, left;
+ int i;
+
+ if (data->state != PAX_STD_1)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Received PAX_STD-2");
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, respData, &len);
+ if (pos == NULL || len < sizeof(*resp) + EAP_PAX_ICV_LEN)
+ return;
+
+ resp = (struct eap_pax_hdr *) pos;
+ pos = (u8 *) (resp + 1);
+ left = len - sizeof(*resp);
+
+ if (left < 2 + EAP_PAX_RAND_LEN ||
+ WPA_GET_BE16(pos) != EAP_PAX_RAND_LEN) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Too short PAX_STD-2 (B)");
+ return;
+ }
+ pos += 2;
+ left -= 2;
+ os_memcpy(data->rand.r.y, pos, EAP_PAX_RAND_LEN);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Y (client rand)",
+ data->rand.r.y, EAP_PAX_RAND_LEN);
+ pos += EAP_PAX_RAND_LEN;
+ left -= EAP_PAX_RAND_LEN;
+
+ if (left < 2 || (size_t) 2 + WPA_GET_BE16(pos) > left) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Too short PAX_STD-2 (CID)");
+ return;
+ }
+ data->cid_len = WPA_GET_BE16(pos);
+ os_free(data->cid);
+ data->cid = os_malloc(data->cid_len);
+ if (data->cid == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Failed to allocate memory for "
+ "CID");
+ return;
+ }
+ os_memcpy(data->cid, pos + 2, data->cid_len);
+ pos += 2 + data->cid_len;
+ left -= 2 + data->cid_len;
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-PAX: CID",
+ (u8 *) data->cid, data->cid_len);
+
+ if (left < 2 + EAP_PAX_MAC_LEN ||
+ WPA_GET_BE16(pos) != EAP_PAX_MAC_LEN) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Too short PAX_STD-2 (MAC_CK)");
+ return;
+ }
+ pos += 2;
+ left -= 2;
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: MAC_CK(A, B, CID)",
+ pos, EAP_PAX_MAC_LEN);
+
+ if (eap_user_get(sm, (u8 *) data->cid, data->cid_len, 0) < 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-PAX: unknown CID",
+ (u8 *) data->cid, data->cid_len);
+ data->state = FAILURE;
+ return;
+ }
+
+ for (i = 0;
+ i < EAP_MAX_METHODS &&
+ (sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[i].method != EAP_TYPE_NONE);
+ i++) {
+ if (sm->user->methods[i].vendor == EAP_VENDOR_IETF &&
+ sm->user->methods[i].method == EAP_TYPE_PAX)
+ break;
+ }
+
+ if (i >= EAP_MAX_METHODS ||
+ sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[i].method != EAP_TYPE_PAX) {
+ wpa_hexdump_ascii(MSG_DEBUG,
+ "EAP-PAX: EAP-PAX not enabled for CID",
+ (u8 *) data->cid, data->cid_len);
+ data->state = FAILURE;
+ return;
+ }
+
+ if (sm->user->password == NULL ||
+ sm->user->password_len != EAP_PAX_AK_LEN) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-PAX: invalid password in "
+ "user database for CID",
+ (u8 *) data->cid, data->cid_len);
+ data->state = FAILURE;
+ return;
+ }
+ os_memcpy(data->ak, sm->user->password, EAP_PAX_AK_LEN);
+
+ if (eap_pax_initial_key_derivation(data->mac_id, data->ak,
+ data->rand.e, data->mk, data->ck,
+ data->ick) < 0) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Failed to complete initial "
+ "key derivation");
+ data->state = FAILURE;
+ return;
+ }
+ data->keys_set = 1;
+
+ eap_pax_mac(data->mac_id, data->ck, EAP_PAX_CK_LEN,
+ data->rand.r.x, EAP_PAX_RAND_LEN,
+ data->rand.r.y, EAP_PAX_RAND_LEN,
+ (u8 *) data->cid, data->cid_len, mac);
+ if (os_memcmp(mac, pos, EAP_PAX_MAC_LEN) != 0) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Invalid MAC_CK(A, B, CID) in "
+ "PAX_STD-2");
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Expected MAC_CK(A, B, CID)",
+ mac, EAP_PAX_MAC_LEN);
+ data->state = FAILURE;
+ return;
+ }
+
+ pos += EAP_PAX_MAC_LEN;
+ left -= EAP_PAX_MAC_LEN;
+
+ if (left < EAP_PAX_ICV_LEN) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Too short ICV (%lu) in "
+ "PAX_STD-2", (unsigned long) left);
+ return;
+ }
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ICV", pos, EAP_PAX_ICV_LEN);
+ eap_pax_mac(data->mac_id, data->ick, EAP_PAX_ICK_LEN,
+ wpabuf_head(respData),
+ wpabuf_len(respData) - EAP_PAX_ICV_LEN, NULL, 0, NULL, 0,
+ icvbuf);
+ if (os_memcmp(icvbuf, pos, EAP_PAX_ICV_LEN) != 0) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Invalid ICV in PAX_STD-2");
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: Expected ICV",
+ icvbuf, EAP_PAX_ICV_LEN);
+ return;
+ }
+ pos += EAP_PAX_ICV_LEN;
+ left -= EAP_PAX_ICV_LEN;
+
+ if (left > 0) {
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PAX: ignored extra payload",
+ pos, left);
+ }
+
+ data->state = PAX_STD_3;
+}
+
+
+static void eap_pax_process_ack(struct eap_sm *sm,
+ struct eap_pax_data *data,
+ struct wpabuf *respData)
+{
+ if (data->state != PAX_STD_3)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-PAX: Received PAX-ACK - authentication "
+ "completed successfully");
+ data->state = SUCCESS;
+}
+
+
+static void eap_pax_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_pax_data *data = priv;
+ struct eap_pax_hdr *resp;
+ const u8 *pos;
+ size_t len;
+
+ if (sm->user == NULL || sm->user->password == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PAX: Plaintext password not "
+ "configured");
+ data->state = FAILURE;
+ return;
+ }
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PAX, respData, &len);
+ if (pos == NULL || len < sizeof(*resp))
+ return;
+
+ resp = (struct eap_pax_hdr *) pos;
+
+ switch (resp->op_code) {
+ case EAP_PAX_OP_STD_2:
+ eap_pax_process_std_2(sm, data, respData);
+ break;
+ case EAP_PAX_OP_ACK:
+ eap_pax_process_ack(sm, data, respData);
+ break;
+ }
+}
+
+
+static Boolean eap_pax_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_pax_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_pax_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_pax_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_MSK_LEN);
+ if (key == NULL)
+ return NULL;
+
+ *len = EAP_MSK_LEN;
+ eap_pax_kdf(data->mac_id, data->mk, EAP_PAX_MK_LEN,
+ "Master Session Key", data->rand.e, 2 * EAP_PAX_RAND_LEN,
+ EAP_MSK_LEN, key);
+
+ return key;
+}
+
+
+static u8 * eap_pax_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_pax_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+
+ *len = EAP_EMSK_LEN;
+ eap_pax_kdf(data->mac_id, data->mk, EAP_PAX_MK_LEN,
+ "Extended Master Session Key",
+ data->rand.e, 2 * EAP_PAX_RAND_LEN,
+ EAP_EMSK_LEN, key);
+
+ return key;
+}
+
+
+static Boolean eap_pax_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_pax_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_pax_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_PAX, "PAX");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_pax_init;
+ eap->reset = eap_pax_reset;
+ eap->buildReq = eap_pax_buildReq;
+ eap->check = eap_pax_check;
+ eap->process = eap_pax_process;
+ eap->isDone = eap_pax_isDone;
+ eap->getKey = eap_pax_getKey;
+ eap->isSuccess = eap_pax_isSuccess;
+ eap->get_emsk = eap_pax_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_peap.c b/src/eap_server/eap_server_peap.c
new file mode 100644
index 0000000..8a7d626
--- /dev/null
+++ b/src/eap_server/eap_server_peap.c
@@ -0,0 +1,1387 @@
+/*
+ * hostapd / EAP-PEAP (draft-josefsson-pppext-eap-tls-eap-10.txt)
+ * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/sha1.h"
+#include "crypto/tls.h"
+#include "crypto/random.h"
+#include "eap_i.h"
+#include "eap_tls_common.h"
+#include "eap_common/eap_tlv_common.h"
+#include "eap_common/eap_peap_common.h"
+#include "tncs.h"
+
+
+/* Maximum supported PEAP version
+ * 0 = Microsoft's PEAP version 0; draft-kamath-pppext-peapv0-00.txt
+ * 1 = draft-josefsson-ppext-eap-tls-eap-05.txt
+ * 2 = draft-josefsson-ppext-eap-tls-eap-10.txt
+ */
+#define EAP_PEAP_VERSION 1
+
+
+static void eap_peap_reset(struct eap_sm *sm, void *priv);
+
+
+struct eap_peap_data {
+ struct eap_ssl_data ssl;
+ enum {
+ START, PHASE1, PHASE1_ID2, PHASE2_START, PHASE2_ID,
+ PHASE2_METHOD, PHASE2_SOH,
+ PHASE2_TLV, SUCCESS_REQ, FAILURE_REQ, SUCCESS, FAILURE
+ } state;
+
+ int peap_version;
+ int recv_version;
+ const struct eap_method *phase2_method;
+ void *phase2_priv;
+ int force_version;
+ struct wpabuf *pending_phase2_resp;
+ enum { TLV_REQ_NONE, TLV_REQ_SUCCESS, TLV_REQ_FAILURE } tlv_request;
+ int crypto_binding_sent;
+ int crypto_binding_used;
+ enum { NO_BINDING, OPTIONAL_BINDING, REQUIRE_BINDING } crypto_binding;
+ u8 binding_nonce[32];
+ u8 ipmk[40];
+ u8 cmk[20];
+ u8 *phase2_key;
+ size_t phase2_key_len;
+ struct wpabuf *soh_response;
+};
+
+
+static const char * eap_peap_state_txt(int state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case PHASE1:
+ return "PHASE1";
+ case PHASE1_ID2:
+ return "PHASE1_ID2";
+ case PHASE2_START:
+ return "PHASE2_START";
+ case PHASE2_ID:
+ return "PHASE2_ID";
+ case PHASE2_METHOD:
+ return "PHASE2_METHOD";
+ case PHASE2_SOH:
+ return "PHASE2_SOH";
+ case PHASE2_TLV:
+ return "PHASE2_TLV";
+ case SUCCESS_REQ:
+ return "SUCCESS_REQ";
+ case FAILURE_REQ:
+ return "FAILURE_REQ";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "Unknown?!";
+ }
+}
+
+
+static void eap_peap_state(struct eap_peap_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: %s -> %s",
+ eap_peap_state_txt(data->state),
+ eap_peap_state_txt(state));
+ data->state = state;
+}
+
+
+static struct wpabuf * eap_peapv2_tlv_eap_payload(struct wpabuf *buf)
+{
+ struct wpabuf *e;
+ struct eap_tlv_hdr *tlv;
+
+ if (buf == NULL)
+ return NULL;
+
+ /* Encapsulate EAP packet in EAP-Payload TLV */
+ wpa_printf(MSG_DEBUG, "EAP-PEAPv2: Add EAP-Payload TLV");
+ e = wpabuf_alloc(sizeof(*tlv) + wpabuf_len(buf));
+ if (e == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAPv2: Failed to allocate memory "
+ "for TLV encapsulation");
+ wpabuf_free(buf);
+ return NULL;
+ }
+ tlv = wpabuf_put(e, sizeof(*tlv));
+ tlv->tlv_type = host_to_be16(EAP_TLV_TYPE_MANDATORY |
+ EAP_TLV_EAP_PAYLOAD_TLV);
+ tlv->length = host_to_be16(wpabuf_len(buf));
+ wpabuf_put_buf(e, buf);
+ wpabuf_free(buf);
+ return e;
+}
+
+
+static void eap_peap_req_success(struct eap_sm *sm,
+ struct eap_peap_data *data)
+{
+ if (data->state == FAILURE || data->state == FAILURE_REQ) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ if (data->peap_version == 0) {
+ data->tlv_request = TLV_REQ_SUCCESS;
+ eap_peap_state(data, PHASE2_TLV);
+ } else {
+ eap_peap_state(data, SUCCESS_REQ);
+ }
+}
+
+
+static void eap_peap_req_failure(struct eap_sm *sm,
+ struct eap_peap_data *data)
+{
+ if (data->state == FAILURE || data->state == FAILURE_REQ ||
+ data->state == SUCCESS_REQ || data->tlv_request != TLV_REQ_NONE) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ if (data->peap_version == 0) {
+ data->tlv_request = TLV_REQ_FAILURE;
+ eap_peap_state(data, PHASE2_TLV);
+ } else {
+ eap_peap_state(data, FAILURE_REQ);
+ }
+}
+
+
+static void * eap_peap_init(struct eap_sm *sm)
+{
+ struct eap_peap_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->peap_version = EAP_PEAP_VERSION;
+ data->force_version = -1;
+ if (sm->user && sm->user->force_version >= 0) {
+ data->force_version = sm->user->force_version;
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: forcing version %d",
+ data->force_version);
+ data->peap_version = data->force_version;
+ }
+ data->state = START;
+ data->crypto_binding = OPTIONAL_BINDING;
+
+ if (eap_server_tls_ssl_init(sm, &data->ssl, 0)) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Failed to initialize SSL.");
+ eap_peap_reset(sm, data);
+ return NULL;
+ }
+
+ return data;
+}
+
+
+static void eap_peap_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_peap_data *data = priv;
+ if (data == NULL)
+ return;
+ if (data->phase2_priv && data->phase2_method)
+ data->phase2_method->reset(sm, data->phase2_priv);
+ eap_server_tls_ssl_deinit(sm, &data->ssl);
+ wpabuf_free(data->pending_phase2_resp);
+ os_free(data->phase2_key);
+ wpabuf_free(data->soh_response);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_peap_build_start(struct eap_sm *sm,
+ struct eap_peap_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PEAP, 1,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-PEAP: Failed to allocate memory for"
+ " request");
+ eap_peap_state(data, FAILURE);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_TLS_FLAGS_START | data->peap_version);
+
+ eap_peap_state(data, PHASE1);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_peap_build_phase2_req(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ u8 id)
+{
+ struct wpabuf *buf, *encr_req, msgbuf;
+ const u8 *req;
+ size_t req_len;
+
+ if (data->phase2_method == NULL || data->phase2_priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 method not ready");
+ return NULL;
+ }
+ buf = data->phase2_method->buildReq(sm, data->phase2_priv, id);
+ if (data->peap_version >= 2 && buf)
+ buf = eap_peapv2_tlv_eap_payload(buf);
+ if (buf == NULL)
+ return NULL;
+
+ req = wpabuf_head(buf);
+ req_len = wpabuf_len(buf);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: Encrypting Phase 2 data",
+ req, req_len);
+
+ if (data->peap_version == 0 &&
+ data->phase2_method->method != EAP_TYPE_TLV) {
+ req += sizeof(struct eap_hdr);
+ req_len -= sizeof(struct eap_hdr);
+ }
+
+ wpabuf_set(&msgbuf, req, req_len);
+ encr_req = eap_server_tls_encrypt(sm, &data->ssl, &msgbuf);
+ wpabuf_free(buf);
+
+ return encr_req;
+}
+
+
+#ifdef EAP_SERVER_TNC
+static struct wpabuf * eap_peap_build_phase2_soh(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ u8 id)
+{
+ struct wpabuf *buf1, *buf, *encr_req, msgbuf;
+ const u8 *req;
+ size_t req_len;
+
+ buf1 = tncs_build_soh_request();
+ if (buf1 == NULL)
+ return NULL;
+
+ buf = eap_msg_alloc(EAP_VENDOR_MICROSOFT, 0x21, wpabuf_len(buf1),
+ EAP_CODE_REQUEST, id);
+ if (buf == NULL) {
+ wpabuf_free(buf1);
+ return NULL;
+ }
+ wpabuf_put_buf(buf, buf1);
+ wpabuf_free(buf1);
+
+ req = wpabuf_head(buf);
+ req_len = wpabuf_len(buf);
+
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: Encrypting Phase 2 SOH data",
+ req, req_len);
+
+ req += sizeof(struct eap_hdr);
+ req_len -= sizeof(struct eap_hdr);
+ wpabuf_set(&msgbuf, req, req_len);
+
+ encr_req = eap_server_tls_encrypt(sm, &data->ssl, &msgbuf);
+ wpabuf_free(buf);
+
+ return encr_req;
+}
+#endif /* EAP_SERVER_TNC */
+
+
+static void eap_peap_get_isk(struct eap_peap_data *data,
+ u8 *isk, size_t isk_len)
+{
+ size_t key_len;
+
+ os_memset(isk, 0, isk_len);
+ if (data->phase2_key == NULL)
+ return;
+
+ key_len = data->phase2_key_len;
+ if (key_len > isk_len)
+ key_len = isk_len;
+ os_memcpy(isk, data->phase2_key, key_len);
+}
+
+
+static int eap_peap_derive_cmk(struct eap_sm *sm, struct eap_peap_data *data)
+{
+ u8 *tk;
+ u8 isk[32], imck[60];
+
+ /*
+ * Tunnel key (TK) is the first 60 octets of the key generated by
+ * phase 1 of PEAP (based on TLS).
+ */
+ tk = eap_server_tls_derive_key(sm, &data->ssl, "client EAP encryption",
+ EAP_TLS_KEY_LEN);
+ if (tk == NULL)
+ return -1;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: TK", tk, 60);
+
+ eap_peap_get_isk(data, isk, sizeof(isk));
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: ISK", isk, sizeof(isk));
+
+ /*
+ * IPMK Seed = "Inner Methods Compound Keys" | ISK
+ * TempKey = First 40 octets of TK
+ * IPMK|CMK = PRF+(TempKey, IPMK Seed, 60)
+ * (note: draft-josefsson-pppext-eap-tls-eap-10.txt includes a space
+ * in the end of the label just before ISK; is that just a typo?)
+ */
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: TempKey", tk, 40);
+ peap_prfplus(data->peap_version, tk, 40, "Inner Methods Compound Keys",
+ isk, sizeof(isk), imck, sizeof(imck));
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: IMCK (IPMKj)",
+ imck, sizeof(imck));
+
+ os_free(tk);
+
+ /* TODO: fast-connect: IPMK|CMK = TK */
+ os_memcpy(data->ipmk, imck, 40);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: IPMK (S-IPMKj)", data->ipmk, 40);
+ os_memcpy(data->cmk, imck + 40, 20);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: CMK (CMKj)", data->cmk, 20);
+
+ return 0;
+}
+
+
+static struct wpabuf * eap_peap_build_phase2_tlv(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ u8 id)
+{
+ struct wpabuf *buf, *encr_req;
+ size_t mlen;
+
+ mlen = 6; /* Result TLV */
+ if (data->crypto_binding != NO_BINDING)
+ mlen += 60; /* Cryptobinding TLV */
+#ifdef EAP_SERVER_TNC
+ if (data->soh_response)
+ mlen += wpabuf_len(data->soh_response);
+#endif /* EAP_SERVER_TNC */
+
+ buf = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TLV, mlen,
+ EAP_CODE_REQUEST, id);
+ if (buf == NULL)
+ return NULL;
+
+ wpabuf_put_u8(buf, 0x80); /* Mandatory */
+ wpabuf_put_u8(buf, EAP_TLV_RESULT_TLV);
+ /* Length */
+ wpabuf_put_be16(buf, 2);
+ /* Status */
+ wpabuf_put_be16(buf, data->tlv_request == TLV_REQ_SUCCESS ?
+ EAP_TLV_RESULT_SUCCESS : EAP_TLV_RESULT_FAILURE);
+
+ if (data->peap_version == 0 && data->tlv_request == TLV_REQ_SUCCESS &&
+ data->crypto_binding != NO_BINDING) {
+ u8 *mac;
+ u8 eap_type = EAP_TYPE_PEAP;
+ const u8 *addr[2];
+ size_t len[2];
+ u16 tlv_type;
+
+#ifdef EAP_SERVER_TNC
+ if (data->soh_response) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Adding MS-SOH "
+ "Response TLV");
+ wpabuf_put_buf(buf, data->soh_response);
+ wpabuf_free(data->soh_response);
+ data->soh_response = NULL;
+ }
+#endif /* EAP_SERVER_TNC */
+
+ if (eap_peap_derive_cmk(sm, data) < 0 ||
+ random_get_bytes(data->binding_nonce, 32)) {
+ wpabuf_free(buf);
+ return NULL;
+ }
+
+ /* Compound_MAC: HMAC-SHA1-160(cryptobinding TLV | EAP type) */
+ addr[0] = wpabuf_put(buf, 0);
+ len[0] = 60;
+ addr[1] = &eap_type;
+ len[1] = 1;
+
+ tlv_type = EAP_TLV_CRYPTO_BINDING_TLV;
+ if (data->peap_version >= 2)
+ tlv_type |= EAP_TLV_TYPE_MANDATORY;
+ wpabuf_put_be16(buf, tlv_type);
+ wpabuf_put_be16(buf, 56);
+
+ wpabuf_put_u8(buf, 0); /* Reserved */
+ wpabuf_put_u8(buf, data->peap_version); /* Version */
+ wpabuf_put_u8(buf, data->recv_version); /* RecvVersion */
+ wpabuf_put_u8(buf, 0); /* SubType: 0 = Request, 1 = Response */
+ wpabuf_put_data(buf, data->binding_nonce, 32); /* Nonce */
+ mac = wpabuf_put(buf, 20); /* Compound_MAC */
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PEAP: Compound_MAC CMK",
+ data->cmk, 20);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PEAP: Compound_MAC data 1",
+ addr[0], len[0]);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PEAP: Compound_MAC data 2",
+ addr[1], len[1]);
+ hmac_sha1_vector(data->cmk, 20, 2, addr, len, mac);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PEAP: Compound_MAC",
+ mac, SHA1_MAC_LEN);
+ data->crypto_binding_sent = 1;
+ }
+
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-PEAP: Encrypting Phase 2 TLV data",
+ buf);
+
+ encr_req = eap_server_tls_encrypt(sm, &data->ssl, buf);
+ wpabuf_free(buf);
+
+ return encr_req;
+}
+
+
+static struct wpabuf * eap_peap_build_phase2_term(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ u8 id, int success)
+{
+ struct wpabuf *encr_req, msgbuf;
+ size_t req_len;
+ struct eap_hdr *hdr;
+
+ req_len = sizeof(*hdr);
+ hdr = os_zalloc(req_len);
+ if (hdr == NULL)
+ return NULL;
+
+ hdr->code = success ? EAP_CODE_SUCCESS : EAP_CODE_FAILURE;
+ hdr->identifier = id;
+ hdr->length = host_to_be16(req_len);
+
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: Encrypting Phase 2 data",
+ (u8 *) hdr, req_len);
+
+ wpabuf_set(&msgbuf, hdr, req_len);
+ encr_req = eap_server_tls_encrypt(sm, &data->ssl, &msgbuf);
+ os_free(hdr);
+
+ return encr_req;
+}
+
+
+static struct wpabuf * eap_peap_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_peap_data *data = priv;
+
+ if (data->ssl.state == FRAG_ACK) {
+ return eap_server_tls_build_ack(id, EAP_TYPE_PEAP,
+ data->peap_version);
+ }
+
+ if (data->ssl.state == WAIT_FRAG_ACK) {
+ return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_PEAP,
+ data->peap_version, id);
+ }
+
+ switch (data->state) {
+ case START:
+ return eap_peap_build_start(sm, data, id);
+ case PHASE1:
+ case PHASE1_ID2:
+ if (data->peap_version < 2 &&
+ tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase1 done, "
+ "starting Phase2");
+ eap_peap_state(data, PHASE2_START);
+ }
+ break;
+ case PHASE2_ID:
+ case PHASE2_METHOD:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_peap_build_phase2_req(sm, data, id);
+ break;
+#ifdef EAP_SERVER_TNC
+ case PHASE2_SOH:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_peap_build_phase2_soh(sm, data, id);
+ break;
+#endif /* EAP_SERVER_TNC */
+ case PHASE2_TLV:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_peap_build_phase2_tlv(sm, data, id);
+ break;
+ case SUCCESS_REQ:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_peap_build_phase2_term(sm, data, id,
+ 1);
+ break;
+ case FAILURE_REQ:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_peap_build_phase2_term(sm, data, id,
+ 0);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: %s - unexpected state %d",
+ __func__, data->state);
+ return NULL;
+ }
+
+ return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_PEAP,
+ data->peap_version, id);
+}
+
+
+static Boolean eap_peap_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PEAP, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static int eap_peap_phase2_init(struct eap_sm *sm, struct eap_peap_data *data,
+ EapType eap_type)
+{
+ if (data->phase2_priv && data->phase2_method) {
+ data->phase2_method->reset(sm, data->phase2_priv);
+ data->phase2_method = NULL;
+ data->phase2_priv = NULL;
+ }
+ data->phase2_method = eap_server_get_eap_method(EAP_VENDOR_IETF,
+ eap_type);
+ if (!data->phase2_method)
+ return -1;
+
+ sm->init_phase2 = 1;
+ data->phase2_priv = data->phase2_method->init(sm);
+ sm->init_phase2 = 0;
+ return 0;
+}
+
+
+static int eap_tlv_validate_cryptobinding(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ const u8 *crypto_tlv,
+ size_t crypto_tlv_len)
+{
+ u8 buf[61], mac[SHA1_MAC_LEN];
+ const u8 *pos;
+
+ if (crypto_tlv_len != 4 + 56) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Invalid cryptobinding TLV "
+ "length %d", (int) crypto_tlv_len);
+ return -1;
+ }
+
+ pos = crypto_tlv;
+ pos += 4; /* TLV header */
+ if (pos[1] != data->peap_version) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Cryptobinding TLV Version "
+ "mismatch (was %d; expected %d)",
+ pos[1], data->peap_version);
+ return -1;
+ }
+
+ if (pos[3] != 1) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Unexpected Cryptobinding TLV "
+ "SubType %d", pos[3]);
+ return -1;
+ }
+ pos += 4;
+ pos += 32; /* Nonce */
+
+ /* Compound_MAC: HMAC-SHA1-160(cryptobinding TLV | EAP type) */
+ os_memcpy(buf, crypto_tlv, 60);
+ os_memset(buf + 4 + 4 + 32, 0, 20); /* Compound_MAC */
+ buf[60] = EAP_TYPE_PEAP;
+ hmac_sha1(data->cmk, 20, buf, sizeof(buf), mac);
+
+ if (os_memcmp(mac, pos, SHA1_MAC_LEN) != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Invalid Compound_MAC in "
+ "cryptobinding TLV");
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: CMK", data->cmk, 20);
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Cryptobinding seed data",
+ buf, 61);
+ return -1;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Valid cryptobinding TLV received");
+
+ return 0;
+}
+
+
+static void eap_peap_process_phase2_tlv(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ struct wpabuf *in_data)
+{
+ const u8 *pos;
+ size_t left;
+ const u8 *result_tlv = NULL, *crypto_tlv = NULL;
+ size_t result_tlv_len = 0, crypto_tlv_len = 0;
+ int tlv_type, mandatory, tlv_len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_TLV, in_data, &left);
+ if (pos == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Invalid EAP-TLV header");
+ return;
+ }
+
+ /* Parse TLVs */
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Received TLVs", pos, left);
+ while (left >= 4) {
+ mandatory = !!(pos[0] & 0x80);
+ tlv_type = pos[0] & 0x3f;
+ tlv_type = (tlv_type << 8) | pos[1];
+ tlv_len = ((int) pos[2] << 8) | pos[3];
+ pos += 4;
+ left -= 4;
+ if ((size_t) tlv_len > left) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: TLV underrun "
+ "(tlv_len=%d left=%lu)", tlv_len,
+ (unsigned long) left);
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ switch (tlv_type) {
+ case EAP_TLV_RESULT_TLV:
+ result_tlv = pos;
+ result_tlv_len = tlv_len;
+ break;
+ case EAP_TLV_CRYPTO_BINDING_TLV:
+ crypto_tlv = pos;
+ crypto_tlv_len = tlv_len;
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Unsupported TLV Type "
+ "%d%s", tlv_type,
+ mandatory ? " (mandatory)" : "");
+ if (mandatory) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ /* Ignore this TLV, but process other TLVs */
+ break;
+ }
+
+ pos += tlv_len;
+ left -= tlv_len;
+ }
+ if (left) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Last TLV too short in "
+ "Request (left=%lu)", (unsigned long) left);
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ /* Process supported TLVs */
+ if (crypto_tlv && data->crypto_binding_sent) {
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Cryptobinding TLV",
+ crypto_tlv, crypto_tlv_len);
+ if (eap_tlv_validate_cryptobinding(sm, data, crypto_tlv - 4,
+ crypto_tlv_len + 4) < 0) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ data->crypto_binding_used = 1;
+ } else if (!crypto_tlv && data->crypto_binding_sent &&
+ data->crypto_binding == REQUIRE_BINDING) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: No cryptobinding TLV");
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ if (result_tlv) {
+ int status;
+ const char *requested;
+
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Result TLV",
+ result_tlv, result_tlv_len);
+ if (result_tlv_len < 2) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Too short Result TLV "
+ "(len=%lu)",
+ (unsigned long) result_tlv_len);
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ requested = data->tlv_request == TLV_REQ_SUCCESS ? "Success" :
+ "Failure";
+ status = WPA_GET_BE16(result_tlv);
+ if (status == EAP_TLV_RESULT_SUCCESS) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: TLV Result - Success "
+ "- requested %s", requested);
+ if (data->tlv_request == TLV_REQ_SUCCESS)
+ eap_peap_state(data, SUCCESS);
+ else
+ eap_peap_state(data, FAILURE);
+
+ } else if (status == EAP_TLV_RESULT_FAILURE) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: TLV Result - Failure "
+ "- requested %s", requested);
+ eap_peap_state(data, FAILURE);
+ } else {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Unknown TLV Result "
+ "Status %d", status);
+ eap_peap_state(data, FAILURE);
+ }
+ }
+}
+
+
+#ifdef EAP_SERVER_TNC
+static void eap_peap_process_phase2_soh(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ struct wpabuf *in_data)
+{
+ const u8 *pos, *vpos;
+ size_t left;
+ const u8 *soh_tlv = NULL;
+ size_t soh_tlv_len = 0;
+ int tlv_type, mandatory, tlv_len, vtlv_len;
+ u8 next_type;
+ u32 vendor_id;
+
+ pos = eap_hdr_validate(EAP_VENDOR_MICROSOFT, 0x21, in_data, &left);
+ if (pos == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Not a valid SoH EAP "
+ "Extensions Method header - skip TNC");
+ goto auth_method;
+ }
+
+ /* Parse TLVs */
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Received TLVs (SoH)", pos, left);
+ while (left >= 4) {
+ mandatory = !!(pos[0] & 0x80);
+ tlv_type = pos[0] & 0x3f;
+ tlv_type = (tlv_type << 8) | pos[1];
+ tlv_len = ((int) pos[2] << 8) | pos[3];
+ pos += 4;
+ left -= 4;
+ if ((size_t) tlv_len > left) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: TLV underrun "
+ "(tlv_len=%d left=%lu)", tlv_len,
+ (unsigned long) left);
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ switch (tlv_type) {
+ case EAP_TLV_VENDOR_SPECIFIC_TLV:
+ if (tlv_len < 4) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Too short "
+ "vendor specific TLV (len=%d)",
+ (int) tlv_len);
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ vendor_id = WPA_GET_BE32(pos);
+ if (vendor_id != EAP_VENDOR_MICROSOFT) {
+ if (mandatory) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ break;
+ }
+
+ vpos = pos + 4;
+ mandatory = !!(vpos[0] & 0x80);
+ tlv_type = vpos[0] & 0x3f;
+ tlv_type = (tlv_type << 8) | vpos[1];
+ vtlv_len = ((int) vpos[2] << 8) | vpos[3];
+ vpos += 4;
+ if (vpos + vtlv_len > pos + left) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Vendor TLV "
+ "underrun");
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ if (tlv_type == 1) {
+ soh_tlv = vpos;
+ soh_tlv_len = vtlv_len;
+ break;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Unsupported MS-TLV "
+ "Type %d%s", tlv_type,
+ mandatory ? " (mandatory)" : "");
+ if (mandatory) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ /* Ignore this TLV, but process other TLVs */
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Unsupported TLV Type "
+ "%d%s", tlv_type,
+ mandatory ? " (mandatory)" : "");
+ if (mandatory) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ /* Ignore this TLV, but process other TLVs */
+ break;
+ }
+
+ pos += tlv_len;
+ left -= tlv_len;
+ }
+ if (left) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Last TLV too short in "
+ "Request (left=%lu)", (unsigned long) left);
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ /* Process supported TLVs */
+ if (soh_tlv) {
+ int failure = 0;
+ wpabuf_free(data->soh_response);
+ data->soh_response = tncs_process_soh(soh_tlv, soh_tlv_len,
+ &failure);
+ if (failure) {
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: No SoH TLV received");
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+auth_method:
+ eap_peap_state(data, PHASE2_METHOD);
+ next_type = sm->user->methods[0].method;
+ sm->user_eap_method_index = 1;
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: try EAP type %d", next_type);
+ eap_peap_phase2_init(sm, data, next_type);
+}
+#endif /* EAP_SERVER_TNC */
+
+
+static void eap_peap_process_phase2_response(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ struct wpabuf *in_data)
+{
+ u8 next_type = EAP_TYPE_NONE;
+ const struct eap_hdr *hdr;
+ const u8 *pos;
+ size_t left;
+
+ if (data->state == PHASE2_TLV) {
+ eap_peap_process_phase2_tlv(sm, data, in_data);
+ return;
+ }
+
+#ifdef EAP_SERVER_TNC
+ if (data->state == PHASE2_SOH) {
+ eap_peap_process_phase2_soh(sm, data, in_data);
+ return;
+ }
+#endif /* EAP_SERVER_TNC */
+
+ if (data->phase2_priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: %s - Phase2 not "
+ "initialized?!", __func__);
+ return;
+ }
+
+ hdr = wpabuf_head(in_data);
+ pos = (const u8 *) (hdr + 1);
+
+ if (wpabuf_len(in_data) > sizeof(*hdr) && *pos == EAP_TYPE_NAK) {
+ left = wpabuf_len(in_data) - sizeof(*hdr);
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Phase2 type Nak'ed; "
+ "allowed types", pos + 1, left - 1);
+ eap_sm_process_nak(sm, pos + 1, left - 1);
+ if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
+ sm->user->methods[sm->user_eap_method_index].method !=
+ EAP_TYPE_NONE) {
+ next_type = sm->user->methods[
+ sm->user_eap_method_index++].method;
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: try EAP type %d",
+ next_type);
+ } else {
+ eap_peap_req_failure(sm, data);
+ next_type = EAP_TYPE_NONE;
+ }
+ eap_peap_phase2_init(sm, data, next_type);
+ return;
+ }
+
+ if (data->phase2_method->check(sm, data->phase2_priv, in_data)) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase2 check() asked to "
+ "ignore the packet");
+ return;
+ }
+
+ data->phase2_method->process(sm, data->phase2_priv, in_data);
+
+ if (sm->method_pending == METHOD_PENDING_WAIT) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase2 method is in "
+ "pending wait state - save decrypted response");
+ wpabuf_free(data->pending_phase2_resp);
+ data->pending_phase2_resp = wpabuf_dup(in_data);
+ }
+
+ if (!data->phase2_method->isDone(sm, data->phase2_priv))
+ return;
+
+ if (!data->phase2_method->isSuccess(sm, data->phase2_priv)) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase2 method failed");
+ eap_peap_req_failure(sm, data);
+ next_type = EAP_TYPE_NONE;
+ eap_peap_phase2_init(sm, data, next_type);
+ return;
+ }
+
+ os_free(data->phase2_key);
+ if (data->phase2_method->getKey) {
+ data->phase2_key = data->phase2_method->getKey(
+ sm, data->phase2_priv, &data->phase2_key_len);
+ if (data->phase2_key == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase2 getKey "
+ "failed");
+ eap_peap_req_failure(sm, data);
+ eap_peap_phase2_init(sm, data, EAP_TYPE_NONE);
+ return;
+ }
+ }
+
+ switch (data->state) {
+ case PHASE1_ID2:
+ case PHASE2_ID:
+ case PHASE2_SOH:
+ if (eap_user_get(sm, sm->identity, sm->identity_len, 1) != 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP_PEAP: Phase2 "
+ "Identity not found in the user "
+ "database",
+ sm->identity, sm->identity_len);
+ eap_peap_req_failure(sm, data);
+ next_type = EAP_TYPE_NONE;
+ break;
+ }
+
+#ifdef EAP_SERVER_TNC
+ if (data->state != PHASE2_SOH && sm->tnc &&
+ data->peap_version == 0) {
+ eap_peap_state(data, PHASE2_SOH);
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Try to initialize "
+ "TNC (NAP SOH)");
+ next_type = EAP_TYPE_NONE;
+ break;
+ }
+#endif /* EAP_SERVER_TNC */
+
+ eap_peap_state(data, PHASE2_METHOD);
+ next_type = sm->user->methods[0].method;
+ sm->user_eap_method_index = 1;
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: try EAP type %d", next_type);
+ break;
+ case PHASE2_METHOD:
+ eap_peap_req_success(sm, data);
+ next_type = EAP_TYPE_NONE;
+ break;
+ case FAILURE:
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: %s - unexpected state %d",
+ __func__, data->state);
+ break;
+ }
+
+ eap_peap_phase2_init(sm, data, next_type);
+}
+
+
+static void eap_peap_process_phase2(struct eap_sm *sm,
+ struct eap_peap_data *data,
+ const struct wpabuf *respData,
+ struct wpabuf *in_buf)
+{
+ struct wpabuf *in_decrypted;
+ const struct eap_hdr *hdr;
+ size_t len;
+
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: received %lu bytes encrypted data for"
+ " Phase 2", (unsigned long) wpabuf_len(in_buf));
+
+ if (data->pending_phase2_resp) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Pending Phase 2 response - "
+ "skip decryption and use old data");
+ eap_peap_process_phase2_response(sm, data,
+ data->pending_phase2_resp);
+ wpabuf_free(data->pending_phase2_resp);
+ data->pending_phase2_resp = NULL;
+ return;
+ }
+
+ in_decrypted = tls_connection_decrypt(sm->ssl_ctx, data->ssl.conn,
+ in_buf);
+ if (in_decrypted == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Failed to decrypt Phase 2 "
+ "data");
+ eap_peap_state(data, FAILURE);
+ return;
+ }
+
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-PEAP: Decrypted Phase 2 EAP",
+ in_decrypted);
+
+ hdr = wpabuf_head(in_decrypted);
+
+ if (data->peap_version == 0 && data->state != PHASE2_TLV) {
+ const struct eap_hdr *resp;
+ struct eap_hdr *nhdr;
+ struct wpabuf *nbuf =
+ wpabuf_alloc(sizeof(struct eap_hdr) +
+ wpabuf_len(in_decrypted));
+ if (nbuf == NULL) {
+ wpabuf_free(in_decrypted);
+ return;
+ }
+
+ resp = wpabuf_head(respData);
+ nhdr = wpabuf_put(nbuf, sizeof(*nhdr));
+ nhdr->code = resp->code;
+ nhdr->identifier = resp->identifier;
+ nhdr->length = host_to_be16(sizeof(struct eap_hdr) +
+ wpabuf_len(in_decrypted));
+ wpabuf_put_buf(nbuf, in_decrypted);
+ wpabuf_free(in_decrypted);
+
+ in_decrypted = nbuf;
+ } else if (data->peap_version >= 2) {
+ struct eap_tlv_hdr *tlv;
+ struct wpabuf *nmsg;
+
+ if (wpabuf_len(in_decrypted) < sizeof(*tlv) + sizeof(*hdr)) {
+ wpa_printf(MSG_INFO, "EAP-PEAPv2: Too short Phase 2 "
+ "EAP TLV");
+ wpabuf_free(in_decrypted);
+ return;
+ }
+ tlv = wpabuf_mhead(in_decrypted);
+ if ((be_to_host16(tlv->tlv_type) & EAP_TLV_TYPE_MASK) !=
+ EAP_TLV_EAP_PAYLOAD_TLV) {
+ wpa_printf(MSG_INFO, "EAP-PEAPv2: Not an EAP TLV");
+ wpabuf_free(in_decrypted);
+ return;
+ }
+ if (sizeof(*tlv) + be_to_host16(tlv->length) >
+ wpabuf_len(in_decrypted)) {
+ wpa_printf(MSG_INFO, "EAP-PEAPv2: Invalid EAP TLV "
+ "length");
+ wpabuf_free(in_decrypted);
+ return;
+ }
+ hdr = (struct eap_hdr *) (tlv + 1);
+ if (be_to_host16(hdr->length) > be_to_host16(tlv->length)) {
+ wpa_printf(MSG_INFO, "EAP-PEAPv2: No room for full "
+ "EAP packet in EAP TLV");
+ wpabuf_free(in_decrypted);
+ return;
+ }
+
+ nmsg = wpabuf_alloc(be_to_host16(hdr->length));
+ if (nmsg == NULL) {
+ wpabuf_free(in_decrypted);
+ return;
+ }
+
+ wpabuf_put_data(nmsg, hdr, be_to_host16(hdr->length));
+ wpabuf_free(in_decrypted);
+ in_decrypted = nmsg;
+ }
+
+ hdr = wpabuf_head(in_decrypted);
+ if (wpabuf_len(in_decrypted) < (int) sizeof(*hdr)) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Too short Phase 2 "
+ "EAP frame (len=%lu)",
+ (unsigned long) wpabuf_len(in_decrypted));
+ wpabuf_free(in_decrypted);
+ eap_peap_req_failure(sm, data);
+ return;
+ }
+ len = be_to_host16(hdr->length);
+ if (len > wpabuf_len(in_decrypted)) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: Length mismatch in "
+ "Phase 2 EAP frame (len=%lu hdr->length=%lu)",
+ (unsigned long) wpabuf_len(in_decrypted),
+ (unsigned long) len);
+ wpabuf_free(in_decrypted);
+ eap_peap_req_failure(sm, data);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: received Phase 2: code=%d "
+ "identifier=%d length=%lu", hdr->code, hdr->identifier,
+ (unsigned long) len);
+ switch (hdr->code) {
+ case EAP_CODE_RESPONSE:
+ eap_peap_process_phase2_response(sm, data, in_decrypted);
+ break;
+ case EAP_CODE_SUCCESS:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 Success");
+ if (data->state == SUCCESS_REQ) {
+ eap_peap_state(data, SUCCESS);
+ }
+ break;
+ case EAP_CODE_FAILURE:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 Failure");
+ eap_peap_state(data, FAILURE);
+ break;
+ default:
+ wpa_printf(MSG_INFO, "EAP-PEAP: Unexpected code=%d in "
+ "Phase 2 EAP header", hdr->code);
+ break;
+ }
+
+ wpabuf_free(in_decrypted);
+}
+
+
+static int eap_peapv2_start_phase2(struct eap_sm *sm,
+ struct eap_peap_data *data)
+{
+ struct wpabuf *buf, *buf2;
+
+ wpa_printf(MSG_DEBUG, "EAP-PEAPv2: Phase1 done, include first Phase2 "
+ "payload in the same message");
+ eap_peap_state(data, PHASE1_ID2);
+ if (eap_peap_phase2_init(sm, data, EAP_TYPE_IDENTITY))
+ return -1;
+
+ /* TODO: which Id to use here? */
+ buf = data->phase2_method->buildReq(sm, data->phase2_priv, 6);
+ if (buf == NULL)
+ return -1;
+
+ buf2 = eap_peapv2_tlv_eap_payload(buf);
+ if (buf2 == NULL)
+ return -1;
+
+ wpa_hexdump_buf(MSG_DEBUG, "EAP-PEAPv2: Identity Request", buf2);
+
+ buf = tls_connection_encrypt(sm->ssl_ctx, data->ssl.conn,
+ buf2);
+ wpabuf_free(buf2);
+
+ if (buf == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PEAPv2: Failed to encrypt Phase 2 "
+ "data");
+ return -1;
+ }
+
+ wpa_hexdump_buf(MSG_DEBUG, "EAP-PEAPv2: Encrypted Identity Request",
+ buf);
+
+ /* Append TLS data into the pending buffer after the Server Finished */
+ if (wpabuf_resize(&data->ssl.tls_out, wpabuf_len(buf)) < 0) {
+ wpabuf_free(buf);
+ return -1;
+ }
+ wpabuf_put_buf(data->ssl.tls_out, buf);
+ wpabuf_free(buf);
+
+ return 0;
+}
+
+
+static int eap_peap_process_version(struct eap_sm *sm, void *priv,
+ int peer_version)
+{
+ struct eap_peap_data *data = priv;
+
+ data->recv_version = peer_version;
+ if (data->force_version >= 0 && peer_version != data->force_version) {
+ wpa_printf(MSG_INFO, "EAP-PEAP: peer did not select the forced"
+ " version (forced=%d peer=%d) - reject",
+ data->force_version, peer_version);
+ return -1;
+ }
+ if (peer_version < data->peap_version) {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: peer ver=%d, own ver=%d; "
+ "use version %d",
+ peer_version, data->peap_version, peer_version);
+ data->peap_version = peer_version;
+ }
+
+ return 0;
+}
+
+
+static void eap_peap_process_msg(struct eap_sm *sm, void *priv,
+ const struct wpabuf *respData)
+{
+ struct eap_peap_data *data = priv;
+
+ switch (data->state) {
+ case PHASE1:
+ if (eap_server_tls_phase1(sm, &data->ssl) < 0) {
+ eap_peap_state(data, FAILURE);
+ break;
+ }
+
+ if (data->peap_version >= 2 &&
+ tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
+ if (eap_peapv2_start_phase2(sm, data)) {
+ eap_peap_state(data, FAILURE);
+ break;
+ }
+ }
+ break;
+ case PHASE2_START:
+ eap_peap_state(data, PHASE2_ID);
+ eap_peap_phase2_init(sm, data, EAP_TYPE_IDENTITY);
+ break;
+ case PHASE1_ID2:
+ case PHASE2_ID:
+ case PHASE2_METHOD:
+ case PHASE2_SOH:
+ case PHASE2_TLV:
+ eap_peap_process_phase2(sm, data, respData, data->ssl.tls_in);
+ break;
+ case SUCCESS_REQ:
+ eap_peap_state(data, SUCCESS);
+ break;
+ case FAILURE_REQ:
+ eap_peap_state(data, FAILURE);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Unexpected state %d in %s",
+ data->state, __func__);
+ break;
+ }
+}
+
+
+static void eap_peap_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_peap_data *data = priv;
+ if (eap_server_tls_process(sm, &data->ssl, respData, data,
+ EAP_TYPE_PEAP, eap_peap_process_version,
+ eap_peap_process_msg) < 0)
+ eap_peap_state(data, FAILURE);
+}
+
+
+static Boolean eap_peap_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_peap_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_peap_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_peap_data *data = priv;
+ u8 *eapKeyData;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ if (data->crypto_binding_used) {
+ u8 csk[128];
+ /*
+ * Note: It looks like Microsoft implementation requires null
+ * termination for this label while the one used for deriving
+ * IPMK|CMK did not use null termination.
+ */
+ peap_prfplus(data->peap_version, data->ipmk, 40,
+ "Session Key Generating Function",
+ (u8 *) "\00", 1, csk, sizeof(csk));
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: CSK", csk, sizeof(csk));
+ eapKeyData = os_malloc(EAP_TLS_KEY_LEN);
+ if (eapKeyData) {
+ os_memcpy(eapKeyData, csk, EAP_TLS_KEY_LEN);
+ *len = EAP_TLS_KEY_LEN;
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Derived key",
+ eapKeyData, EAP_TLS_KEY_LEN);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Failed to derive "
+ "key");
+ }
+
+ return eapKeyData;
+ }
+
+ /* TODO: PEAPv1 - different label in some cases */
+ eapKeyData = eap_server_tls_derive_key(sm, &data->ssl,
+ "client EAP encryption",
+ EAP_TLS_KEY_LEN);
+ if (eapKeyData) {
+ *len = EAP_TLS_KEY_LEN;
+ wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Derived key",
+ eapKeyData, EAP_TLS_KEY_LEN);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-PEAP: Failed to derive key");
+ }
+
+ return eapKeyData;
+}
+
+
+static Boolean eap_peap_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_peap_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_peap_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_PEAP, "PEAP");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_peap_init;
+ eap->reset = eap_peap_reset;
+ eap->buildReq = eap_peap_buildReq;
+ eap->check = eap_peap_check;
+ eap->process = eap_peap_process;
+ eap->isDone = eap_peap_isDone;
+ eap->getKey = eap_peap_getKey;
+ eap->isSuccess = eap_peap_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_psk.c b/src/eap_server/eap_server_psk.c
new file mode 100644
index 0000000..efc7a82
--- /dev/null
+++ b/src/eap_server/eap_server_psk.c
@@ -0,0 +1,518 @@
+/*
+ * hostapd / EAP-PSK (RFC 4764) server
+ * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ *
+ * Note: EAP-PSK is an EAP authentication method and as such, completely
+ * different from WPA-PSK. This file is not needed for WPA-PSK functionality.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/aes_wrap.h"
+#include "crypto/random.h"
+#include "eap_common/eap_psk_common.h"
+#include "eap_server/eap_i.h"
+
+
+struct eap_psk_data {
+ enum { PSK_1, PSK_3, SUCCESS, FAILURE } state;
+ u8 rand_s[EAP_PSK_RAND_LEN];
+ u8 rand_p[EAP_PSK_RAND_LEN];
+ u8 *id_p, *id_s;
+ size_t id_p_len, id_s_len;
+ u8 ak[EAP_PSK_AK_LEN], kdk[EAP_PSK_KDK_LEN], tek[EAP_PSK_TEK_LEN];
+ u8 msk[EAP_MSK_LEN];
+ u8 emsk[EAP_EMSK_LEN];
+};
+
+
+static void * eap_psk_init(struct eap_sm *sm)
+{
+ struct eap_psk_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = PSK_1;
+ data->id_s = (u8 *) "hostapd";
+ data->id_s_len = 7;
+
+ return data;
+}
+
+
+static void eap_psk_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_psk_data *data = priv;
+ os_free(data->id_p);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_psk_build_1(struct eap_sm *sm,
+ struct eap_psk_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_psk_hdr_1 *psk;
+
+ wpa_printf(MSG_DEBUG, "EAP-PSK: PSK-1 (sending)");
+
+ if (random_get_bytes(data->rand_s, EAP_PSK_RAND_LEN)) {
+ wpa_printf(MSG_ERROR, "EAP-PSK: Failed to get random data");
+ data->state = FAILURE;
+ return NULL;
+ }
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PSK: RAND_S (server rand)",
+ data->rand_s, EAP_PSK_RAND_LEN);
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PSK,
+ sizeof(*psk) + data->id_s_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-PSK: Failed to allocate memory "
+ "request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ psk = wpabuf_put(req, sizeof(*psk));
+ psk->flags = EAP_PSK_FLAGS_SET_T(0); /* T=0 */
+ os_memcpy(psk->rand_s, data->rand_s, EAP_PSK_RAND_LEN);
+ wpabuf_put_data(req, data->id_s, data->id_s_len);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_psk_build_3(struct eap_sm *sm,
+ struct eap_psk_data *data, u8 id)
+{
+ struct wpabuf *req;
+ struct eap_psk_hdr_3 *psk;
+ u8 *buf, *pchannel, nonce[16];
+ size_t buflen;
+
+ wpa_printf(MSG_DEBUG, "EAP-PSK: PSK-3 (sending)");
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PSK,
+ sizeof(*psk) + 4 + 16 + 1, EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-PSK: Failed to allocate memory "
+ "request");
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ psk = wpabuf_put(req, sizeof(*psk));
+ psk->flags = EAP_PSK_FLAGS_SET_T(2); /* T=2 */
+ os_memcpy(psk->rand_s, data->rand_s, EAP_PSK_RAND_LEN);
+
+ /* MAC_S = OMAC1-AES-128(AK, ID_S||RAND_P) */
+ buflen = data->id_s_len + EAP_PSK_RAND_LEN;
+ buf = os_malloc(buflen);
+ if (buf == NULL)
+ goto fail;
+
+ os_memcpy(buf, data->id_s, data->id_s_len);
+ os_memcpy(buf + data->id_s_len, data->rand_p, EAP_PSK_RAND_LEN);
+ if (omac1_aes_128(data->ak, buf, buflen, psk->mac_s))
+ goto fail;
+ os_free(buf);
+
+ if (eap_psk_derive_keys(data->kdk, data->rand_p, data->tek, data->msk,
+ data->emsk))
+ goto fail;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PSK: TEK", data->tek, EAP_PSK_TEK_LEN);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PSK: MSK", data->msk, EAP_MSK_LEN);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PSK: EMSK", data->emsk, EAP_EMSK_LEN);
+
+ os_memset(nonce, 0, sizeof(nonce));
+ pchannel = wpabuf_put(req, 4 + 16 + 1);
+ os_memcpy(pchannel, nonce + 12, 4);
+ os_memset(pchannel + 4, 0, 16); /* Tag */
+ pchannel[4 + 16] = EAP_PSK_R_FLAG_DONE_SUCCESS << 6;
+ wpa_hexdump(MSG_DEBUG, "EAP-PSK: PCHANNEL (plaintext)",
+ pchannel, 4 + 16 + 1);
+ if (aes_128_eax_encrypt(data->tek, nonce, sizeof(nonce),
+ wpabuf_head(req), 22,
+ pchannel + 4 + 16, 1, pchannel + 4))
+ goto fail;
+ wpa_hexdump(MSG_DEBUG, "EAP-PSK: PCHANNEL (encrypted)",
+ pchannel, 4 + 16 + 1);
+
+ return req;
+
+fail:
+ wpabuf_free(req);
+ data->state = FAILURE;
+ return NULL;
+}
+
+
+static struct wpabuf * eap_psk_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_psk_data *data = priv;
+
+ switch (data->state) {
+ case PSK_1:
+ return eap_psk_build_1(sm, data, id);
+ case PSK_3:
+ return eap_psk_build_3(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Unknown state %d in buildReq",
+ data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_psk_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_psk_data *data = priv;
+ size_t len;
+ u8 t;
+ const u8 *pos;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PSK, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Invalid frame");
+ return TRUE;
+ }
+ t = EAP_PSK_FLAGS_GET_T(*pos);
+
+ wpa_printf(MSG_DEBUG, "EAP-PSK: received frame: T=%d", t);
+
+ if (data->state == PSK_1 && t != 1) {
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Expected PSK-2 - "
+ "ignore T=%d", t);
+ return TRUE;
+ }
+
+ if (data->state == PSK_3 && t != 3) {
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Expected PSK-4 - "
+ "ignore T=%d", t);
+ return TRUE;
+ }
+
+ if ((t == 1 && len < sizeof(struct eap_psk_hdr_2)) ||
+ (t == 3 && len < sizeof(struct eap_psk_hdr_4))) {
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Too short frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_psk_process_2(struct eap_sm *sm,
+ struct eap_psk_data *data,
+ struct wpabuf *respData)
+{
+ const struct eap_psk_hdr_2 *resp;
+ u8 *pos, mac[EAP_PSK_MAC_LEN], *buf;
+ size_t left, buflen;
+ int i;
+ const u8 *cpos;
+
+ if (data->state != PSK_1)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Received PSK-2");
+
+ cpos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PSK, respData,
+ &left);
+ if (cpos == NULL || left < sizeof(*resp)) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Invalid frame");
+ return;
+ }
+ resp = (const struct eap_psk_hdr_2 *) cpos;
+ cpos = (const u8 *) (resp + 1);
+ left -= sizeof(*resp);
+
+ os_free(data->id_p);
+ data->id_p = os_malloc(left);
+ if (data->id_p == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Failed to allocate memory for "
+ "ID_P");
+ return;
+ }
+ os_memcpy(data->id_p, cpos, left);
+ data->id_p_len = left;
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-PSK: ID_P",
+ data->id_p, data->id_p_len);
+
+ if (eap_user_get(sm, data->id_p, data->id_p_len, 0) < 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-PSK: unknown ID_P",
+ data->id_p, data->id_p_len);
+ data->state = FAILURE;
+ return;
+ }
+
+ for (i = 0;
+ i < EAP_MAX_METHODS &&
+ (sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[i].method != EAP_TYPE_NONE);
+ i++) {
+ if (sm->user->methods[i].vendor == EAP_VENDOR_IETF &&
+ sm->user->methods[i].method == EAP_TYPE_PSK)
+ break;
+ }
+
+ if (i >= EAP_MAX_METHODS ||
+ sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
+ sm->user->methods[i].method != EAP_TYPE_PSK) {
+ wpa_hexdump_ascii(MSG_DEBUG,
+ "EAP-PSK: EAP-PSK not enabled for ID_P",
+ data->id_p, data->id_p_len);
+ data->state = FAILURE;
+ return;
+ }
+
+ if (sm->user->password == NULL ||
+ sm->user->password_len != EAP_PSK_PSK_LEN) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-PSK: invalid password in "
+ "user database for ID_P",
+ data->id_p, data->id_p_len);
+ data->state = FAILURE;
+ return;
+ }
+ if (eap_psk_key_setup(sm->user->password, data->ak, data->kdk)) {
+ data->state = FAILURE;
+ return;
+ }
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PSK: AK", data->ak, EAP_PSK_AK_LEN);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-PSK: KDK", data->kdk, EAP_PSK_KDK_LEN);
+
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PSK: RAND_P (client rand)",
+ resp->rand_p, EAP_PSK_RAND_LEN);
+ os_memcpy(data->rand_p, resp->rand_p, EAP_PSK_RAND_LEN);
+
+ /* MAC_P = OMAC1-AES-128(AK, ID_P||ID_S||RAND_S||RAND_P) */
+ buflen = data->id_p_len + data->id_s_len + 2 * EAP_PSK_RAND_LEN;
+ buf = os_malloc(buflen);
+ if (buf == NULL) {
+ data->state = FAILURE;
+ return;
+ }
+ os_memcpy(buf, data->id_p, data->id_p_len);
+ pos = buf + data->id_p_len;
+ os_memcpy(pos, data->id_s, data->id_s_len);
+ pos += data->id_s_len;
+ os_memcpy(pos, data->rand_s, EAP_PSK_RAND_LEN);
+ pos += EAP_PSK_RAND_LEN;
+ os_memcpy(pos, data->rand_p, EAP_PSK_RAND_LEN);
+ if (omac1_aes_128(data->ak, buf, buflen, mac)) {
+ os_free(buf);
+ data->state = FAILURE;
+ return;
+ }
+ os_free(buf);
+ wpa_hexdump(MSG_DEBUG, "EAP-PSK: MAC_P", resp->mac_p, EAP_PSK_MAC_LEN);
+ if (os_memcmp(mac, resp->mac_p, EAP_PSK_MAC_LEN) != 0) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Invalid MAC_P");
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PSK: Expected MAC_P",
+ mac, EAP_PSK_MAC_LEN);
+ data->state = FAILURE;
+ return;
+ }
+
+ data->state = PSK_3;
+}
+
+
+static void eap_psk_process_4(struct eap_sm *sm,
+ struct eap_psk_data *data,
+ struct wpabuf *respData)
+{
+ const struct eap_psk_hdr_4 *resp;
+ u8 *decrypted, nonce[16];
+ size_t left;
+ const u8 *pos, *tag;
+
+ if (data->state != PSK_3)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Received PSK-4");
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PSK, respData, &left);
+ if (pos == NULL || left < sizeof(*resp)) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Invalid frame");
+ return;
+ }
+ resp = (const struct eap_psk_hdr_4 *) pos;
+ pos = (const u8 *) (resp + 1);
+ left -= sizeof(*resp);
+
+ wpa_hexdump(MSG_MSGDUMP, "EAP-PSK: Encrypted PCHANNEL", pos, left);
+
+ if (left < 4 + 16 + 1) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Too short PCHANNEL data in "
+ "PSK-4 (len=%lu, expected 21)",
+ (unsigned long) left);
+ return;
+ }
+
+ if (pos[0] == 0 && pos[1] == 0 && pos[2] == 0 && pos[3] == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-PSK: Nonce did not increase");
+ return;
+ }
+
+ os_memset(nonce, 0, 12);
+ os_memcpy(nonce + 12, pos, 4);
+ pos += 4;
+ left -= 4;
+ tag = pos;
+ pos += 16;
+ left -= 16;
+
+ decrypted = os_malloc(left);
+ if (decrypted == NULL)
+ return;
+ os_memcpy(decrypted, pos, left);
+
+ if (aes_128_eax_decrypt(data->tek, nonce, sizeof(nonce),
+ wpabuf_head(respData), 22, decrypted, left,
+ tag)) {
+ wpa_printf(MSG_WARNING, "EAP-PSK: PCHANNEL decryption failed");
+ os_free(decrypted);
+ data->state = FAILURE;
+ return;
+ }
+ wpa_hexdump(MSG_DEBUG, "EAP-PSK: Decrypted PCHANNEL message",
+ decrypted, left);
+
+ /* Verify R flag */
+ switch (decrypted[0] >> 6) {
+ case EAP_PSK_R_FLAG_CONT:
+ wpa_printf(MSG_DEBUG, "EAP-PSK: R flag - CONT - unsupported");
+ data->state = FAILURE;
+ break;
+ case EAP_PSK_R_FLAG_DONE_SUCCESS:
+ wpa_printf(MSG_DEBUG, "EAP-PSK: R flag - DONE_SUCCESS");
+ data->state = SUCCESS;
+ break;
+ case EAP_PSK_R_FLAG_DONE_FAILURE:
+ wpa_printf(MSG_DEBUG, "EAP-PSK: R flag - DONE_FAILURE");
+ data->state = FAILURE;
+ break;
+ }
+ os_free(decrypted);
+}
+
+
+static void eap_psk_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_psk_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ if (sm->user == NULL || sm->user->password == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PSK: Plaintext password not "
+ "configured");
+ data->state = FAILURE;
+ return;
+ }
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PSK, respData, &len);
+ if (pos == NULL || len < 1)
+ return;
+
+ switch (EAP_PSK_FLAGS_GET_T(*pos)) {
+ case 1:
+ eap_psk_process_2(sm, data, respData);
+ break;
+ case 3:
+ eap_psk_process_4(sm, data, respData);
+ break;
+ }
+}
+
+
+static Boolean eap_psk_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_psk_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_psk_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_psk_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_MSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->msk, EAP_MSK_LEN);
+ *len = EAP_MSK_LEN;
+
+ return key;
+}
+
+
+static u8 * eap_psk_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_psk_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->emsk, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+
+ return key;
+}
+
+
+static Boolean eap_psk_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_psk_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_psk_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_PSK, "PSK");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_psk_init;
+ eap->reset = eap_psk_reset;
+ eap->buildReq = eap_psk_buildReq;
+ eap->check = eap_psk_check;
+ eap->process = eap_psk_process;
+ eap->isDone = eap_psk_isDone;
+ eap->getKey = eap_psk_getKey;
+ eap->isSuccess = eap_psk_isSuccess;
+ eap->get_emsk = eap_psk_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_pwd.c b/src/eap_server/eap_server_pwd.c
new file mode 100644
index 0000000..dd2557a
--- /dev/null
+++ b/src/eap_server/eap_server_pwd.c
@@ -0,0 +1,844 @@
+/*
+ * hostapd / EAP-pwd (RFC 5931) server
+ * Copyright (c) 2010, Dan Harkins <dharkins@lounge.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the BSD license.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_server/eap_i.h"
+#include "eap_common/eap_pwd_common.h"
+
+
+struct eap_pwd_data {
+ enum {
+ PWD_ID_Req, PWD_Commit_Req, PWD_Confirm_Req, SUCCESS, FAILURE
+ } state;
+ u8 *id_peer;
+ size_t id_peer_len;
+ u8 *id_server;
+ size_t id_server_len;
+ u8 *password;
+ size_t password_len;
+ u32 token;
+ u16 group_num;
+ EAP_PWD_group *grp;
+
+ BIGNUM *k;
+ BIGNUM *private_value;
+ BIGNUM *peer_scalar;
+ BIGNUM *my_scalar;
+ EC_POINT *my_element;
+ EC_POINT *peer_element;
+
+ u8 my_confirm[SHA256_DIGEST_LENGTH];
+
+ u8 msk[EAP_MSK_LEN];
+ u8 emsk[EAP_EMSK_LEN];
+
+ BN_CTX *bnctx;
+};
+
+
+static const char * eap_pwd_state_txt(int state)
+{
+ switch (state) {
+ case PWD_ID_Req:
+ return "PWD-ID-Req";
+ case PWD_Commit_Req:
+ return "PWD-Commit-Req";
+ case PWD_Confirm_Req:
+ return "PWD-Confirm-Req";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "PWD-Unk";
+ }
+}
+
+
+static void eap_pwd_state(struct eap_pwd_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-pwd: %s -> %s",
+ eap_pwd_state_txt(data->state), eap_pwd_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_pwd_init(struct eap_sm *sm)
+{
+ struct eap_pwd_data *data;
+
+ if (sm->user == NULL || sm->user->password == NULL ||
+ sm->user->password_len == 0) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): Password is not "
+ "configured");
+ return NULL;
+ }
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+
+ data->group_num = sm->pwd_group;
+ wpa_printf(MSG_DEBUG, "EAP-pwd: Selected group number %d",
+ data->group_num);
+ data->state = PWD_ID_Req;
+
+ data->id_server = (u8 *) os_strdup("server");
+ if (data->id_server)
+ data->id_server_len = os_strlen((char *) data->id_server);
+
+ data->password = os_malloc(sm->user->password_len);
+ if (data->password == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PWD: Memory allocation password "
+ "fail");
+ os_free(data->id_server);
+ os_free(data);
+ return NULL;
+ }
+ data->password_len = sm->user->password_len;
+ os_memcpy(data->password, sm->user->password, data->password_len);
+
+ data->bnctx = BN_CTX_new();
+ if (data->bnctx == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PWD: bn context allocation fail");
+ os_free(data->password);
+ os_free(data->id_server);
+ os_free(data);
+ return NULL;
+ }
+
+ return data;
+}
+
+
+static void eap_pwd_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_pwd_data *data = priv;
+
+ BN_free(data->private_value);
+ BN_free(data->peer_scalar);
+ BN_free(data->my_scalar);
+ BN_free(data->k);
+ BN_CTX_free(data->bnctx);
+ EC_POINT_free(data->my_element);
+ EC_POINT_free(data->peer_element);
+ os_free(data->id_peer);
+ os_free(data->id_server);
+ os_free(data->password);
+ if (data->grp) {
+ EC_GROUP_free(data->grp->group);
+ EC_POINT_free(data->grp->pwe);
+ BN_free(data->grp->order);
+ BN_free(data->grp->prime);
+ os_free(data->grp);
+ }
+ os_free(data);
+}
+
+
+static struct wpabuf *
+eap_pwd_build_id_req(struct eap_sm *sm, struct eap_pwd_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ wpa_printf(MSG_DEBUG, "EAP-pwd: ID/Request");
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PWD,
+ sizeof(struct eap_pwd_hdr) +
+ sizeof(struct eap_pwd_id) + data->id_server_len,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ eap_pwd_state(data, FAILURE);
+ return NULL;
+ }
+
+ /* an lfsr is good enough to generate unpredictable tokens */
+ data->token = os_random();
+ wpabuf_put_u8(req, EAP_PWD_OPCODE_ID_EXCH);
+ wpabuf_put_be16(req, data->group_num);
+ wpabuf_put_u8(req, EAP_PWD_DEFAULT_RAND_FUNC);
+ wpabuf_put_u8(req, EAP_PWD_DEFAULT_PRF);
+ wpabuf_put_data(req, &data->token, sizeof(data->token));
+ wpabuf_put_u8(req, EAP_PWD_PREP_NONE);
+ wpabuf_put_data(req, data->id_server, data->id_server_len);
+
+ return req;
+}
+
+
+static struct wpabuf *
+eap_pwd_build_commit_req(struct eap_sm *sm, struct eap_pwd_data *data, u8 id)
+{
+ struct wpabuf *req = NULL;
+ BIGNUM *mask = NULL, *x = NULL, *y = NULL;
+ u8 *scalar = NULL, *element = NULL;
+ u16 offset;
+
+ wpa_printf(MSG_DEBUG, "EAP-pwd: Commit/Request");
+
+ if (((data->private_value = BN_new()) == NULL) ||
+ ((data->my_element = EC_POINT_new(data->grp->group)) == NULL) ||
+ ((data->my_scalar = BN_new()) == NULL) ||
+ ((mask = BN_new()) == NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): scalar allocation "
+ "fail");
+ goto fin;
+ }
+
+ BN_rand_range(data->private_value, data->grp->order);
+ BN_rand_range(mask, data->grp->order);
+ BN_add(data->my_scalar, data->private_value, mask);
+ BN_mod(data->my_scalar, data->my_scalar, data->grp->order,
+ data->bnctx);
+
+ if (!EC_POINT_mul(data->grp->group, data->my_element, NULL,
+ data->grp->pwe, mask, data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): element allocation "
+ "fail");
+ eap_pwd_state(data, FAILURE);
+ goto fin;
+ }
+
+ if (!EC_POINT_invert(data->grp->group, data->my_element, data->bnctx))
+ {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): element inversion "
+ "fail");
+ goto fin;
+ }
+ BN_free(mask);
+
+ if (((x = BN_new()) == NULL) ||
+ ((y = BN_new()) == NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): point allocation "
+ "fail");
+ goto fin;
+ }
+ if (!EC_POINT_get_affine_coordinates_GFp(data->grp->group,
+ data->my_element, x, y,
+ data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): point assignment "
+ "fail");
+ goto fin;
+ }
+
+ if (((scalar = os_malloc(BN_num_bytes(data->grp->order))) == NULL) ||
+ ((element = os_malloc(BN_num_bytes(data->grp->prime) * 2)) ==
+ NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): data allocation fail");
+ goto fin;
+ }
+
+ /*
+ * bignums occupy as little memory as possible so one that is
+ * sufficiently smaller than the prime or order might need pre-pending
+ * with zeros.
+ */
+ os_memset(scalar, 0, BN_num_bytes(data->grp->order));
+ os_memset(element, 0, BN_num_bytes(data->grp->prime) * 2);
+ offset = BN_num_bytes(data->grp->order) -
+ BN_num_bytes(data->my_scalar);
+ BN_bn2bin(data->my_scalar, scalar + offset);
+
+ offset = BN_num_bytes(data->grp->prime) - BN_num_bytes(x);
+ BN_bn2bin(x, element + offset);
+ offset = BN_num_bytes(data->grp->prime) - BN_num_bytes(y);
+ BN_bn2bin(y, element + BN_num_bytes(data->grp->prime) + offset);
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PWD,
+ sizeof(struct eap_pwd_hdr) +
+ (2 * BN_num_bytes(data->grp->prime)) +
+ BN_num_bytes(data->grp->order),
+ EAP_CODE_REQUEST, id);
+ if (req == NULL)
+ goto fin;
+ wpabuf_put_u8(req, EAP_PWD_OPCODE_COMMIT_EXCH);
+
+ /* We send the element as (x,y) followed by the scalar */
+ wpabuf_put_data(req, element, (2 * BN_num_bytes(data->grp->prime)));
+ wpabuf_put_data(req, scalar, BN_num_bytes(data->grp->order));
+
+fin:
+ os_free(scalar);
+ os_free(element);
+ BN_free(x);
+ BN_free(y);
+ if (req == NULL)
+ eap_pwd_state(data, FAILURE);
+
+ return req;
+}
+
+
+static struct wpabuf *
+eap_pwd_build_confirm_req(struct eap_sm *sm, struct eap_pwd_data *data, u8 id)
+{
+ struct wpabuf *req = NULL;
+ BIGNUM *x = NULL, *y = NULL;
+ HMAC_CTX ctx;
+ u8 conf[SHA256_DIGEST_LENGTH], *cruft = NULL, *ptr;
+ u16 grp;
+
+ wpa_printf(MSG_DEBUG, "EAP-pwd: Confirm/Request");
+
+ /* Each component of the cruft will be at most as big as the prime */
+ if (((cruft = os_malloc(BN_num_bytes(data->grp->prime))) == NULL) ||
+ ((x = BN_new()) == NULL) || ((y = BN_new()) == NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): debug allocation "
+ "fail");
+ goto fin;
+ }
+
+ /*
+ * commit is H(k | server_element | server_scalar | peer_element |
+ * peer_scalar | ciphersuite)
+ */
+ H_Init(&ctx);
+
+ /*
+ * Zero the memory each time because this is mod prime math and some
+ * value may start with a few zeros and the previous one did not.
+ *
+ * First is k
+ */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(data->k, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+
+ /* server element: x, y */
+ if (!EC_POINT_get_affine_coordinates_GFp(data->grp->group,
+ data->my_element, x, y,
+ data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): confirm point "
+ "assignment fail");
+ goto fin;
+ }
+
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(x, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(y, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+
+ /* server scalar */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(data->my_scalar, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->order));
+
+ /* peer element: x, y */
+ if (!EC_POINT_get_affine_coordinates_GFp(data->grp->group,
+ data->peer_element, x, y,
+ data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): confirm point "
+ "assignment fail");
+ goto fin;
+ }
+
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(x, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(y, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+
+ /* peer scalar */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(data->peer_scalar, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->order));
+
+ /* ciphersuite */
+ grp = htons(data->group_num);
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ ptr = cruft;
+ os_memcpy(ptr, &grp, sizeof(u16));
+ ptr += sizeof(u16);
+ *ptr = EAP_PWD_DEFAULT_RAND_FUNC;
+ ptr += sizeof(u8);
+ *ptr = EAP_PWD_DEFAULT_PRF;
+ ptr += sizeof(u8);
+ H_Update(&ctx, cruft, ptr-cruft);
+
+ /* all done with the random function */
+ H_Final(&ctx, conf);
+ os_memcpy(data->my_confirm, conf, SHA256_DIGEST_LENGTH);
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_PWD,
+ sizeof(struct eap_pwd_hdr) + SHA256_DIGEST_LENGTH,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL)
+ goto fin;
+
+ wpabuf_put_u8(req, EAP_PWD_OPCODE_CONFIRM_EXCH);
+ wpabuf_put_data(req, conf, SHA256_DIGEST_LENGTH);
+
+fin:
+ os_free(cruft);
+ BN_free(x);
+ BN_free(y);
+ if (req == NULL)
+ eap_pwd_state(data, FAILURE);
+
+ return req;
+}
+
+
+static struct wpabuf *
+eap_pwd_build_req(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_pwd_data *data = priv;
+
+ switch (data->state) {
+ case PWD_ID_Req:
+ return eap_pwd_build_id_req(sm, data, id);
+ case PWD_Commit_Req:
+ return eap_pwd_build_commit_req(sm, data, id);
+ case PWD_Confirm_Req:
+ return eap_pwd_build_confirm_req(sm, data, id);
+ default:
+ wpa_printf(MSG_INFO, "EAP-pwd: Unknown state %d in build_req",
+ data->state);
+ break;
+ }
+
+ return NULL;
+}
+
+
+static Boolean eap_pwd_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_pwd_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PWD, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-pwd: Invalid frame");
+ return TRUE;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-pwd: Received frame: opcode=%d", *pos);
+
+ if (data->state == PWD_ID_Req && *pos == EAP_PWD_OPCODE_ID_EXCH)
+ return FALSE;
+
+ if (data->state == PWD_Commit_Req &&
+ *pos == EAP_PWD_OPCODE_COMMIT_EXCH)
+ return FALSE;
+
+ if (data->state == PWD_Confirm_Req &&
+ *pos == EAP_PWD_OPCODE_CONFIRM_EXCH)
+ return FALSE;
+
+ wpa_printf(MSG_INFO, "EAP-pwd: Unexpected opcode=%d in state=%d",
+ *pos, data->state);
+
+ return TRUE;
+}
+
+
+static void eap_pwd_process_id_resp(struct eap_sm *sm,
+ struct eap_pwd_data *data,
+ const u8 *payload, size_t payload_len)
+{
+ struct eap_pwd_id *id;
+
+ if (payload_len < sizeof(struct eap_pwd_id)) {
+ wpa_printf(MSG_INFO, "EAP-pwd: Invalid ID response");
+ return;
+ }
+
+ id = (struct eap_pwd_id *) payload;
+ if ((data->group_num != be_to_host16(id->group_num)) ||
+ (id->random_function != EAP_PWD_DEFAULT_RAND_FUNC) ||
+ (os_memcmp(id->token, (u8 *)&data->token, sizeof(data->token))) ||
+ (id->prf != EAP_PWD_DEFAULT_PRF)) {
+ wpa_printf(MSG_INFO, "EAP-pwd: peer changed parameters");
+ eap_pwd_state(data, FAILURE);
+ return;
+ }
+ data->id_peer = os_malloc(payload_len - sizeof(struct eap_pwd_id));
+ if (data->id_peer == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PWD: memory allocation id fail");
+ return;
+ }
+ data->id_peer_len = payload_len - sizeof(struct eap_pwd_id);
+ os_memcpy(data->id_peer, id->identity, data->id_peer_len);
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-PWD (server): peer sent id of",
+ data->id_peer, data->id_peer_len);
+
+ if ((data->grp = os_malloc(sizeof(EAP_PWD_group))) == NULL) {
+ wpa_printf(MSG_INFO, "EAP-PWD: failed to allocate memory for "
+ "group");
+ return;
+ }
+ if (compute_password_element(data->grp, data->group_num,
+ data->password, data->password_len,
+ data->id_server, data->id_server_len,
+ data->id_peer, data->id_peer_len,
+ (u8 *) &data->token)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): unable to compute "
+ "PWE");
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-PWD (server): computed %d bit PWE...",
+ BN_num_bits(data->grp->prime));
+
+ eap_pwd_state(data, PWD_Commit_Req);
+}
+
+
+static void
+eap_pwd_process_commit_resp(struct eap_sm *sm, struct eap_pwd_data *data,
+ const u8 *payload, size_t payload_len)
+{
+ u8 *ptr;
+ BIGNUM *x = NULL, *y = NULL, *cofactor = NULL;
+ EC_POINT *K = NULL, *point = NULL;
+ int res = 0;
+
+ wpa_printf(MSG_DEBUG, "EAP-pwd: Received commit response");
+
+ if (((data->peer_scalar = BN_new()) == NULL) ||
+ ((data->k = BN_new()) == NULL) ||
+ ((cofactor = BN_new()) == NULL) ||
+ ((x = BN_new()) == NULL) ||
+ ((y = BN_new()) == NULL) ||
+ ((point = EC_POINT_new(data->grp->group)) == NULL) ||
+ ((K = EC_POINT_new(data->grp->group)) == NULL) ||
+ ((data->peer_element = EC_POINT_new(data->grp->group)) == NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): peer data allocation "
+ "fail");
+ goto fin;
+ }
+
+ if (!EC_GROUP_get_cofactor(data->grp->group, cofactor, NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): unable to get "
+ "cofactor for curve");
+ goto fin;
+ }
+
+ /* element, x then y, followed by scalar */
+ ptr = (u8 *) payload;
+ BN_bin2bn(ptr, BN_num_bytes(data->grp->prime), x);
+ ptr += BN_num_bytes(data->grp->prime);
+ BN_bin2bn(ptr, BN_num_bytes(data->grp->prime), y);
+ ptr += BN_num_bytes(data->grp->prime);
+ BN_bin2bn(ptr, BN_num_bytes(data->grp->order), data->peer_scalar);
+ if (!EC_POINT_set_affine_coordinates_GFp(data->grp->group,
+ data->peer_element, x, y,
+ data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): setting peer element "
+ "fail");
+ goto fin;
+ }
+
+ /* check to ensure peer's element is not in a small sub-group */
+ if (BN_cmp(cofactor, BN_value_one())) {
+ if (!EC_POINT_mul(data->grp->group, point, NULL,
+ data->peer_element, cofactor, NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): cannot "
+ "multiply peer element by order");
+ goto fin;
+ }
+ if (EC_POINT_is_at_infinity(data->grp->group, point)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): peer element "
+ "is at infinity!\n");
+ goto fin;
+ }
+ }
+
+ /* compute the shared key, k */
+ if ((!EC_POINT_mul(data->grp->group, K, NULL, data->grp->pwe,
+ data->peer_scalar, data->bnctx)) ||
+ (!EC_POINT_add(data->grp->group, K, K, data->peer_element,
+ data->bnctx)) ||
+ (!EC_POINT_mul(data->grp->group, K, NULL, K, data->private_value,
+ data->bnctx))) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): computing shared key "
+ "fail");
+ goto fin;
+ }
+
+ /* ensure that the shared key isn't in a small sub-group */
+ if (BN_cmp(cofactor, BN_value_one())) {
+ if (!EC_POINT_mul(data->grp->group, K, NULL, K, cofactor,
+ NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): cannot "
+ "multiply shared key point by order!\n");
+ goto fin;
+ }
+ }
+
+ /*
+ * This check is strictly speaking just for the case above where
+ * co-factor > 1 but it was suggested that even though this is probably
+ * never going to happen it is a simple and safe check "just to be
+ * sure" so let's be safe.
+ */
+ if (EC_POINT_is_at_infinity(data->grp->group, K)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): shared key point is "
+ "at infinity");
+ goto fin;
+ }
+ if (!EC_POINT_get_affine_coordinates_GFp(data->grp->group, K, data->k,
+ NULL, data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): unable to extract "
+ "shared secret from secret point");
+ goto fin;
+ }
+ res = 1;
+
+fin:
+ EC_POINT_free(K);
+ EC_POINT_free(point);
+ BN_free(cofactor);
+ BN_free(x);
+ BN_free(y);
+
+ if (res)
+ eap_pwd_state(data, PWD_Confirm_Req);
+ else
+ eap_pwd_state(data, FAILURE);
+}
+
+
+static void
+eap_pwd_process_confirm_resp(struct eap_sm *sm, struct eap_pwd_data *data,
+ const u8 *payload, size_t payload_len)
+{
+ BIGNUM *x = NULL, *y = NULL;
+ HMAC_CTX ctx;
+ u32 cs;
+ u16 grp;
+ u8 conf[SHA256_DIGEST_LENGTH], *cruft = NULL, *ptr;
+
+ /* build up the ciphersuite: group | random_function | prf */
+ grp = htons(data->group_num);
+ ptr = (u8 *) &cs;
+ os_memcpy(ptr, &grp, sizeof(u16));
+ ptr += sizeof(u16);
+ *ptr = EAP_PWD_DEFAULT_RAND_FUNC;
+ ptr += sizeof(u8);
+ *ptr = EAP_PWD_DEFAULT_PRF;
+
+ /* each component of the cruft will be at most as big as the prime */
+ if (((cruft = os_malloc(BN_num_bytes(data->grp->prime))) == NULL) ||
+ ((x = BN_new()) == NULL) || ((y = BN_new()) == NULL)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (peer): allocation fail");
+ goto fin;
+ }
+
+ /*
+ * commit is H(k | peer_element | peer_scalar | server_element |
+ * server_scalar | ciphersuite)
+ */
+ H_Init(&ctx);
+
+ /* k */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(data->k, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+
+ /* peer element: x, y */
+ if (!EC_POINT_get_affine_coordinates_GFp(data->grp->group,
+ data->peer_element, x, y,
+ data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): confirm point "
+ "assignment fail");
+ goto fin;
+ }
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(x, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(y, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+
+ /* peer scalar */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(data->peer_scalar, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->order));
+
+ /* server element: x, y */
+ if (!EC_POINT_get_affine_coordinates_GFp(data->grp->group,
+ data->my_element, x, y,
+ data->bnctx)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): confirm point "
+ "assignment fail");
+ goto fin;
+ }
+
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(x, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(y, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->prime));
+
+ /* server scalar */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ BN_bn2bin(data->my_scalar, cruft);
+ H_Update(&ctx, cruft, BN_num_bytes(data->grp->order));
+
+ /* ciphersuite */
+ os_memset(cruft, 0, BN_num_bytes(data->grp->prime));
+ H_Update(&ctx, (u8 *)&cs, sizeof(u32));
+
+ /* all done */
+ H_Final(&ctx, conf);
+
+ ptr = (u8 *) payload;
+ if (os_memcmp(conf, ptr, SHA256_DIGEST_LENGTH)) {
+ wpa_printf(MSG_INFO, "EAP-PWD (server): confirm did not "
+ "verify");
+ goto fin;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-pwd (server): confirm verified");
+ if (compute_keys(data->grp, data->bnctx, data->k,
+ data->peer_scalar, data->my_scalar, conf,
+ data->my_confirm, &cs, data->msk, data->emsk) < 0)
+ eap_pwd_state(data, FAILURE);
+ else
+ eap_pwd_state(data, SUCCESS);
+
+fin:
+ os_free(cruft);
+ BN_free(x);
+ BN_free(y);
+}
+
+
+static void eap_pwd_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_pwd_data *data = priv;
+ const u8 *pos;
+ size_t len;
+ u8 exch;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_PWD, respData, &len);
+ if ((pos == NULL) || (len < 1)) {
+ wpa_printf(MSG_INFO, "Bad EAP header! pos %s and len = %d",
+ (pos == NULL) ? "is NULL" : "is not NULL",
+ (int) len);
+ return;
+ }
+
+ exch = *pos & 0x3f;
+ switch (exch) {
+ case EAP_PWD_OPCODE_ID_EXCH:
+ eap_pwd_process_id_resp(sm, data, pos + 1, len - 1);
+ break;
+ case EAP_PWD_OPCODE_COMMIT_EXCH:
+ eap_pwd_process_commit_resp(sm, data, pos + 1, len - 1);
+ break;
+ case EAP_PWD_OPCODE_CONFIRM_EXCH:
+ eap_pwd_process_confirm_resp(sm, data, pos + 1, len - 1);
+ break;
+ }
+}
+
+
+static u8 * eap_pwd_getkey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_pwd_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_MSK_LEN);
+ if (key == NULL)
+ return NULL;
+
+ os_memcpy(key, data->msk, EAP_MSK_LEN);
+ *len = EAP_MSK_LEN;
+
+ return key;
+}
+
+
+static u8 * eap_pwd_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_pwd_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+
+ os_memcpy(key, data->emsk, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+
+ return key;
+}
+
+
+static Boolean eap_pwd_is_success(struct eap_sm *sm, void *priv)
+{
+ struct eap_pwd_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+static Boolean eap_pwd_is_done(struct eap_sm *sm, void *priv)
+{
+ struct eap_pwd_data *data = priv;
+ return (data->state == SUCCESS) || (data->state == FAILURE);
+}
+
+
+int eap_server_pwd_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+ struct timeval tp;
+ struct timezone tz;
+ u32 sr;
+
+ EVP_add_digest(EVP_sha256());
+
+ sr = 0xdeaddada;
+ (void) gettimeofday(&tp, &tz);
+ sr ^= (tp.tv_sec ^ tp.tv_usec);
+ srandom(sr);
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_PWD,
+ "PWD");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_pwd_init;
+ eap->reset = eap_pwd_reset;
+ eap->buildReq = eap_pwd_build_req;
+ eap->check = eap_pwd_check;
+ eap->process = eap_pwd_process;
+ eap->isDone = eap_pwd_is_done;
+ eap->getKey = eap_pwd_getkey;
+ eap->get_emsk = eap_pwd_get_emsk;
+ eap->isSuccess = eap_pwd_is_success;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
+
diff --git a/src/eap_server/eap_server_sake.c b/src/eap_server/eap_server_sake.c
new file mode 100644
index 0000000..a9b515f
--- /dev/null
+++ b/src/eap_server/eap_server_sake.c
@@ -0,0 +1,543 @@
+/*
+ * hostapd / EAP-SAKE (RFC 4763) server
+ * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/random.h"
+#include "eap_server/eap_i.h"
+#include "eap_common/eap_sake_common.h"
+
+
+struct eap_sake_data {
+ enum { IDENTITY, CHALLENGE, CONFIRM, SUCCESS, FAILURE } state;
+ u8 rand_s[EAP_SAKE_RAND_LEN];
+ u8 rand_p[EAP_SAKE_RAND_LEN];
+ struct {
+ u8 auth[EAP_SAKE_TEK_AUTH_LEN];
+ u8 cipher[EAP_SAKE_TEK_CIPHER_LEN];
+ } tek;
+ u8 msk[EAP_MSK_LEN];
+ u8 emsk[EAP_EMSK_LEN];
+ u8 session_id;
+ u8 *peerid;
+ size_t peerid_len;
+ u8 *serverid;
+ size_t serverid_len;
+};
+
+
+static const char * eap_sake_state_txt(int state)
+{
+ switch (state) {
+ case IDENTITY:
+ return "IDENTITY";
+ case CHALLENGE:
+ return "CHALLENGE";
+ case CONFIRM:
+ return "CONFIRM";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "?";
+ }
+}
+
+
+static void eap_sake_state(struct eap_sake_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: %s -> %s",
+ eap_sake_state_txt(data->state),
+ eap_sake_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_sake_init(struct eap_sm *sm)
+{
+ struct eap_sake_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = CHALLENGE;
+
+ if (os_get_random(&data->session_id, 1)) {
+ wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to get random data");
+ os_free(data);
+ return NULL;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Initialized Session ID %d",
+ data->session_id);
+
+ /* TODO: add support for configuring SERVERID */
+ data->serverid = (u8 *) os_strdup("hostapd");
+ if (data->serverid)
+ data->serverid_len = os_strlen((char *) data->serverid);
+
+ return data;
+}
+
+
+static void eap_sake_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_sake_data *data = priv;
+ os_free(data->serverid);
+ os_free(data->peerid);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_sake_build_msg(struct eap_sake_data *data,
+ u8 id, size_t length, u8 subtype)
+{
+ struct eap_sake_hdr *sake;
+ struct wpabuf *msg;
+ size_t plen;
+
+ plen = sizeof(struct eap_sake_hdr) + length;
+
+ msg = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_SAKE, plen,
+ EAP_CODE_REQUEST, id);
+ if (msg == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to allocate memory "
+ "request");
+ return NULL;
+ }
+
+ sake = wpabuf_put(msg, sizeof(*sake));
+ sake->version = EAP_SAKE_VERSION;
+ sake->session_id = data->session_id;
+ sake->subtype = subtype;
+
+ return msg;
+}
+
+
+static struct wpabuf * eap_sake_build_identity(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ u8 id)
+{
+ struct wpabuf *msg;
+ size_t plen;
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Identity");
+
+ plen = 4;
+ if (data->serverid)
+ plen += 2 + data->serverid_len;
+ msg = eap_sake_build_msg(data, id, plen, EAP_SAKE_SUBTYPE_IDENTITY);
+ if (msg == NULL) {
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_PERM_ID_REQ");
+ eap_sake_add_attr(msg, EAP_SAKE_AT_PERM_ID_REQ, NULL, 2);
+
+ if (data->serverid) {
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_SERVERID");
+ eap_sake_add_attr(msg, EAP_SAKE_AT_SERVERID,
+ data->serverid, data->serverid_len);
+ }
+
+ return msg;
+}
+
+
+static struct wpabuf * eap_sake_build_challenge(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ u8 id)
+{
+ struct wpabuf *msg;
+ size_t plen;
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Challenge");
+
+ if (random_get_bytes(data->rand_s, EAP_SAKE_RAND_LEN)) {
+ wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to get random data");
+ data->state = FAILURE;
+ return NULL;
+ }
+ wpa_hexdump(MSG_MSGDUMP, "EAP-SAKE: RAND_S (server rand)",
+ data->rand_s, EAP_SAKE_RAND_LEN);
+
+ plen = 2 + EAP_SAKE_RAND_LEN;
+ if (data->serverid)
+ plen += 2 + data->serverid_len;
+ msg = eap_sake_build_msg(data, id, plen, EAP_SAKE_SUBTYPE_CHALLENGE);
+ if (msg == NULL) {
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_RAND_S");
+ eap_sake_add_attr(msg, EAP_SAKE_AT_RAND_S,
+ data->rand_s, EAP_SAKE_RAND_LEN);
+
+ if (data->serverid) {
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_SERVERID");
+ eap_sake_add_attr(msg, EAP_SAKE_AT_SERVERID,
+ data->serverid, data->serverid_len);
+ }
+
+ return msg;
+}
+
+
+static struct wpabuf * eap_sake_build_confirm(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ u8 id)
+{
+ struct wpabuf *msg;
+ u8 *mic;
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Confirm");
+
+ msg = eap_sake_build_msg(data, id, 2 + EAP_SAKE_MIC_LEN,
+ EAP_SAKE_SUBTYPE_CONFIRM);
+ if (msg == NULL) {
+ data->state = FAILURE;
+ return NULL;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_MIC_S");
+ wpabuf_put_u8(msg, EAP_SAKE_AT_MIC_S);
+ wpabuf_put_u8(msg, 2 + EAP_SAKE_MIC_LEN);
+ mic = wpabuf_put(msg, EAP_SAKE_MIC_LEN);
+ if (eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
+ data->serverid, data->serverid_len,
+ data->peerid, data->peerid_len, 0,
+ wpabuf_head(msg), wpabuf_len(msg), mic, mic))
+ {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Failed to compute MIC");
+ data->state = FAILURE;
+ os_free(msg);
+ return NULL;
+ }
+
+ return msg;
+}
+
+
+static struct wpabuf * eap_sake_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_sake_data *data = priv;
+
+ switch (data->state) {
+ case IDENTITY:
+ return eap_sake_build_identity(sm, data, id);
+ case CHALLENGE:
+ return eap_sake_build_challenge(sm, data, id);
+ case CONFIRM:
+ return eap_sake_build_confirm(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Unknown state %d in buildReq",
+ data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_sake_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_sake_data *data = priv;
+ struct eap_sake_hdr *resp;
+ size_t len;
+ u8 version, session_id, subtype;
+ const u8 *pos;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SAKE, respData, &len);
+ if (pos == NULL || len < sizeof(struct eap_sake_hdr)) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Invalid frame");
+ return TRUE;
+ }
+
+ resp = (struct eap_sake_hdr *) pos;
+ version = resp->version;
+ session_id = resp->session_id;
+ subtype = resp->subtype;
+
+ if (version != EAP_SAKE_VERSION) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Unknown version %d", version);
+ return TRUE;
+ }
+
+ if (session_id != data->session_id) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Session ID mismatch (%d,%d)",
+ session_id, data->session_id);
+ return TRUE;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Received frame: subtype=%d", subtype);
+
+ if (data->state == IDENTITY && subtype == EAP_SAKE_SUBTYPE_IDENTITY)
+ return FALSE;
+
+ if (data->state == CHALLENGE && subtype == EAP_SAKE_SUBTYPE_CHALLENGE)
+ return FALSE;
+
+ if (data->state == CONFIRM && subtype == EAP_SAKE_SUBTYPE_CONFIRM)
+ return FALSE;
+
+ if (subtype == EAP_SAKE_SUBTYPE_AUTH_REJECT)
+ return FALSE;
+
+ wpa_printf(MSG_INFO, "EAP-SAKE: Unexpected subtype=%d in state=%d",
+ subtype, data->state);
+
+ return TRUE;
+}
+
+
+static void eap_sake_process_identity(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ const struct wpabuf *respData,
+ const u8 *payload, size_t payloadlen)
+{
+ if (data->state != IDENTITY)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Identity");
+ /* TODO: update identity and select new user data */
+ eap_sake_state(data, CHALLENGE);
+}
+
+
+static void eap_sake_process_challenge(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ const struct wpabuf *respData,
+ const u8 *payload, size_t payloadlen)
+{
+ struct eap_sake_parse_attr attr;
+ u8 mic_p[EAP_SAKE_MIC_LEN];
+
+ if (data->state != CHALLENGE)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Challenge");
+
+ if (eap_sake_parse_attributes(payload, payloadlen, &attr))
+ return;
+
+ if (!attr.rand_p || !attr.mic_p) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Response/Challenge did not "
+ "include AT_RAND_P or AT_MIC_P");
+ return;
+ }
+
+ os_memcpy(data->rand_p, attr.rand_p, EAP_SAKE_RAND_LEN);
+
+ os_free(data->peerid);
+ data->peerid = NULL;
+ data->peerid_len = 0;
+ if (attr.peerid) {
+ data->peerid = os_malloc(attr.peerid_len);
+ if (data->peerid == NULL)
+ return;
+ os_memcpy(data->peerid, attr.peerid, attr.peerid_len);
+ data->peerid_len = attr.peerid_len;
+ }
+
+ if (sm->user == NULL || sm->user->password == NULL ||
+ sm->user->password_len != 2 * EAP_SAKE_ROOT_SECRET_LEN) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Plaintext password with "
+ "%d-byte key not configured",
+ 2 * EAP_SAKE_ROOT_SECRET_LEN);
+ data->state = FAILURE;
+ return;
+ }
+ eap_sake_derive_keys(sm->user->password,
+ sm->user->password + EAP_SAKE_ROOT_SECRET_LEN,
+ data->rand_s, data->rand_p,
+ (u8 *) &data->tek, data->msk, data->emsk);
+
+ eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
+ data->serverid, data->serverid_len,
+ data->peerid, data->peerid_len, 1,
+ wpabuf_head(respData), wpabuf_len(respData),
+ attr.mic_p, mic_p);
+ if (os_memcmp(attr.mic_p, mic_p, EAP_SAKE_MIC_LEN) != 0) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Incorrect AT_MIC_P");
+ eap_sake_state(data, FAILURE);
+ return;
+ }
+
+ eap_sake_state(data, CONFIRM);
+}
+
+
+static void eap_sake_process_confirm(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ const struct wpabuf *respData,
+ const u8 *payload, size_t payloadlen)
+{
+ struct eap_sake_parse_attr attr;
+ u8 mic_p[EAP_SAKE_MIC_LEN];
+
+ if (data->state != CONFIRM)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Confirm");
+
+ if (eap_sake_parse_attributes(payload, payloadlen, &attr))
+ return;
+
+ if (!attr.mic_p) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Response/Confirm did not "
+ "include AT_MIC_P");
+ return;
+ }
+
+ eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
+ data->serverid, data->serverid_len,
+ data->peerid, data->peerid_len, 1,
+ wpabuf_head(respData), wpabuf_len(respData),
+ attr.mic_p, mic_p);
+ if (os_memcmp(attr.mic_p, mic_p, EAP_SAKE_MIC_LEN) != 0) {
+ wpa_printf(MSG_INFO, "EAP-SAKE: Incorrect AT_MIC_P");
+ eap_sake_state(data, FAILURE);
+ } else
+ eap_sake_state(data, SUCCESS);
+}
+
+
+static void eap_sake_process_auth_reject(struct eap_sm *sm,
+ struct eap_sake_data *data,
+ const struct wpabuf *respData,
+ const u8 *payload, size_t payloadlen)
+{
+ wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Auth-Reject");
+ eap_sake_state(data, FAILURE);
+}
+
+
+static void eap_sake_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_sake_data *data = priv;
+ struct eap_sake_hdr *resp;
+ u8 subtype;
+ size_t len;
+ const u8 *pos, *end;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SAKE, respData, &len);
+ if (pos == NULL || len < sizeof(struct eap_sake_hdr))
+ return;
+
+ resp = (struct eap_sake_hdr *) pos;
+ end = pos + len;
+ subtype = resp->subtype;
+ pos = (u8 *) (resp + 1);
+
+ wpa_hexdump(MSG_DEBUG, "EAP-SAKE: Received attributes",
+ pos, end - pos);
+
+ switch (subtype) {
+ case EAP_SAKE_SUBTYPE_IDENTITY:
+ eap_sake_process_identity(sm, data, respData, pos, end - pos);
+ break;
+ case EAP_SAKE_SUBTYPE_CHALLENGE:
+ eap_sake_process_challenge(sm, data, respData, pos, end - pos);
+ break;
+ case EAP_SAKE_SUBTYPE_CONFIRM:
+ eap_sake_process_confirm(sm, data, respData, pos, end - pos);
+ break;
+ case EAP_SAKE_SUBTYPE_AUTH_REJECT:
+ eap_sake_process_auth_reject(sm, data, respData, pos,
+ end - pos);
+ break;
+ }
+}
+
+
+static Boolean eap_sake_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_sake_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_sake_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_sake_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_MSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->msk, EAP_MSK_LEN);
+ *len = EAP_MSK_LEN;
+
+ return key;
+}
+
+
+static u8 * eap_sake_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_sake_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->emsk, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+
+ return key;
+}
+
+
+static Boolean eap_sake_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_sake_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_sake_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_SAKE, "SAKE");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_sake_init;
+ eap->reset = eap_sake_reset;
+ eap->buildReq = eap_sake_buildReq;
+ eap->check = eap_sake_check;
+ eap->process = eap_sake_process;
+ eap->isDone = eap_sake_isDone;
+ eap->getKey = eap_sake_getKey;
+ eap->isSuccess = eap_sake_isSuccess;
+ eap->get_emsk = eap_sake_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_sim.c b/src/eap_server/eap_server_sim.c
new file mode 100644
index 0000000..29df2ff
--- /dev/null
+++ b/src/eap_server/eap_server_sim.c
@@ -0,0 +1,798 @@
+/*
+ * hostapd / EAP-SIM (RFC 4186)
+ * Copyright (c) 2005-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/random.h"
+#include "eap_server/eap_i.h"
+#include "eap_common/eap_sim_common.h"
+#include "eap_server/eap_sim_db.h"
+
+
+struct eap_sim_data {
+ u8 mk[EAP_SIM_MK_LEN];
+ u8 nonce_mt[EAP_SIM_NONCE_MT_LEN];
+ u8 nonce_s[EAP_SIM_NONCE_S_LEN];
+ u8 k_aut[EAP_SIM_K_AUT_LEN];
+ u8 k_encr[EAP_SIM_K_ENCR_LEN];
+ u8 msk[EAP_SIM_KEYING_DATA_LEN];
+ u8 emsk[EAP_EMSK_LEN];
+ u8 kc[EAP_SIM_MAX_CHAL][EAP_SIM_KC_LEN];
+ u8 sres[EAP_SIM_MAX_CHAL][EAP_SIM_SRES_LEN];
+ u8 rand[EAP_SIM_MAX_CHAL][GSM_RAND_LEN];
+ int num_chal;
+ enum {
+ START, CHALLENGE, REAUTH, NOTIFICATION, SUCCESS, FAILURE
+ } state;
+ char *next_pseudonym;
+ char *next_reauth_id;
+ u16 counter;
+ struct eap_sim_reauth *reauth;
+ u16 notification;
+ int use_result_ind;
+};
+
+
+static const char * eap_sim_state_txt(int state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case CHALLENGE:
+ return "CHALLENGE";
+ case REAUTH:
+ return "REAUTH";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ case NOTIFICATION:
+ return "NOTIFICATION";
+ default:
+ return "Unknown?!";
+ }
+}
+
+
+static void eap_sim_state(struct eap_sim_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-SIM: %s -> %s",
+ eap_sim_state_txt(data->state),
+ eap_sim_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_sim_init(struct eap_sm *sm)
+{
+ struct eap_sim_data *data;
+
+ if (sm->eap_sim_db_priv == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: eap_sim_db not configured");
+ return NULL;
+ }
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = START;
+
+ return data;
+}
+
+
+static void eap_sim_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_sim_data *data = priv;
+ os_free(data->next_pseudonym);
+ os_free(data->next_reauth_id);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_sim_build_start(struct eap_sm *sm,
+ struct eap_sim_data *data, u8 id)
+{
+ struct eap_sim_msg *msg;
+ u8 ver[2];
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Start");
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
+ EAP_SIM_SUBTYPE_START);
+ if (eap_sim_db_identity_known(sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len)) {
+ wpa_printf(MSG_DEBUG, " AT_PERMANENT_ID_REQ");
+ eap_sim_msg_add(msg, EAP_SIM_AT_PERMANENT_ID_REQ, 0, NULL, 0);
+ } else {
+ /*
+ * RFC 4186, Chap. 4.2.4 recommends that identity from EAP is
+ * ignored and the SIM/Start is used to request the identity.
+ */
+ wpa_printf(MSG_DEBUG, " AT_ANY_ID_REQ");
+ eap_sim_msg_add(msg, EAP_SIM_AT_ANY_ID_REQ, 0, NULL, 0);
+ }
+ wpa_printf(MSG_DEBUG, " AT_VERSION_LIST");
+ ver[0] = 0;
+ ver[1] = EAP_SIM_VERSION;
+ eap_sim_msg_add(msg, EAP_SIM_AT_VERSION_LIST, sizeof(ver),
+ ver, sizeof(ver));
+ return eap_sim_msg_finish(msg, NULL, NULL, 0);
+}
+
+
+static int eap_sim_build_encr(struct eap_sm *sm, struct eap_sim_data *data,
+ struct eap_sim_msg *msg, u16 counter,
+ const u8 *nonce_s)
+{
+ os_free(data->next_pseudonym);
+ data->next_pseudonym =
+ eap_sim_db_get_next_pseudonym(sm->eap_sim_db_priv, 0);
+ os_free(data->next_reauth_id);
+ if (data->counter <= EAP_SIM_MAX_FAST_REAUTHS) {
+ data->next_reauth_id =
+ eap_sim_db_get_next_reauth_id(sm->eap_sim_db_priv, 0);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Max fast re-authentication "
+ "count exceeded - force full authentication");
+ data->next_reauth_id = NULL;
+ }
+
+ if (data->next_pseudonym == NULL && data->next_reauth_id == NULL &&
+ counter == 0 && nonce_s == NULL)
+ return 0;
+
+ wpa_printf(MSG_DEBUG, " AT_IV");
+ wpa_printf(MSG_DEBUG, " AT_ENCR_DATA");
+ eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, EAP_SIM_AT_ENCR_DATA);
+
+ if (counter > 0) {
+ wpa_printf(MSG_DEBUG, " *AT_COUNTER (%u)", counter);
+ eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, counter, NULL, 0);
+ }
+
+ if (nonce_s) {
+ wpa_printf(MSG_DEBUG, " *AT_NONCE_S");
+ eap_sim_msg_add(msg, EAP_SIM_AT_NONCE_S, 0, nonce_s,
+ EAP_SIM_NONCE_S_LEN);
+ }
+
+ if (data->next_pseudonym) {
+ wpa_printf(MSG_DEBUG, " *AT_NEXT_PSEUDONYM (%s)",
+ data->next_pseudonym);
+ eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_PSEUDONYM,
+ os_strlen(data->next_pseudonym),
+ (u8 *) data->next_pseudonym,
+ os_strlen(data->next_pseudonym));
+ }
+
+ if (data->next_reauth_id) {
+ wpa_printf(MSG_DEBUG, " *AT_NEXT_REAUTH_ID (%s)",
+ data->next_reauth_id);
+ eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_REAUTH_ID,
+ os_strlen(data->next_reauth_id),
+ (u8 *) data->next_reauth_id,
+ os_strlen(data->next_reauth_id));
+ }
+
+ if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Failed to encrypt "
+ "AT_ENCR_DATA");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static struct wpabuf * eap_sim_build_challenge(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ u8 id)
+{
+ struct eap_sim_msg *msg;
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Challenge");
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
+ EAP_SIM_SUBTYPE_CHALLENGE);
+ wpa_printf(MSG_DEBUG, " AT_RAND");
+ eap_sim_msg_add(msg, EAP_SIM_AT_RAND, 0, (u8 *) data->rand,
+ data->num_chal * GSM_RAND_LEN);
+
+ if (eap_sim_build_encr(sm, data, msg, 0, NULL)) {
+ eap_sim_msg_free(msg);
+ return NULL;
+ }
+
+ if (sm->eap_sim_aka_result_ind) {
+ wpa_printf(MSG_DEBUG, " AT_RESULT_IND");
+ eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
+ }
+
+ wpa_printf(MSG_DEBUG, " AT_MAC");
+ eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
+ return eap_sim_msg_finish(msg, data->k_aut, data->nonce_mt,
+ EAP_SIM_NONCE_MT_LEN);
+}
+
+
+static struct wpabuf * eap_sim_build_reauth(struct eap_sm *sm,
+ struct eap_sim_data *data, u8 id)
+{
+ struct eap_sim_msg *msg;
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Re-authentication");
+
+ if (random_get_bytes(data->nonce_s, EAP_SIM_NONCE_S_LEN))
+ return NULL;
+ wpa_hexdump_key(MSG_MSGDUMP, "EAP-SIM: NONCE_S",
+ data->nonce_s, EAP_SIM_NONCE_S_LEN);
+
+ eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
+ data->emsk);
+ eap_sim_derive_keys_reauth(data->counter, sm->identity,
+ sm->identity_len, data->nonce_s, data->mk,
+ data->msk, data->emsk);
+
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
+ EAP_SIM_SUBTYPE_REAUTHENTICATION);
+
+ if (eap_sim_build_encr(sm, data, msg, data->counter, data->nonce_s)) {
+ eap_sim_msg_free(msg);
+ return NULL;
+ }
+
+ if (sm->eap_sim_aka_result_ind) {
+ wpa_printf(MSG_DEBUG, " AT_RESULT_IND");
+ eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
+ }
+
+ wpa_printf(MSG_DEBUG, " AT_MAC");
+ eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
+ return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
+}
+
+
+static struct wpabuf * eap_sim_build_notification(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ u8 id)
+{
+ struct eap_sim_msg *msg;
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Notification");
+ msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
+ EAP_SIM_SUBTYPE_NOTIFICATION);
+ wpa_printf(MSG_DEBUG, " AT_NOTIFICATION (%d)", data->notification);
+ eap_sim_msg_add(msg, EAP_SIM_AT_NOTIFICATION, data->notification,
+ NULL, 0);
+ if (data->use_result_ind) {
+ if (data->reauth) {
+ wpa_printf(MSG_DEBUG, " AT_IV");
+ wpa_printf(MSG_DEBUG, " AT_ENCR_DATA");
+ eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV,
+ EAP_SIM_AT_ENCR_DATA);
+ wpa_printf(MSG_DEBUG, " *AT_COUNTER (%u)",
+ data->counter);
+ eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter,
+ NULL, 0);
+
+ if (eap_sim_msg_add_encr_end(msg, data->k_encr,
+ EAP_SIM_AT_PADDING)) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Failed to "
+ "encrypt AT_ENCR_DATA");
+ eap_sim_msg_free(msg);
+ return NULL;
+ }
+ }
+
+ wpa_printf(MSG_DEBUG, " AT_MAC");
+ eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
+ }
+ return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
+}
+
+
+static struct wpabuf * eap_sim_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_sim_data *data = priv;
+
+ switch (data->state) {
+ case START:
+ return eap_sim_build_start(sm, data, id);
+ case CHALLENGE:
+ return eap_sim_build_challenge(sm, data, id);
+ case REAUTH:
+ return eap_sim_build_reauth(sm, data, id);
+ case NOTIFICATION:
+ return eap_sim_build_notification(sm, data, id);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in "
+ "buildReq", data->state);
+ break;
+ }
+ return NULL;
+}
+
+
+static Boolean eap_sim_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_sim_data *data = priv;
+ const u8 *pos;
+ size_t len;
+ u8 subtype;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len);
+ if (pos == NULL || len < 3) {
+ wpa_printf(MSG_INFO, "EAP-SIM: Invalid frame");
+ return TRUE;
+ }
+ subtype = *pos;
+
+ if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR)
+ return FALSE;
+
+ switch (data->state) {
+ case START:
+ if (subtype != EAP_SIM_SUBTYPE_START) {
+ wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ case CHALLENGE:
+ if (subtype != EAP_SIM_SUBTYPE_CHALLENGE) {
+ wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ case REAUTH:
+ if (subtype != EAP_SIM_SUBTYPE_REAUTHENTICATION) {
+ wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ case NOTIFICATION:
+ if (subtype != EAP_SIM_SUBTYPE_NOTIFICATION) {
+ wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
+ "subtype %d", subtype);
+ return TRUE;
+ }
+ break;
+ default:
+ wpa_printf(MSG_INFO, "EAP-SIM: Unexpected state (%d) for "
+ "processing a response", data->state);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static int eap_sim_supported_ver(struct eap_sim_data *data, int version)
+{
+ return version == EAP_SIM_VERSION;
+}
+
+
+static void eap_sim_process_start(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ const u8 *identity;
+ size_t identity_len;
+ u8 ver_list[2];
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Receive start response");
+
+ if (attr->identity) {
+ os_free(sm->identity);
+ sm->identity = os_malloc(attr->identity_len);
+ if (sm->identity) {
+ os_memcpy(sm->identity, attr->identity,
+ attr->identity_len);
+ sm->identity_len = attr->identity_len;
+ }
+ }
+
+ identity = NULL;
+ identity_len = 0;
+
+ if (sm->identity && sm->identity_len > 0 &&
+ sm->identity[0] == EAP_SIM_PERMANENT_PREFIX) {
+ identity = sm->identity;
+ identity_len = sm->identity_len;
+ } else {
+ identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv,
+ sm->identity,
+ sm->identity_len,
+ &identity_len);
+ if (identity == NULL) {
+ data->reauth = eap_sim_db_get_reauth_entry(
+ sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len);
+ if (data->reauth) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Using fast "
+ "re-authentication");
+ identity = data->reauth->identity;
+ identity_len = data->reauth->identity_len;
+ data->counter = data->reauth->counter;
+ os_memcpy(data->mk, data->reauth->mk,
+ EAP_SIM_MK_LEN);
+ }
+ }
+ }
+
+ if (identity == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Could not get proper permanent"
+ " user name");
+ eap_sim_state(data, FAILURE);
+ return;
+ }
+
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity",
+ identity, identity_len);
+
+ if (data->reauth) {
+ eap_sim_state(data, REAUTH);
+ return;
+ }
+
+ if (attr->nonce_mt == NULL || attr->selected_version < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Start/Response missing "
+ "required attributes");
+ eap_sim_state(data, FAILURE);
+ return;
+ }
+
+ if (!eap_sim_supported_ver(data, attr->selected_version)) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Peer selected unsupported "
+ "version %d", attr->selected_version);
+ eap_sim_state(data, FAILURE);
+ return;
+ }
+
+ data->counter = 0; /* reset re-auth counter since this is full auth */
+ data->reauth = NULL;
+
+ data->num_chal = eap_sim_db_get_gsm_triplets(
+ sm->eap_sim_db_priv, identity, identity_len,
+ EAP_SIM_MAX_CHAL,
+ (u8 *) data->rand, (u8 *) data->kc, (u8 *) data->sres, sm);
+ if (data->num_chal == EAP_SIM_DB_PENDING) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: GSM authentication triplets "
+ "not yet available - pending request");
+ sm->method_pending = METHOD_PENDING_WAIT;
+ return;
+ }
+ if (data->num_chal < 2) {
+ wpa_printf(MSG_INFO, "EAP-SIM: Failed to get GSM "
+ "authentication triplets for the peer");
+ eap_sim_state(data, FAILURE);
+ return;
+ }
+
+ identity_len = sm->identity_len;
+ while (identity_len > 0 && sm->identity[identity_len - 1] == '\0') {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Workaround - drop last null "
+ "character from identity");
+ identity_len--;
+ }
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity for MK derivation",
+ sm->identity, identity_len);
+
+ os_memcpy(data->nonce_mt, attr->nonce_mt, EAP_SIM_NONCE_MT_LEN);
+ WPA_PUT_BE16(ver_list, EAP_SIM_VERSION);
+ eap_sim_derive_mk(sm->identity, identity_len, attr->nonce_mt,
+ attr->selected_version, ver_list, sizeof(ver_list),
+ data->num_chal, (const u8 *) data->kc, data->mk);
+ eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
+ data->emsk);
+
+ eap_sim_state(data, CHALLENGE);
+}
+
+
+static void eap_sim_process_challenge(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ const u8 *identity;
+ size_t identity_len;
+
+ if (attr->mac == NULL ||
+ eap_sim_verify_mac(data->k_aut, respData, attr->mac,
+ (u8 *) data->sres,
+ data->num_chal * EAP_SIM_SRES_LEN)) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Challenge message "
+ "did not include valid AT_MAC");
+ eap_sim_state(data, FAILURE);
+ return;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Challenge response includes the "
+ "correct AT_MAC");
+ if (sm->eap_sim_aka_result_ind && attr->result_ind) {
+ data->use_result_ind = 1;
+ data->notification = EAP_SIM_SUCCESS;
+ eap_sim_state(data, NOTIFICATION);
+ } else
+ eap_sim_state(data, SUCCESS);
+
+ identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv, sm->identity,
+ sm->identity_len, &identity_len);
+ if (identity == NULL) {
+ identity = sm->identity;
+ identity_len = sm->identity_len;
+ }
+
+ if (data->next_pseudonym) {
+ eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity,
+ identity_len,
+ data->next_pseudonym);
+ data->next_pseudonym = NULL;
+ }
+ if (data->next_reauth_id) {
+ eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity,
+ identity_len,
+ data->next_reauth_id, data->counter + 1,
+ data->mk);
+ data->next_reauth_id = NULL;
+ }
+}
+
+
+static void eap_sim_process_reauth(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ struct eap_sim_attrs eattr;
+ u8 *decrypted = NULL;
+ const u8 *identity, *id2;
+ size_t identity_len, id2_len;
+
+ if (attr->mac == NULL ||
+ eap_sim_verify_mac(data->k_aut, respData, attr->mac, data->nonce_s,
+ EAP_SIM_NONCE_S_LEN)) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message "
+ "did not include valid AT_MAC");
+ goto fail;
+ }
+
+ if (attr->encr_data == NULL || attr->iv == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Reauthentication "
+ "message did not include encrypted data");
+ goto fail;
+ }
+
+ decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
+ attr->encr_data_len, attr->iv, &eattr,
+ 0);
+ if (decrypted == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Failed to parse encrypted "
+ "data from reauthentication message");
+ goto fail;
+ }
+
+ if (eattr.counter != data->counter) {
+ wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message "
+ "used incorrect counter %u, expected %u",
+ eattr.counter, data->counter);
+ goto fail;
+ }
+ os_free(decrypted);
+ decrypted = NULL;
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Re-authentication response includes "
+ "the correct AT_MAC");
+ if (sm->eap_sim_aka_result_ind && attr->result_ind) {
+ data->use_result_ind = 1;
+ data->notification = EAP_SIM_SUCCESS;
+ eap_sim_state(data, NOTIFICATION);
+ } else
+ eap_sim_state(data, SUCCESS);
+
+ if (data->reauth) {
+ identity = data->reauth->identity;
+ identity_len = data->reauth->identity_len;
+ } else {
+ identity = sm->identity;
+ identity_len = sm->identity_len;
+ }
+
+ id2 = eap_sim_db_get_permanent(sm->eap_sim_db_priv, identity,
+ identity_len, &id2_len);
+ if (id2) {
+ identity = id2;
+ identity_len = id2_len;
+ }
+
+ if (data->next_pseudonym) {
+ eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity,
+ identity_len, data->next_pseudonym);
+ data->next_pseudonym = NULL;
+ }
+ if (data->next_reauth_id) {
+ eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity,
+ identity_len, data->next_reauth_id,
+ data->counter + 1, data->mk);
+ data->next_reauth_id = NULL;
+ } else {
+ eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
+ data->reauth = NULL;
+ }
+
+ return;
+
+fail:
+ eap_sim_state(data, FAILURE);
+ eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
+ data->reauth = NULL;
+ os_free(decrypted);
+}
+
+
+static void eap_sim_process_client_error(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Client reported error %d",
+ attr->client_error_code);
+ if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
+ eap_sim_state(data, SUCCESS);
+ else
+ eap_sim_state(data, FAILURE);
+}
+
+
+static void eap_sim_process_notification(struct eap_sm *sm,
+ struct eap_sim_data *data,
+ struct wpabuf *respData,
+ struct eap_sim_attrs *attr)
+{
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Client replied to notification");
+ if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
+ eap_sim_state(data, SUCCESS);
+ else
+ eap_sim_state(data, FAILURE);
+}
+
+
+static void eap_sim_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_sim_data *data = priv;
+ const u8 *pos, *end;
+ u8 subtype;
+ size_t len;
+ struct eap_sim_attrs attr;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len);
+ if (pos == NULL || len < 3)
+ return;
+
+ end = pos + len;
+ subtype = *pos;
+ pos += 3;
+
+ if (eap_sim_parse_attr(pos, end, &attr, 0, 0)) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Failed to parse attributes");
+ eap_sim_state(data, FAILURE);
+ return;
+ }
+
+ if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR) {
+ eap_sim_process_client_error(sm, data, respData, &attr);
+ return;
+ }
+
+ switch (data->state) {
+ case START:
+ eap_sim_process_start(sm, data, respData, &attr);
+ break;
+ case CHALLENGE:
+ eap_sim_process_challenge(sm, data, respData, &attr);
+ break;
+ case REAUTH:
+ eap_sim_process_reauth(sm, data, respData, &attr);
+ break;
+ case NOTIFICATION:
+ eap_sim_process_notification(sm, data, respData, &attr);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in "
+ "process", data->state);
+ break;
+ }
+}
+
+
+static Boolean eap_sim_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_sim_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_sim_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_sim_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_SIM_KEYING_DATA_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->msk, EAP_SIM_KEYING_DATA_LEN);
+ *len = EAP_SIM_KEYING_DATA_LEN;
+ return key;
+}
+
+
+static u8 * eap_sim_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_sim_data *data = priv;
+ u8 *key;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(EAP_EMSK_LEN);
+ if (key == NULL)
+ return NULL;
+ os_memcpy(key, data->emsk, EAP_EMSK_LEN);
+ *len = EAP_EMSK_LEN;
+ return key;
+}
+
+
+static Boolean eap_sim_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_sim_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_sim_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_SIM, "SIM");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_sim_init;
+ eap->reset = eap_sim_reset;
+ eap->buildReq = eap_sim_buildReq;
+ eap->check = eap_sim_check;
+ eap->process = eap_sim_process;
+ eap->isDone = eap_sim_isDone;
+ eap->getKey = eap_sim_getKey;
+ eap->isSuccess = eap_sim_isSuccess;
+ eap->get_emsk = eap_sim_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_tls.c b/src/eap_server/eap_server_tls.c
new file mode 100644
index 0000000..c98fa18
--- /dev/null
+++ b/src/eap_server/eap_server_tls.c
@@ -0,0 +1,286 @@
+/*
+ * hostapd / EAP-TLS (RFC 2716)
+ * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+#include "eap_tls_common.h"
+#include "crypto/tls.h"
+
+
+static void eap_tls_reset(struct eap_sm *sm, void *priv);
+
+
+struct eap_tls_data {
+ struct eap_ssl_data ssl;
+ enum { START, CONTINUE, SUCCESS, FAILURE } state;
+ int established;
+};
+
+
+static const char * eap_tls_state_txt(int state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case CONTINUE:
+ return "CONTINUE";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "Unknown?!";
+ }
+}
+
+
+static void eap_tls_state(struct eap_tls_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-TLS: %s -> %s",
+ eap_tls_state_txt(data->state),
+ eap_tls_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_tls_init(struct eap_sm *sm)
+{
+ struct eap_tls_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = START;
+
+ if (eap_server_tls_ssl_init(sm, &data->ssl, 1)) {
+ wpa_printf(MSG_INFO, "EAP-TLS: Failed to initialize SSL.");
+ eap_tls_reset(sm, data);
+ return NULL;
+ }
+
+ return data;
+}
+
+
+static void eap_tls_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_tls_data *data = priv;
+ if (data == NULL)
+ return;
+ eap_server_tls_ssl_deinit(sm, &data->ssl);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_tls_build_start(struct eap_sm *sm,
+ struct eap_tls_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TLS, 1, EAP_CODE_REQUEST,
+ id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-TLS: Failed to allocate memory for "
+ "request");
+ eap_tls_state(data, FAILURE);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_TLS_FLAGS_START);
+
+ eap_tls_state(data, CONTINUE);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_tls_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_tls_data *data = priv;
+ struct wpabuf *res;
+
+ if (data->ssl.state == FRAG_ACK) {
+ return eap_server_tls_build_ack(id, EAP_TYPE_TLS, 0);
+ }
+
+ if (data->ssl.state == WAIT_FRAG_ACK) {
+ res = eap_server_tls_build_msg(&data->ssl, EAP_TYPE_TLS, 0,
+ id);
+ goto check_established;
+ }
+
+ switch (data->state) {
+ case START:
+ return eap_tls_build_start(sm, data, id);
+ case CONTINUE:
+ if (tls_connection_established(sm->ssl_ctx, data->ssl.conn))
+ data->established = 1;
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-TLS: %s - unexpected state %d",
+ __func__, data->state);
+ return NULL;
+ }
+
+ res = eap_server_tls_build_msg(&data->ssl, EAP_TYPE_TLS, 0, id);
+
+check_established:
+ if (data->established && data->ssl.state != WAIT_FRAG_ACK) {
+ /* TLS handshake has been completed and there are no more
+ * fragments waiting to be sent out. */
+ wpa_printf(MSG_DEBUG, "EAP-TLS: Done");
+ eap_tls_state(data, SUCCESS);
+ }
+
+ return res;
+}
+
+
+static Boolean eap_tls_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_TLS, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-TLS: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_tls_process_msg(struct eap_sm *sm, void *priv,
+ const struct wpabuf *respData)
+{
+ struct eap_tls_data *data = priv;
+ if (data->state == SUCCESS && wpabuf_len(data->ssl.tls_in) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TLS: Client acknowledged final TLS "
+ "handshake message");
+ return;
+ }
+ if (eap_server_tls_phase1(sm, &data->ssl) < 0)
+ eap_tls_state(data, FAILURE);
+}
+
+
+static void eap_tls_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_tls_data *data = priv;
+ if (eap_server_tls_process(sm, &data->ssl, respData, data,
+ EAP_TYPE_TLS, NULL, eap_tls_process_msg) <
+ 0)
+ eap_tls_state(data, FAILURE);
+}
+
+
+static Boolean eap_tls_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_tls_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_tls_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_tls_data *data = priv;
+ u8 *eapKeyData;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ eapKeyData = eap_server_tls_derive_key(sm, &data->ssl,
+ "client EAP encryption",
+ EAP_TLS_KEY_LEN);
+ if (eapKeyData) {
+ *len = EAP_TLS_KEY_LEN;
+ wpa_hexdump(MSG_DEBUG, "EAP-TLS: Derived key",
+ eapKeyData, EAP_TLS_KEY_LEN);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TLS: Failed to derive key");
+ }
+
+ return eapKeyData;
+}
+
+
+static u8 * eap_tls_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_tls_data *data = priv;
+ u8 *eapKeyData, *emsk;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ eapKeyData = eap_server_tls_derive_key(sm, &data->ssl,
+ "client EAP encryption",
+ EAP_TLS_KEY_LEN + EAP_EMSK_LEN);
+ if (eapKeyData) {
+ emsk = os_malloc(EAP_EMSK_LEN);
+ if (emsk)
+ os_memcpy(emsk, eapKeyData + EAP_TLS_KEY_LEN,
+ EAP_EMSK_LEN);
+ os_free(eapKeyData);
+ } else
+ emsk = NULL;
+
+ if (emsk) {
+ *len = EAP_EMSK_LEN;
+ wpa_hexdump(MSG_DEBUG, "EAP-TLS: Derived EMSK",
+ emsk, EAP_EMSK_LEN);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TLS: Failed to derive EMSK");
+ }
+
+ return emsk;
+}
+
+
+static Boolean eap_tls_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_tls_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_tls_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_TLS, "TLS");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_tls_init;
+ eap->reset = eap_tls_reset;
+ eap->buildReq = eap_tls_buildReq;
+ eap->check = eap_tls_check;
+ eap->process = eap_tls_process;
+ eap->isDone = eap_tls_isDone;
+ eap->getKey = eap_tls_getKey;
+ eap->isSuccess = eap_tls_isSuccess;
+ eap->get_emsk = eap_tls_get_emsk;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_tls_common.c b/src/eap_server/eap_server_tls_common.c
new file mode 100644
index 0000000..e149ee3
--- /dev/null
+++ b/src/eap_server/eap_server_tls_common.c
@@ -0,0 +1,400 @@
+/*
+ * EAP-TLS/PEAP/TTLS/FAST server common functions
+ * Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/sha1.h"
+#include "crypto/tls.h"
+#include "eap_i.h"
+#include "eap_tls_common.h"
+
+
+static void eap_server_tls_free_in_buf(struct eap_ssl_data *data);
+
+
+int eap_server_tls_ssl_init(struct eap_sm *sm, struct eap_ssl_data *data,
+ int verify_peer)
+{
+ data->eap = sm;
+ data->phase2 = sm->init_phase2;
+
+ data->conn = tls_connection_init(sm->ssl_ctx);
+ if (data->conn == NULL) {
+ wpa_printf(MSG_INFO, "SSL: Failed to initialize new TLS "
+ "connection");
+ return -1;
+ }
+
+ if (tls_connection_set_verify(sm->ssl_ctx, data->conn, verify_peer)) {
+ wpa_printf(MSG_INFO, "SSL: Failed to configure verification "
+ "of TLS peer certificate");
+ tls_connection_deinit(sm->ssl_ctx, data->conn);
+ data->conn = NULL;
+ return -1;
+ }
+
+ data->tls_out_limit = sm->fragment_size > 0 ? sm->fragment_size : 1398;
+ if (data->phase2) {
+ /* Limit the fragment size in the inner TLS authentication
+ * since the outer authentication with EAP-PEAP does not yet
+ * support fragmentation */
+ if (data->tls_out_limit > 100)
+ data->tls_out_limit -= 100;
+ }
+ return 0;
+}
+
+
+void eap_server_tls_ssl_deinit(struct eap_sm *sm, struct eap_ssl_data *data)
+{
+ tls_connection_deinit(sm->ssl_ctx, data->conn);
+ eap_server_tls_free_in_buf(data);
+ wpabuf_free(data->tls_out);
+ data->tls_out = NULL;
+}
+
+
+u8 * eap_server_tls_derive_key(struct eap_sm *sm, struct eap_ssl_data *data,
+ char *label, size_t len)
+{
+ struct tls_keys keys;
+ u8 *rnd = NULL, *out;
+
+ out = os_malloc(len);
+ if (out == NULL)
+ return NULL;
+
+ if (tls_connection_prf(sm->ssl_ctx, data->conn, label, 0, out, len) ==
+ 0)
+ return out;
+
+ if (tls_connection_get_keys(sm->ssl_ctx, data->conn, &keys))
+ goto fail;
+
+ if (keys.client_random == NULL || keys.server_random == NULL ||
+ keys.master_key == NULL)
+ goto fail;
+
+ rnd = os_malloc(keys.client_random_len + keys.server_random_len);
+ if (rnd == NULL)
+ goto fail;
+ os_memcpy(rnd, keys.client_random, keys.client_random_len);
+ os_memcpy(rnd + keys.client_random_len, keys.server_random,
+ keys.server_random_len);
+
+ if (tls_prf(keys.master_key, keys.master_key_len,
+ label, rnd, keys.client_random_len +
+ keys.server_random_len, out, len))
+ goto fail;
+
+ os_free(rnd);
+ return out;
+
+fail:
+ os_free(out);
+ os_free(rnd);
+ return NULL;
+}
+
+
+struct wpabuf * eap_server_tls_build_msg(struct eap_ssl_data *data,
+ int eap_type, int version, u8 id)
+{
+ struct wpabuf *req;
+ u8 flags;
+ size_t send_len, plen;
+
+ wpa_printf(MSG_DEBUG, "SSL: Generating Request");
+ if (data->tls_out == NULL) {
+ wpa_printf(MSG_ERROR, "SSL: tls_out NULL in %s", __func__);
+ return NULL;
+ }
+
+ flags = version;
+ send_len = wpabuf_len(data->tls_out) - data->tls_out_pos;
+ if (1 + send_len > data->tls_out_limit) {
+ send_len = data->tls_out_limit - 1;
+ flags |= EAP_TLS_FLAGS_MORE_FRAGMENTS;
+ if (data->tls_out_pos == 0) {
+ flags |= EAP_TLS_FLAGS_LENGTH_INCLUDED;
+ send_len -= 4;
+ }
+ }
+
+ plen = 1 + send_len;
+ if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED)
+ plen += 4;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, eap_type, plen,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL)
+ return NULL;
+
+ wpabuf_put_u8(req, flags); /* Flags */
+ if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED)
+ wpabuf_put_be32(req, wpabuf_len(data->tls_out));
+
+ wpabuf_put_data(req, wpabuf_head_u8(data->tls_out) + data->tls_out_pos,
+ send_len);
+ data->tls_out_pos += send_len;
+
+ if (data->tls_out_pos == wpabuf_len(data->tls_out)) {
+ wpa_printf(MSG_DEBUG, "SSL: Sending out %lu bytes "
+ "(message sent completely)",
+ (unsigned long) send_len);
+ wpabuf_free(data->tls_out);
+ data->tls_out = NULL;
+ data->tls_out_pos = 0;
+ data->state = MSG;
+ } else {
+ wpa_printf(MSG_DEBUG, "SSL: Sending out %lu bytes "
+ "(%lu more to send)", (unsigned long) send_len,
+ (unsigned long) wpabuf_len(data->tls_out) -
+ data->tls_out_pos);
+ data->state = WAIT_FRAG_ACK;
+ }
+
+ return req;
+}
+
+
+struct wpabuf * eap_server_tls_build_ack(u8 id, int eap_type, int version)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, eap_type, 1, EAP_CODE_REQUEST,
+ id);
+ if (req == NULL)
+ return NULL;
+ wpa_printf(MSG_DEBUG, "SSL: Building ACK");
+ wpabuf_put_u8(req, version); /* Flags */
+ return req;
+}
+
+
+static int eap_server_tls_process_cont(struct eap_ssl_data *data,
+ const u8 *buf, size_t len)
+{
+ /* Process continuation of a pending message */
+ if (len > wpabuf_tailroom(data->tls_in)) {
+ wpa_printf(MSG_DEBUG, "SSL: Fragment overflow");
+ return -1;
+ }
+
+ wpabuf_put_data(data->tls_in, buf, len);
+ wpa_printf(MSG_DEBUG, "SSL: Received %lu bytes, waiting for %lu "
+ "bytes more", (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->tls_in));
+
+ return 0;
+}
+
+
+static int eap_server_tls_process_fragment(struct eap_ssl_data *data,
+ u8 flags, u32 message_length,
+ const u8 *buf, size_t len)
+{
+ /* Process a fragment that is not the last one of the message */
+ if (data->tls_in == NULL && !(flags & EAP_TLS_FLAGS_LENGTH_INCLUDED)) {
+ wpa_printf(MSG_DEBUG, "SSL: No Message Length field in a "
+ "fragmented packet");
+ return -1;
+ }
+
+ if (data->tls_in == NULL) {
+ /* First fragment of the message */
+
+ /* Limit length to avoid rogue peers from causing large
+ * memory allocations. */
+ if (message_length > 65536) {
+ wpa_printf(MSG_INFO, "SSL: Too long TLS fragment (size"
+ " over 64 kB)");
+ return -1;
+ }
+
+ data->tls_in = wpabuf_alloc(message_length);
+ if (data->tls_in == NULL) {
+ wpa_printf(MSG_DEBUG, "SSL: No memory for message");
+ return -1;
+ }
+ wpabuf_put_data(data->tls_in, buf, len);
+ wpa_printf(MSG_DEBUG, "SSL: Received %lu bytes in first "
+ "fragment, waiting for %lu bytes more",
+ (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->tls_in));
+ }
+
+ return 0;
+}
+
+
+int eap_server_tls_phase1(struct eap_sm *sm, struct eap_ssl_data *data)
+{
+ if (data->tls_out) {
+ /* This should not happen.. */
+ wpa_printf(MSG_INFO, "SSL: pending tls_out data when "
+ "processing new message");
+ wpabuf_free(data->tls_out);
+ WPA_ASSERT(data->tls_out == NULL);
+ }
+
+ data->tls_out = tls_connection_server_handshake(sm->ssl_ctx,
+ data->conn,
+ data->tls_in, NULL);
+ if (data->tls_out == NULL) {
+ wpa_printf(MSG_INFO, "SSL: TLS processing failed");
+ return -1;
+ }
+ if (tls_connection_get_failed(sm->ssl_ctx, data->conn)) {
+ /* TLS processing has failed - return error */
+ wpa_printf(MSG_DEBUG, "SSL: Failed - tls_out available to "
+ "report error");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int eap_server_tls_reassemble(struct eap_ssl_data *data, u8 flags,
+ const u8 **pos, size_t *left)
+{
+ unsigned int tls_msg_len = 0;
+ const u8 *end = *pos + *left;
+
+ if (flags & EAP_TLS_FLAGS_LENGTH_INCLUDED) {
+ if (*left < 4) {
+ wpa_printf(MSG_INFO, "SSL: Short frame with TLS "
+ "length");
+ return -1;
+ }
+ tls_msg_len = WPA_GET_BE32(*pos);
+ wpa_printf(MSG_DEBUG, "SSL: TLS Message Length: %d",
+ tls_msg_len);
+ *pos += 4;
+ *left -= 4;
+ }
+
+ wpa_printf(MSG_DEBUG, "SSL: Received packet: Flags 0x%x "
+ "Message Length %u", flags, tls_msg_len);
+
+ if (data->state == WAIT_FRAG_ACK) {
+ if (*left != 0) {
+ wpa_printf(MSG_DEBUG, "SSL: Unexpected payload in "
+ "WAIT_FRAG_ACK state");
+ return -1;
+ }
+ wpa_printf(MSG_DEBUG, "SSL: Fragment acknowledged");
+ return 1;
+ }
+
+ if (data->tls_in &&
+ eap_server_tls_process_cont(data, *pos, end - *pos) < 0)
+ return -1;
+
+ if (flags & EAP_TLS_FLAGS_MORE_FRAGMENTS) {
+ if (eap_server_tls_process_fragment(data, flags, tls_msg_len,
+ *pos, end - *pos) < 0)
+ return -1;
+
+ data->state = FRAG_ACK;
+ return 1;
+ }
+
+ if (data->state == FRAG_ACK) {
+ wpa_printf(MSG_DEBUG, "SSL: All fragments received");
+ data->state = MSG;
+ }
+
+ if (data->tls_in == NULL) {
+ /* Wrap unfragmented messages as wpabuf without extra copy */
+ wpabuf_set(&data->tmpbuf, *pos, end - *pos);
+ data->tls_in = &data->tmpbuf;
+ }
+
+ return 0;
+}
+
+
+static void eap_server_tls_free_in_buf(struct eap_ssl_data *data)
+{
+ if (data->tls_in != &data->tmpbuf)
+ wpabuf_free(data->tls_in);
+ data->tls_in = NULL;
+}
+
+
+struct wpabuf * eap_server_tls_encrypt(struct eap_sm *sm,
+ struct eap_ssl_data *data,
+ const struct wpabuf *plain)
+{
+ struct wpabuf *buf;
+
+ buf = tls_connection_encrypt(sm->ssl_ctx, data->conn,
+ plain);
+ if (buf == NULL) {
+ wpa_printf(MSG_INFO, "SSL: Failed to encrypt Phase 2 data");
+ return NULL;
+ }
+
+ return buf;
+}
+
+
+int eap_server_tls_process(struct eap_sm *sm, struct eap_ssl_data *data,
+ struct wpabuf *respData, void *priv, int eap_type,
+ int (*proc_version)(struct eap_sm *sm, void *priv,
+ int peer_version),
+ void (*proc_msg)(struct eap_sm *sm, void *priv,
+ const struct wpabuf *respData))
+{
+ const u8 *pos;
+ u8 flags;
+ size_t left;
+ int ret, res = 0;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, eap_type, respData, &left);
+ if (pos == NULL || left < 1)
+ return 0; /* Should not happen - frame already validated */
+ flags = *pos++;
+ left--;
+ wpa_printf(MSG_DEBUG, "SSL: Received packet(len=%lu) - Flags 0x%02x",
+ (unsigned long) wpabuf_len(respData), flags);
+
+ if (proc_version &&
+ proc_version(sm, priv, flags & EAP_TLS_VERSION_MASK) < 0)
+ return -1;
+
+ ret = eap_server_tls_reassemble(data, flags, &pos, &left);
+ if (ret < 0) {
+ res = -1;
+ goto done;
+ } else if (ret == 1)
+ return 0;
+
+ if (proc_msg)
+ proc_msg(sm, priv, respData);
+
+ if (tls_connection_get_write_alerts(sm->ssl_ctx, data->conn) > 1) {
+ wpa_printf(MSG_INFO, "SSL: Locally detected fatal error in "
+ "TLS processing");
+ res = -1;
+ }
+
+done:
+ eap_server_tls_free_in_buf(data);
+
+ return res;
+}
diff --git a/src/eap_server/eap_server_tnc.c b/src/eap_server/eap_server_tnc.c
new file mode 100644
index 0000000..a2d6f17
--- /dev/null
+++ b/src/eap_server/eap_server_tnc.c
@@ -0,0 +1,582 @@
+/*
+ * EAP server method: EAP-TNC (Trusted Network Connect)
+ * Copyright (c) 2007-2010, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "base64.h"
+#include "eap_i.h"
+#include "tncs.h"
+
+
+struct eap_tnc_data {
+ enum eap_tnc_state {
+ START, CONTINUE, RECOMMENDATION, FRAG_ACK, WAIT_FRAG_ACK, DONE,
+ FAIL
+ } state;
+ enum { ALLOW, ISOLATE, NO_ACCESS, NO_RECOMMENDATION } recommendation;
+ struct tncs_data *tncs;
+ struct wpabuf *in_buf;
+ struct wpabuf *out_buf;
+ size_t out_used;
+ size_t fragment_size;
+ unsigned int was_done:1;
+ unsigned int was_fail:1;
+};
+
+
+/* EAP-TNC Flags */
+#define EAP_TNC_FLAGS_LENGTH_INCLUDED 0x80
+#define EAP_TNC_FLAGS_MORE_FRAGMENTS 0x40
+#define EAP_TNC_FLAGS_START 0x20
+#define EAP_TNC_VERSION_MASK 0x07
+
+#define EAP_TNC_VERSION 1
+
+
+static const char * eap_tnc_state_txt(enum eap_tnc_state state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case CONTINUE:
+ return "CONTINUE";
+ case RECOMMENDATION:
+ return "RECOMMENDATION";
+ case FRAG_ACK:
+ return "FRAG_ACK";
+ case WAIT_FRAG_ACK:
+ return "WAIT_FRAG_ACK";
+ case DONE:
+ return "DONE";
+ case FAIL:
+ return "FAIL";
+ }
+ return "??";
+}
+
+
+static void eap_tnc_set_state(struct eap_tnc_data *data,
+ enum eap_tnc_state new_state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-TNC: %s -> %s",
+ eap_tnc_state_txt(data->state),
+ eap_tnc_state_txt(new_state));
+ data->state = new_state;
+}
+
+
+static void * eap_tnc_init(struct eap_sm *sm)
+{
+ struct eap_tnc_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ eap_tnc_set_state(data, START);
+ data->tncs = tncs_init();
+ if (data->tncs == NULL) {
+ os_free(data);
+ return NULL;
+ }
+
+ data->fragment_size = sm->fragment_size > 100 ?
+ sm->fragment_size - 98 : 1300;
+
+ return data;
+}
+
+
+static void eap_tnc_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_tnc_data *data = priv;
+ wpabuf_free(data->in_buf);
+ wpabuf_free(data->out_buf);
+ tncs_deinit(data->tncs);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_tnc_build_start(struct eap_sm *sm,
+ struct eap_tnc_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TNC, 1, EAP_CODE_REQUEST,
+ id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-TNC: Failed to allocate memory for "
+ "request");
+ eap_tnc_set_state(data, FAIL);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_TNC_FLAGS_START | EAP_TNC_VERSION);
+
+ eap_tnc_set_state(data, CONTINUE);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_tnc_build(struct eap_sm *sm,
+ struct eap_tnc_data *data)
+{
+ struct wpabuf *req;
+ u8 *rpos, *rpos1;
+ size_t rlen;
+ char *start_buf, *end_buf;
+ size_t start_len, end_len;
+ size_t imv_len;
+
+ imv_len = tncs_total_send_len(data->tncs);
+
+ start_buf = tncs_if_tnccs_start(data->tncs);
+ if (start_buf == NULL)
+ return NULL;
+ start_len = os_strlen(start_buf);
+ end_buf = tncs_if_tnccs_end();
+ if (end_buf == NULL) {
+ os_free(start_buf);
+ return NULL;
+ }
+ end_len = os_strlen(end_buf);
+
+ rlen = start_len + imv_len + end_len;
+ req = wpabuf_alloc(rlen);
+ if (req == NULL) {
+ os_free(start_buf);
+ os_free(end_buf);
+ return NULL;
+ }
+
+ wpabuf_put_data(req, start_buf, start_len);
+ os_free(start_buf);
+
+ rpos1 = wpabuf_put(req, 0);
+ rpos = tncs_copy_send_buf(data->tncs, rpos1);
+ wpabuf_put(req, rpos - rpos1);
+
+ wpabuf_put_data(req, end_buf, end_len);
+ os_free(end_buf);
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-TNC: Request",
+ wpabuf_head(req), wpabuf_len(req));
+
+ return req;
+}
+
+
+static struct wpabuf * eap_tnc_build_recommendation(struct eap_sm *sm,
+ struct eap_tnc_data *data)
+{
+ switch (data->recommendation) {
+ case ALLOW:
+ eap_tnc_set_state(data, DONE);
+ break;
+ case ISOLATE:
+ eap_tnc_set_state(data, FAIL);
+ /* TODO: support assignment to a different VLAN */
+ break;
+ case NO_ACCESS:
+ eap_tnc_set_state(data, FAIL);
+ break;
+ case NO_RECOMMENDATION:
+ eap_tnc_set_state(data, DONE);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Unknown recommendation");
+ return NULL;
+ }
+
+ return eap_tnc_build(sm, data);
+}
+
+
+static struct wpabuf * eap_tnc_build_frag_ack(u8 id, u8 code)
+{
+ struct wpabuf *msg;
+
+ msg = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TNC, 1, code, id);
+ if (msg == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-TNC: Failed to allocate memory "
+ "for fragment ack");
+ return NULL;
+ }
+ wpabuf_put_u8(msg, EAP_TNC_VERSION); /* Flags */
+
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Send fragment ack");
+
+ return msg;
+}
+
+
+static struct wpabuf * eap_tnc_build_msg(struct eap_tnc_data *data, u8 id)
+{
+ struct wpabuf *req;
+ u8 flags;
+ size_t send_len, plen;
+
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Generating Request");
+
+ flags = EAP_TNC_VERSION;
+ send_len = wpabuf_len(data->out_buf) - data->out_used;
+ if (1 + send_len > data->fragment_size) {
+ send_len = data->fragment_size - 1;
+ flags |= EAP_TNC_FLAGS_MORE_FRAGMENTS;
+ if (data->out_used == 0) {
+ flags |= EAP_TNC_FLAGS_LENGTH_INCLUDED;
+ send_len -= 4;
+ }
+ }
+
+ plen = 1 + send_len;
+ if (flags & EAP_TNC_FLAGS_LENGTH_INCLUDED)
+ plen += 4;
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TNC, plen,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL)
+ return NULL;
+
+ wpabuf_put_u8(req, flags); /* Flags */
+ if (flags & EAP_TNC_FLAGS_LENGTH_INCLUDED)
+ wpabuf_put_be32(req, wpabuf_len(data->out_buf));
+
+ wpabuf_put_data(req, wpabuf_head_u8(data->out_buf) + data->out_used,
+ send_len);
+ data->out_used += send_len;
+
+ if (data->out_used == wpabuf_len(data->out_buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Sending out %lu bytes "
+ "(message sent completely)",
+ (unsigned long) send_len);
+ wpabuf_free(data->out_buf);
+ data->out_buf = NULL;
+ data->out_used = 0;
+ if (data->was_fail)
+ eap_tnc_set_state(data, FAIL);
+ else if (data->was_done)
+ eap_tnc_set_state(data, DONE);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Sending out %lu bytes "
+ "(%lu more to send)", (unsigned long) send_len,
+ (unsigned long) wpabuf_len(data->out_buf) -
+ data->out_used);
+ if (data->state == FAIL)
+ data->was_fail = 1;
+ else if (data->state == DONE)
+ data->was_done = 1;
+ eap_tnc_set_state(data, WAIT_FRAG_ACK);
+ }
+
+ return req;
+}
+
+
+static struct wpabuf * eap_tnc_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_tnc_data *data = priv;
+
+ switch (data->state) {
+ case START:
+ tncs_init_connection(data->tncs);
+ return eap_tnc_build_start(sm, data, id);
+ case CONTINUE:
+ if (data->out_buf == NULL) {
+ data->out_buf = eap_tnc_build(sm, data);
+ if (data->out_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Failed to "
+ "generate message");
+ return NULL;
+ }
+ data->out_used = 0;
+ }
+ return eap_tnc_build_msg(data, id);
+ case RECOMMENDATION:
+ if (data->out_buf == NULL) {
+ data->out_buf = eap_tnc_build_recommendation(sm, data);
+ if (data->out_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Failed to "
+ "generate recommendation message");
+ return NULL;
+ }
+ data->out_used = 0;
+ }
+ return eap_tnc_build_msg(data, id);
+ case WAIT_FRAG_ACK:
+ return eap_tnc_build_msg(data, id);
+ case FRAG_ACK:
+ return eap_tnc_build_frag_ack(id, EAP_CODE_REQUEST);
+ case DONE:
+ case FAIL:
+ return NULL;
+ }
+
+ return NULL;
+}
+
+
+static Boolean eap_tnc_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_tnc_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_TNC, respData,
+ &len);
+ if (pos == NULL) {
+ wpa_printf(MSG_INFO, "EAP-TNC: Invalid frame");
+ return TRUE;
+ }
+
+ if (len == 0 && data->state != WAIT_FRAG_ACK) {
+ wpa_printf(MSG_INFO, "EAP-TNC: Invalid frame (empty)");
+ return TRUE;
+ }
+
+ if (len == 0)
+ return FALSE; /* Fragment ACK does not include flags */
+
+ if ((*pos & EAP_TNC_VERSION_MASK) != EAP_TNC_VERSION) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Unsupported version %d",
+ *pos & EAP_TNC_VERSION_MASK);
+ return TRUE;
+ }
+
+ if (*pos & EAP_TNC_FLAGS_START) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Peer used Start flag");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void tncs_process(struct eap_tnc_data *data, struct wpabuf *inbuf)
+{
+ enum tncs_process_res res;
+
+ res = tncs_process_if_tnccs(data->tncs, wpabuf_head(inbuf),
+ wpabuf_len(inbuf));
+ switch (res) {
+ case TNCCS_RECOMMENDATION_ALLOW:
+ wpa_printf(MSG_DEBUG, "EAP-TNC: TNCS allowed access");
+ eap_tnc_set_state(data, RECOMMENDATION);
+ data->recommendation = ALLOW;
+ break;
+ case TNCCS_RECOMMENDATION_NO_RECOMMENDATION:
+ wpa_printf(MSG_DEBUG, "EAP-TNC: TNCS has no recommendation");
+ eap_tnc_set_state(data, RECOMMENDATION);
+ data->recommendation = NO_RECOMMENDATION;
+ break;
+ case TNCCS_RECOMMENDATION_ISOLATE:
+ wpa_printf(MSG_DEBUG, "EAP-TNC: TNCS requested isolation");
+ eap_tnc_set_state(data, RECOMMENDATION);
+ data->recommendation = ISOLATE;
+ break;
+ case TNCCS_RECOMMENDATION_NO_ACCESS:
+ wpa_printf(MSG_DEBUG, "EAP-TNC: TNCS rejected access");
+ eap_tnc_set_state(data, RECOMMENDATION);
+ data->recommendation = NO_ACCESS;
+ break;
+ case TNCCS_PROCESS_ERROR:
+ wpa_printf(MSG_DEBUG, "EAP-TNC: TNCS processing error");
+ eap_tnc_set_state(data, FAIL);
+ break;
+ default:
+ break;
+ }
+}
+
+
+static int eap_tnc_process_cont(struct eap_tnc_data *data,
+ const u8 *buf, size_t len)
+{
+ /* Process continuation of a pending message */
+ if (len > wpabuf_tailroom(data->in_buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Fragment overflow");
+ eap_tnc_set_state(data, FAIL);
+ return -1;
+ }
+
+ wpabuf_put_data(data->in_buf, buf, len);
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Received %lu bytes, waiting for %lu "
+ "bytes more", (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->in_buf));
+
+ return 0;
+}
+
+
+static int eap_tnc_process_fragment(struct eap_tnc_data *data,
+ u8 flags, u32 message_length,
+ const u8 *buf, size_t len)
+{
+ /* Process a fragment that is not the last one of the message */
+ if (data->in_buf == NULL && !(flags & EAP_TNC_FLAGS_LENGTH_INCLUDED)) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: No Message Length field in a "
+ "fragmented packet");
+ return -1;
+ }
+
+ if (data->in_buf == NULL) {
+ /* First fragment of the message */
+ data->in_buf = wpabuf_alloc(message_length);
+ if (data->in_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: No memory for "
+ "message");
+ return -1;
+ }
+ wpabuf_put_data(data->in_buf, buf, len);
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Received %lu bytes in first "
+ "fragment, waiting for %lu bytes more",
+ (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->in_buf));
+ }
+
+ return 0;
+}
+
+
+static void eap_tnc_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_tnc_data *data = priv;
+ const u8 *pos, *end;
+ size_t len;
+ u8 flags;
+ u32 message_length = 0;
+ struct wpabuf tmpbuf;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_TNC, respData, &len);
+ if (pos == NULL)
+ return; /* Should not happen; message already verified */
+
+ end = pos + len;
+
+ if (len == 1 && (data->state == DONE || data->state == FAIL)) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Peer acknowledged the last "
+ "message");
+ return;
+ }
+
+ if (len == 0) {
+ /* fragment ack */
+ flags = 0;
+ } else
+ flags = *pos++;
+
+ if (flags & EAP_TNC_FLAGS_LENGTH_INCLUDED) {
+ if (end - pos < 4) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Message underflow");
+ eap_tnc_set_state(data, FAIL);
+ return;
+ }
+ message_length = WPA_GET_BE32(pos);
+ pos += 4;
+
+ if (message_length < (u32) (end - pos)) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Invalid Message "
+ "Length (%d; %ld remaining in this msg)",
+ message_length, (long) (end - pos));
+ eap_tnc_set_state(data, FAIL);
+ return;
+ }
+ }
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Received packet: Flags 0x%x "
+ "Message Length %u", flags, message_length);
+
+ if (data->state == WAIT_FRAG_ACK) {
+ if (len > 1) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Unexpected payload "
+ "in WAIT_FRAG_ACK state");
+ eap_tnc_set_state(data, FAIL);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-TNC: Fragment acknowledged");
+ eap_tnc_set_state(data, CONTINUE);
+ return;
+ }
+
+ if (data->in_buf && eap_tnc_process_cont(data, pos, end - pos) < 0) {
+ eap_tnc_set_state(data, FAIL);
+ return;
+ }
+
+ if (flags & EAP_TNC_FLAGS_MORE_FRAGMENTS) {
+ if (eap_tnc_process_fragment(data, flags, message_length,
+ pos, end - pos) < 0)
+ eap_tnc_set_state(data, FAIL);
+ else
+ eap_tnc_set_state(data, FRAG_ACK);
+ return;
+ } else if (data->state == FRAG_ACK) {
+ wpa_printf(MSG_DEBUG, "EAP-TNC: All fragments received");
+ eap_tnc_set_state(data, CONTINUE);
+ }
+
+ if (data->in_buf == NULL) {
+ /* Wrap unfragmented messages as wpabuf without extra copy */
+ wpabuf_set(&tmpbuf, pos, end - pos);
+ data->in_buf = &tmpbuf;
+ }
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-TNC: Received payload",
+ wpabuf_head(data->in_buf), wpabuf_len(data->in_buf));
+ tncs_process(data, data->in_buf);
+
+ if (data->in_buf != &tmpbuf)
+ wpabuf_free(data->in_buf);
+ data->in_buf = NULL;
+}
+
+
+static Boolean eap_tnc_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_tnc_data *data = priv;
+ return data->state == DONE || data->state == FAIL;
+}
+
+
+static Boolean eap_tnc_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_tnc_data *data = priv;
+ return data->state == DONE;
+}
+
+
+int eap_server_tnc_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_TNC, "TNC");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_tnc_init;
+ eap->reset = eap_tnc_reset;
+ eap->buildReq = eap_tnc_buildReq;
+ eap->check = eap_tnc_check;
+ eap->process = eap_tnc_process;
+ eap->isDone = eap_tnc_isDone;
+ eap->isSuccess = eap_tnc_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_ttls.c b/src/eap_server/eap_server_ttls.c
new file mode 100644
index 0000000..702c50c
--- /dev/null
+++ b/src/eap_server/eap_server_ttls.c
@@ -0,0 +1,1430 @@
+/*
+ * hostapd / EAP-TTLS (RFC 5281)
+ * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/ms_funcs.h"
+#include "crypto/sha1.h"
+#include "crypto/tls.h"
+#include "eap_server/eap_i.h"
+#include "eap_server/eap_tls_common.h"
+#include "eap_common/chap.h"
+#include "eap_common/eap_ttls.h"
+
+
+/* Maximum supported TTLS version
+ * 0 = RFC 5281
+ * 1 = draft-funk-eap-ttls-v1-00.txt
+ */
+#ifndef EAP_TTLS_VERSION
+#define EAP_TTLS_VERSION 0 /* TTLSv1 implementation is not yet complete */
+#endif /* EAP_TTLS_VERSION */
+
+
+#define MSCHAPV2_KEY_LEN 16
+
+
+static void eap_ttls_reset(struct eap_sm *sm, void *priv);
+
+
+struct eap_ttls_data {
+ struct eap_ssl_data ssl;
+ enum {
+ START, PHASE1, PHASE2_START, PHASE2_METHOD,
+ PHASE2_MSCHAPV2_RESP, PHASE_FINISHED, SUCCESS, FAILURE
+ } state;
+
+ int ttls_version;
+ int force_version;
+ const struct eap_method *phase2_method;
+ void *phase2_priv;
+ int mschapv2_resp_ok;
+ u8 mschapv2_auth_response[20];
+ u8 mschapv2_ident;
+ int tls_ia_configured;
+ struct wpabuf *pending_phase2_eap_resp;
+ int tnc_started;
+};
+
+
+static const char * eap_ttls_state_txt(int state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case PHASE1:
+ return "PHASE1";
+ case PHASE2_START:
+ return "PHASE2_START";
+ case PHASE2_METHOD:
+ return "PHASE2_METHOD";
+ case PHASE2_MSCHAPV2_RESP:
+ return "PHASE2_MSCHAPV2_RESP";
+ case PHASE_FINISHED:
+ return "PHASE_FINISHED";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "Unknown?!";
+ }
+}
+
+
+static void eap_ttls_state(struct eap_ttls_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: %s -> %s",
+ eap_ttls_state_txt(data->state),
+ eap_ttls_state_txt(state));
+ data->state = state;
+}
+
+
+static u8 * eap_ttls_avp_hdr(u8 *avphdr, u32 avp_code, u32 vendor_id,
+ int mandatory, size_t len)
+{
+ struct ttls_avp_vendor *avp;
+ u8 flags;
+ size_t hdrlen;
+
+ avp = (struct ttls_avp_vendor *) avphdr;
+ flags = mandatory ? AVP_FLAGS_MANDATORY : 0;
+ if (vendor_id) {
+ flags |= AVP_FLAGS_VENDOR;
+ hdrlen = sizeof(*avp);
+ avp->vendor_id = host_to_be32(vendor_id);
+ } else {
+ hdrlen = sizeof(struct ttls_avp);
+ }
+
+ avp->avp_code = host_to_be32(avp_code);
+ avp->avp_length = host_to_be32((flags << 24) | (hdrlen + len));
+
+ return avphdr + hdrlen;
+}
+
+
+static struct wpabuf * eap_ttls_avp_encapsulate(struct wpabuf *resp,
+ u32 avp_code, int mandatory)
+{
+ struct wpabuf *avp;
+ u8 *pos;
+
+ avp = wpabuf_alloc(sizeof(struct ttls_avp) + wpabuf_len(resp) + 4);
+ if (avp == NULL) {
+ wpabuf_free(resp);
+ return NULL;
+ }
+
+ pos = eap_ttls_avp_hdr(wpabuf_mhead(avp), avp_code, 0, mandatory,
+ wpabuf_len(resp));
+ os_memcpy(pos, wpabuf_head(resp), wpabuf_len(resp));
+ pos += wpabuf_len(resp);
+ AVP_PAD((const u8 *) wpabuf_head(avp), pos);
+ wpabuf_free(resp);
+ wpabuf_put(avp, pos - (u8 *) wpabuf_head(avp));
+ return avp;
+}
+
+
+struct eap_ttls_avp {
+ /* Note: eap is allocated memory; caller is responsible for freeing
+ * it. All the other pointers are pointing to the packet data, i.e.,
+ * they must not be freed separately. */
+ u8 *eap;
+ size_t eap_len;
+ u8 *user_name;
+ size_t user_name_len;
+ u8 *user_password;
+ size_t user_password_len;
+ u8 *chap_challenge;
+ size_t chap_challenge_len;
+ u8 *chap_password;
+ size_t chap_password_len;
+ u8 *mschap_challenge;
+ size_t mschap_challenge_len;
+ u8 *mschap_response;
+ size_t mschap_response_len;
+ u8 *mschap2_response;
+ size_t mschap2_response_len;
+};
+
+
+static int eap_ttls_avp_parse(struct wpabuf *buf, struct eap_ttls_avp *parse)
+{
+ struct ttls_avp *avp;
+ u8 *pos;
+ int left;
+
+ pos = wpabuf_mhead(buf);
+ left = wpabuf_len(buf);
+ os_memset(parse, 0, sizeof(*parse));
+
+ while (left > 0) {
+ u32 avp_code, avp_length, vendor_id = 0;
+ u8 avp_flags, *dpos;
+ size_t pad, dlen;
+ avp = (struct ttls_avp *) pos;
+ avp_code = be_to_host32(avp->avp_code);
+ avp_length = be_to_host32(avp->avp_length);
+ avp_flags = (avp_length >> 24) & 0xff;
+ avp_length &= 0xffffff;
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP: code=%d flags=0x%02x "
+ "length=%d", (int) avp_code, avp_flags,
+ (int) avp_length);
+ if ((int) avp_length > left) {
+ wpa_printf(MSG_WARNING, "EAP-TTLS: AVP overflow "
+ "(len=%d, left=%d) - dropped",
+ (int) avp_length, left);
+ goto fail;
+ }
+ if (avp_length < sizeof(*avp)) {
+ wpa_printf(MSG_WARNING, "EAP-TTLS: Invalid AVP length "
+ "%d", avp_length);
+ goto fail;
+ }
+ dpos = (u8 *) (avp + 1);
+ dlen = avp_length - sizeof(*avp);
+ if (avp_flags & AVP_FLAGS_VENDOR) {
+ if (dlen < 4) {
+ wpa_printf(MSG_WARNING, "EAP-TTLS: vendor AVP "
+ "underflow");
+ goto fail;
+ }
+ vendor_id = be_to_host32(* (be32 *) dpos);
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP vendor_id %d",
+ (int) vendor_id);
+ dpos += 4;
+ dlen -= 4;
+ }
+
+ wpa_hexdump(MSG_DEBUG, "EAP-TTLS: AVP data", dpos, dlen);
+
+ if (vendor_id == 0 && avp_code == RADIUS_ATTR_EAP_MESSAGE) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP - EAP Message");
+ if (parse->eap == NULL) {
+ parse->eap = os_malloc(dlen);
+ if (parse->eap == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-TTLS: "
+ "failed to allocate memory "
+ "for Phase 2 EAP data");
+ goto fail;
+ }
+ os_memcpy(parse->eap, dpos, dlen);
+ parse->eap_len = dlen;
+ } else {
+ u8 *neweap = os_realloc(parse->eap,
+ parse->eap_len + dlen);
+ if (neweap == NULL) {
+ wpa_printf(MSG_WARNING, "EAP-TTLS: "
+ "failed to allocate memory "
+ "for Phase 2 EAP data");
+ goto fail;
+ }
+ os_memcpy(neweap + parse->eap_len, dpos, dlen);
+ parse->eap = neweap;
+ parse->eap_len += dlen;
+ }
+ } else if (vendor_id == 0 &&
+ avp_code == RADIUS_ATTR_USER_NAME) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-TTLS: User-Name",
+ dpos, dlen);
+ parse->user_name = dpos;
+ parse->user_name_len = dlen;
+ } else if (vendor_id == 0 &&
+ avp_code == RADIUS_ATTR_USER_PASSWORD) {
+ u8 *password = dpos;
+ size_t password_len = dlen;
+ while (password_len > 0 &&
+ password[password_len - 1] == '\0') {
+ password_len--;
+ }
+ wpa_hexdump_ascii_key(MSG_DEBUG, "EAP-TTLS: "
+ "User-Password (PAP)",
+ password, password_len);
+ parse->user_password = password;
+ parse->user_password_len = password_len;
+ } else if (vendor_id == 0 &&
+ avp_code == RADIUS_ATTR_CHAP_CHALLENGE) {
+ wpa_hexdump(MSG_DEBUG,
+ "EAP-TTLS: CHAP-Challenge (CHAP)",
+ dpos, dlen);
+ parse->chap_challenge = dpos;
+ parse->chap_challenge_len = dlen;
+ } else if (vendor_id == 0 &&
+ avp_code == RADIUS_ATTR_CHAP_PASSWORD) {
+ wpa_hexdump(MSG_DEBUG,
+ "EAP-TTLS: CHAP-Password (CHAP)",
+ dpos, dlen);
+ parse->chap_password = dpos;
+ parse->chap_password_len = dlen;
+ } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
+ avp_code == RADIUS_ATTR_MS_CHAP_CHALLENGE) {
+ wpa_hexdump(MSG_DEBUG,
+ "EAP-TTLS: MS-CHAP-Challenge",
+ dpos, dlen);
+ parse->mschap_challenge = dpos;
+ parse->mschap_challenge_len = dlen;
+ } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
+ avp_code == RADIUS_ATTR_MS_CHAP_RESPONSE) {
+ wpa_hexdump(MSG_DEBUG,
+ "EAP-TTLS: MS-CHAP-Response (MSCHAP)",
+ dpos, dlen);
+ parse->mschap_response = dpos;
+ parse->mschap_response_len = dlen;
+ } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
+ avp_code == RADIUS_ATTR_MS_CHAP2_RESPONSE) {
+ wpa_hexdump(MSG_DEBUG,
+ "EAP-TTLS: MS-CHAP2-Response (MSCHAPV2)",
+ dpos, dlen);
+ parse->mschap2_response = dpos;
+ parse->mschap2_response_len = dlen;
+ } else if (avp_flags & AVP_FLAGS_MANDATORY) {
+ wpa_printf(MSG_WARNING, "EAP-TTLS: Unsupported "
+ "mandatory AVP code %d vendor_id %d - "
+ "dropped", (int) avp_code, (int) vendor_id);
+ goto fail;
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Ignoring unsupported "
+ "AVP code %d vendor_id %d",
+ (int) avp_code, (int) vendor_id);
+ }
+
+ pad = (4 - (avp_length & 3)) & 3;
+ pos += avp_length + pad;
+ left -= avp_length + pad;
+ }
+
+ return 0;
+
+fail:
+ os_free(parse->eap);
+ parse->eap = NULL;
+ return -1;
+}
+
+
+static u8 * eap_ttls_implicit_challenge(struct eap_sm *sm,
+ struct eap_ttls_data *data, size_t len)
+{
+ struct tls_keys keys;
+ u8 *challenge, *rnd;
+
+ if (data->ttls_version == 0) {
+ return eap_server_tls_derive_key(sm, &data->ssl,
+ "ttls challenge", len);
+ }
+
+ os_memset(&keys, 0, sizeof(keys));
+ if (tls_connection_get_keys(sm->ssl_ctx, data->ssl.conn, &keys) ||
+ keys.client_random == NULL || keys.server_random == NULL ||
+ keys.inner_secret == NULL) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Could not get inner secret, "
+ "client random, or server random to derive "
+ "implicit challenge");
+ return NULL;
+ }
+
+ rnd = os_malloc(keys.client_random_len + keys.server_random_len);
+ challenge = os_malloc(len);
+ if (rnd == NULL || challenge == NULL) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: No memory for implicit "
+ "challenge derivation");
+ os_free(rnd);
+ os_free(challenge);
+ return NULL;
+ }
+ os_memcpy(rnd, keys.server_random, keys.server_random_len);
+ os_memcpy(rnd + keys.server_random_len, keys.client_random,
+ keys.client_random_len);
+
+ if (tls_prf(keys.inner_secret, keys.inner_secret_len,
+ "inner application challenge", rnd,
+ keys.client_random_len + keys.server_random_len,
+ challenge, len)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to derive implicit "
+ "challenge");
+ os_free(rnd);
+ os_free(challenge);
+ return NULL;
+ }
+
+ os_free(rnd);
+
+ wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: Derived implicit challenge",
+ challenge, len);
+
+ return challenge;
+}
+
+
+static void * eap_ttls_init(struct eap_sm *sm)
+{
+ struct eap_ttls_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->ttls_version = EAP_TTLS_VERSION;
+ data->force_version = -1;
+ if (sm->user && sm->user->force_version >= 0) {
+ data->force_version = sm->user->force_version;
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: forcing version %d",
+ data->force_version);
+ data->ttls_version = data->force_version;
+ }
+ data->state = START;
+
+ if (!(tls_capabilities(sm->ssl_ctx) & TLS_CAPABILITY_IA) &&
+ data->ttls_version > 0) {
+ if (data->force_version > 0) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Forced TTLSv%d and "
+ "TLS library does not support TLS/IA.",
+ data->force_version);
+ eap_ttls_reset(sm, data);
+ return NULL;
+ }
+ data->ttls_version = 0;
+ }
+
+ if (eap_server_tls_ssl_init(sm, &data->ssl, 0)) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Failed to initialize SSL.");
+ eap_ttls_reset(sm, data);
+ return NULL;
+ }
+
+ return data;
+}
+
+
+static void eap_ttls_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_ttls_data *data = priv;
+ if (data == NULL)
+ return;
+ if (data->phase2_priv && data->phase2_method)
+ data->phase2_method->reset(sm, data->phase2_priv);
+ eap_server_tls_ssl_deinit(sm, &data->ssl);
+ wpabuf_free(data->pending_phase2_eap_resp);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_ttls_build_start(struct eap_sm *sm,
+ struct eap_ttls_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TTLS, 1,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-TTLS: Failed to allocate memory for"
+ " request");
+ eap_ttls_state(data, FAILURE);
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, EAP_TLS_FLAGS_START | data->ttls_version);
+
+ eap_ttls_state(data, PHASE1);
+
+ return req;
+}
+
+
+static struct wpabuf * eap_ttls_build_phase2_eap_req(
+ struct eap_sm *sm, struct eap_ttls_data *data, u8 id)
+{
+ struct wpabuf *buf, *encr_req;
+
+
+ buf = data->phase2_method->buildReq(sm, data->phase2_priv, id);
+ if (buf == NULL)
+ return NULL;
+
+ wpa_hexdump_buf_key(MSG_DEBUG,
+ "EAP-TTLS/EAP: Encapsulate Phase 2 data", buf);
+
+ buf = eap_ttls_avp_encapsulate(buf, RADIUS_ATTR_EAP_MESSAGE, 1);
+ if (buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Failed to encapsulate "
+ "packet");
+ return NULL;
+ }
+
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS/EAP: Encrypt encapsulated "
+ "Phase 2 data", buf);
+
+ encr_req = eap_server_tls_encrypt(sm, &data->ssl, buf);
+ wpabuf_free(buf);
+
+ return encr_req;
+}
+
+
+static struct wpabuf * eap_ttls_build_phase2_mschapv2(
+ struct eap_sm *sm, struct eap_ttls_data *data)
+{
+ struct wpabuf *encr_req, msgbuf;
+ u8 *req, *pos, *end;
+ int ret;
+
+ pos = req = os_malloc(100);
+ if (req == NULL)
+ return NULL;
+ end = req + 100;
+
+ if (data->mschapv2_resp_ok) {
+ pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_MS_CHAP2_SUCCESS,
+ RADIUS_VENDOR_ID_MICROSOFT, 1, 43);
+ *pos++ = data->mschapv2_ident;
+ ret = os_snprintf((char *) pos, end - pos, "S=");
+ if (ret >= 0 && ret < end - pos)
+ pos += ret;
+ pos += wpa_snprintf_hex_uppercase(
+ (char *) pos, end - pos, data->mschapv2_auth_response,
+ sizeof(data->mschapv2_auth_response));
+ } else {
+ pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_MS_CHAP_ERROR,
+ RADIUS_VENDOR_ID_MICROSOFT, 1, 6);
+ os_memcpy(pos, "Failed", 6);
+ pos += 6;
+ AVP_PAD(req, pos);
+ }
+
+ wpabuf_set(&msgbuf, req, pos - req);
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Encrypting Phase 2 "
+ "data", &msgbuf);
+
+ encr_req = eap_server_tls_encrypt(sm, &data->ssl, &msgbuf);
+ os_free(req);
+
+ return encr_req;
+}
+
+
+static struct wpabuf * eap_ttls_build_phase_finished(
+ struct eap_sm *sm, struct eap_ttls_data *data, int final)
+{
+ return tls_connection_ia_send_phase_finished(sm->ssl_ctx,
+ data->ssl.conn, final);
+}
+
+
+static struct wpabuf * eap_ttls_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_ttls_data *data = priv;
+
+ if (data->ssl.state == FRAG_ACK) {
+ return eap_server_tls_build_ack(id, EAP_TYPE_TTLS,
+ data->ttls_version);
+ }
+
+ if (data->ssl.state == WAIT_FRAG_ACK) {
+ return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_TTLS,
+ data->ttls_version, id);
+ }
+
+ switch (data->state) {
+ case START:
+ return eap_ttls_build_start(sm, data, id);
+ case PHASE1:
+ if (tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase1 done, "
+ "starting Phase2");
+ eap_ttls_state(data, PHASE2_START);
+ }
+ break;
+ case PHASE2_METHOD:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_ttls_build_phase2_eap_req(sm, data,
+ id);
+ break;
+ case PHASE2_MSCHAPV2_RESP:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_ttls_build_phase2_mschapv2(sm, data);
+ break;
+ case PHASE_FINISHED:
+ wpabuf_free(data->ssl.tls_out);
+ data->ssl.tls_out_pos = 0;
+ data->ssl.tls_out = eap_ttls_build_phase_finished(sm, data, 1);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: %s - unexpected state %d",
+ __func__, data->state);
+ return NULL;
+ }
+
+ return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_TTLS,
+ data->ttls_version, id);
+}
+
+
+static Boolean eap_ttls_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_TTLS, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static int eap_ttls_ia_permute_inner_secret(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ const u8 *key, size_t key_len)
+{
+ u8 *buf;
+ size_t buf_len;
+ int ret;
+
+ if (key) {
+ buf_len = 2 + key_len;
+ buf = os_malloc(buf_len);
+ if (buf == NULL)
+ return -1;
+ WPA_PUT_BE16(buf, key_len);
+ os_memcpy(buf + 2, key, key_len);
+ } else {
+ buf = NULL;
+ buf_len = 0;
+ }
+
+ wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: Session keys for TLS/IA inner "
+ "secret permutation", buf, buf_len);
+ ret = tls_connection_ia_permute_inner_secret(sm->ssl_ctx,
+ data->ssl.conn,
+ buf, buf_len);
+ os_free(buf);
+
+ return ret;
+}
+
+
+static void eap_ttls_process_phase2_pap(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ const u8 *user_password,
+ size_t user_password_len)
+{
+ if (!sm->user || !sm->user->password || sm->user->password_hash ||
+ !(sm->user->ttls_auth & EAP_TTLS_AUTH_PAP)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/PAP: No plaintext user "
+ "password configured");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (sm->user->password_len != user_password_len ||
+ os_memcmp(sm->user->password, user_password, user_password_len) !=
+ 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/PAP: Invalid user password");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/PAP: Correct user password");
+ eap_ttls_state(data, data->ttls_version > 0 ? PHASE_FINISHED :
+ SUCCESS);
+}
+
+
+static void eap_ttls_process_phase2_chap(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ const u8 *challenge,
+ size_t challenge_len,
+ const u8 *password,
+ size_t password_len)
+{
+ u8 *chal, hash[CHAP_MD5_LEN];
+
+ if (challenge == NULL || password == NULL ||
+ challenge_len != EAP_TTLS_CHAP_CHALLENGE_LEN ||
+ password_len != 1 + EAP_TTLS_CHAP_PASSWORD_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Invalid CHAP attributes "
+ "(challenge len %lu password len %lu)",
+ (unsigned long) challenge_len,
+ (unsigned long) password_len);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (!sm->user || !sm->user->password || sm->user->password_hash ||
+ !(sm->user->ttls_auth & EAP_TTLS_AUTH_CHAP)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: No plaintext user "
+ "password configured");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ chal = eap_ttls_implicit_challenge(sm, data,
+ EAP_TTLS_CHAP_CHALLENGE_LEN + 1);
+ if (chal == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Failed to generate "
+ "challenge from TLS data");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (os_memcmp(challenge, chal, EAP_TTLS_CHAP_CHALLENGE_LEN) != 0 ||
+ password[0] != chal[EAP_TTLS_CHAP_CHALLENGE_LEN]) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Challenge mismatch");
+ os_free(chal);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+ os_free(chal);
+
+ /* MD5(Ident + Password + Challenge) */
+ chap_md5(password[0], sm->user->password, sm->user->password_len,
+ challenge, challenge_len, hash);
+
+ if (os_memcmp(hash, password + 1, EAP_TTLS_CHAP_PASSWORD_LEN) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Correct user password");
+ eap_ttls_state(data, data->ttls_version > 0 ? PHASE_FINISHED :
+ SUCCESS);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Invalid user password");
+ eap_ttls_state(data, FAILURE);
+ }
+}
+
+
+static void eap_ttls_process_phase2_mschap(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ u8 *challenge, size_t challenge_len,
+ u8 *response, size_t response_len)
+{
+ u8 *chal, nt_response[24];
+
+ if (challenge == NULL || response == NULL ||
+ challenge_len != EAP_TTLS_MSCHAP_CHALLENGE_LEN ||
+ response_len != EAP_TTLS_MSCHAP_RESPONSE_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Invalid MS-CHAP "
+ "attributes (challenge len %lu response len %lu)",
+ (unsigned long) challenge_len,
+ (unsigned long) response_len);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (!sm->user || !sm->user->password ||
+ !(sm->user->ttls_auth & EAP_TTLS_AUTH_MSCHAP)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: No user password "
+ "configured");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ chal = eap_ttls_implicit_challenge(sm, data,
+ EAP_TTLS_MSCHAP_CHALLENGE_LEN + 1);
+ if (chal == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Failed to generate "
+ "challenge from TLS data");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (os_memcmp(challenge, chal, EAP_TTLS_MSCHAP_CHALLENGE_LEN) != 0 ||
+ response[0] != chal[EAP_TTLS_MSCHAP_CHALLENGE_LEN]) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Challenge mismatch");
+ os_free(chal);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+ os_free(chal);
+
+ if (sm->user->password_hash)
+ challenge_response(challenge, sm->user->password, nt_response);
+ else
+ nt_challenge_response(challenge, sm->user->password,
+ sm->user->password_len, nt_response);
+
+ if (os_memcmp(nt_response, response + 2 + 24, 24) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Correct response");
+ eap_ttls_state(data, data->ttls_version > 0 ? PHASE_FINISHED :
+ SUCCESS);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Invalid NT-Response");
+ wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAP: Received",
+ response + 2 + 24, 24);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAP: Expected",
+ nt_response, 24);
+ eap_ttls_state(data, FAILURE);
+ }
+}
+
+
+static void eap_ttls_process_phase2_mschapv2(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ u8 *challenge,
+ size_t challenge_len,
+ u8 *response, size_t response_len)
+{
+ u8 *chal, *username, nt_response[24], *rx_resp, *peer_challenge,
+ *auth_challenge;
+ size_t username_len, i;
+
+ if (challenge == NULL || response == NULL ||
+ challenge_len != EAP_TTLS_MSCHAPV2_CHALLENGE_LEN ||
+ response_len != EAP_TTLS_MSCHAPV2_RESPONSE_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Invalid MS-CHAP2 "
+ "attributes (challenge len %lu response len %lu)",
+ (unsigned long) challenge_len,
+ (unsigned long) response_len);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (!sm->user || !sm->user->password ||
+ !(sm->user->ttls_auth & EAP_TTLS_AUTH_MSCHAPV2)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: No user password "
+ "configured");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ /* MSCHAPv2 does not include optional domain name in the
+ * challenge-response calculation, so remove domain prefix
+ * (if present). */
+ username = sm->identity;
+ username_len = sm->identity_len;
+ for (i = 0; i < username_len; i++) {
+ if (username[i] == '\\') {
+ username_len -= i + 1;
+ username += i + 1;
+ break;
+ }
+ }
+
+ chal = eap_ttls_implicit_challenge(
+ sm, data, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN + 1);
+ if (chal == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Failed to generate "
+ "challenge from TLS data");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (os_memcmp(challenge, chal, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN) != 0 ||
+ response[0] != chal[EAP_TTLS_MSCHAPV2_CHALLENGE_LEN]) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Challenge mismatch");
+ os_free(chal);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+ os_free(chal);
+
+ auth_challenge = challenge;
+ peer_challenge = response + 2;
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: User",
+ username, username_len);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: auth_challenge",
+ auth_challenge, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: peer_challenge",
+ peer_challenge, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN);
+
+ if (sm->user->password_hash) {
+ generate_nt_response_pwhash(auth_challenge, peer_challenge,
+ username, username_len,
+ sm->user->password,
+ nt_response);
+ } else {
+ generate_nt_response(auth_challenge, peer_challenge,
+ username, username_len,
+ sm->user->password,
+ sm->user->password_len,
+ nt_response);
+ }
+
+ rx_resp = response + 2 + EAP_TTLS_MSCHAPV2_CHALLENGE_LEN + 8;
+ if (os_memcmp(nt_response, rx_resp, 24) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Correct "
+ "NT-Response");
+ data->mschapv2_resp_ok = 1;
+ if (data->ttls_version > 0) {
+ const u8 *pw_hash;
+ u8 pw_hash_buf[16], pw_hash_hash[16], master_key[16];
+ u8 session_key[2 * MSCHAPV2_KEY_LEN];
+
+ if (sm->user->password_hash)
+ pw_hash = sm->user->password;
+ else {
+ nt_password_hash(sm->user->password,
+ sm->user->password_len,
+ pw_hash_buf);
+ pw_hash = pw_hash_buf;
+ }
+ hash_nt_password_hash(pw_hash, pw_hash_hash);
+ get_master_key(pw_hash_hash, nt_response, master_key);
+ get_asymetric_start_key(master_key, session_key,
+ MSCHAPV2_KEY_LEN, 0, 0);
+ get_asymetric_start_key(master_key,
+ session_key + MSCHAPV2_KEY_LEN,
+ MSCHAPV2_KEY_LEN, 1, 0);
+ eap_ttls_ia_permute_inner_secret(sm, data,
+ session_key,
+ sizeof(session_key));
+ }
+
+ if (sm->user->password_hash) {
+ generate_authenticator_response_pwhash(
+ sm->user->password,
+ peer_challenge, auth_challenge,
+ username, username_len, nt_response,
+ data->mschapv2_auth_response);
+ } else {
+ generate_authenticator_response(
+ sm->user->password, sm->user->password_len,
+ peer_challenge, auth_challenge,
+ username, username_len, nt_response,
+ data->mschapv2_auth_response);
+ }
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Invalid "
+ "NT-Response");
+ wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: Received",
+ rx_resp, 24);
+ wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: Expected",
+ nt_response, 24);
+ data->mschapv2_resp_ok = 0;
+ }
+ eap_ttls_state(data, PHASE2_MSCHAPV2_RESP);
+ data->mschapv2_ident = response[0];
+}
+
+
+static int eap_ttls_phase2_eap_init(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ EapType eap_type)
+{
+ if (data->phase2_priv && data->phase2_method) {
+ data->phase2_method->reset(sm, data->phase2_priv);
+ data->phase2_method = NULL;
+ data->phase2_priv = NULL;
+ }
+ data->phase2_method = eap_server_get_eap_method(EAP_VENDOR_IETF,
+ eap_type);
+ if (!data->phase2_method)
+ return -1;
+
+ sm->init_phase2 = 1;
+ data->phase2_priv = data->phase2_method->init(sm);
+ sm->init_phase2 = 0;
+ return data->phase2_priv == NULL ? -1 : 0;
+}
+
+
+static void eap_ttls_process_phase2_eap_response(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ u8 *in_data, size_t in_len)
+{
+ u8 next_type = EAP_TYPE_NONE;
+ struct eap_hdr *hdr;
+ u8 *pos;
+ size_t left;
+ struct wpabuf buf;
+ const struct eap_method *m = data->phase2_method;
+ void *priv = data->phase2_priv;
+
+ if (priv == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: %s - Phase2 not "
+ "initialized?!", __func__);
+ return;
+ }
+
+ hdr = (struct eap_hdr *) in_data;
+ pos = (u8 *) (hdr + 1);
+
+ if (in_len > sizeof(*hdr) && *pos == EAP_TYPE_NAK) {
+ left = in_len - sizeof(*hdr);
+ wpa_hexdump(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 type Nak'ed; "
+ "allowed types", pos + 1, left - 1);
+ eap_sm_process_nak(sm, pos + 1, left - 1);
+ if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
+ sm->user->methods[sm->user_eap_method_index].method !=
+ EAP_TYPE_NONE) {
+ next_type = sm->user->methods[
+ sm->user_eap_method_index++].method;
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: try EAP type %d",
+ next_type);
+ if (eap_ttls_phase2_eap_init(sm, data, next_type)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to "
+ "initialize EAP type %d",
+ next_type);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+ } else {
+ eap_ttls_state(data, FAILURE);
+ }
+ return;
+ }
+
+ wpabuf_set(&buf, in_data, in_len);
+
+ if (m->check(sm, priv, &buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 check() asked to "
+ "ignore the packet");
+ return;
+ }
+
+ m->process(sm, priv, &buf);
+
+ if (sm->method_pending == METHOD_PENDING_WAIT) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 method is in "
+ "pending wait state - save decrypted response");
+ wpabuf_free(data->pending_phase2_eap_resp);
+ data->pending_phase2_eap_resp = wpabuf_dup(&buf);
+ }
+
+ if (!m->isDone(sm, priv))
+ return;
+
+ if (!m->isSuccess(sm, priv)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 method failed");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ switch (data->state) {
+ case PHASE2_START:
+ if (eap_user_get(sm, sm->identity, sm->identity_len, 1) != 0) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP_TTLS: Phase2 "
+ "Identity not found in the user "
+ "database",
+ sm->identity, sm->identity_len);
+ eap_ttls_state(data, FAILURE);
+ break;
+ }
+
+ eap_ttls_state(data, PHASE2_METHOD);
+ next_type = sm->user->methods[0].method;
+ sm->user_eap_method_index = 1;
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: try EAP type %d", next_type);
+ if (eap_ttls_phase2_eap_init(sm, data, next_type)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to initialize "
+ "EAP type %d", next_type);
+ eap_ttls_state(data, FAILURE);
+ }
+ break;
+ case PHASE2_METHOD:
+ if (data->ttls_version > 0) {
+ if (m->getKey) {
+ u8 *key;
+ size_t key_len;
+ key = m->getKey(sm, priv, &key_len);
+ eap_ttls_ia_permute_inner_secret(sm, data,
+ key, key_len);
+ }
+ eap_ttls_state(data, PHASE_FINISHED);
+ } else
+ eap_ttls_state(data, SUCCESS);
+ break;
+ case FAILURE:
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: %s - unexpected state %d",
+ __func__, data->state);
+ break;
+ }
+}
+
+
+static void eap_ttls_process_phase2_eap(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ const u8 *eap, size_t eap_len)
+{
+ struct eap_hdr *hdr;
+ size_t len;
+
+ if (data->state == PHASE2_START) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: initializing Phase 2");
+ if (eap_ttls_phase2_eap_init(sm, data, EAP_TYPE_IDENTITY) < 0)
+ {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: failed to "
+ "initialize EAP-Identity");
+ return;
+ }
+ }
+
+ if (eap_len < sizeof(*hdr)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: too short Phase 2 EAP "
+ "packet (len=%lu)", (unsigned long) eap_len);
+ return;
+ }
+
+ hdr = (struct eap_hdr *) eap;
+ len = be_to_host16(hdr->length);
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: received Phase 2 EAP: code=%d "
+ "identifier=%d length=%lu", hdr->code, hdr->identifier,
+ (unsigned long) len);
+ if (len > eap_len) {
+ wpa_printf(MSG_INFO, "EAP-TTLS/EAP: Length mismatch in Phase 2"
+ " EAP frame (hdr len=%lu, data len in AVP=%lu)",
+ (unsigned long) len, (unsigned long) eap_len);
+ return;
+ }
+
+ switch (hdr->code) {
+ case EAP_CODE_RESPONSE:
+ eap_ttls_process_phase2_eap_response(sm, data, (u8 *) hdr,
+ len);
+ break;
+ default:
+ wpa_printf(MSG_INFO, "EAP-TTLS/EAP: Unexpected code=%d in "
+ "Phase 2 EAP header", hdr->code);
+ break;
+ }
+}
+
+
+static void eap_ttls_process_phase2(struct eap_sm *sm,
+ struct eap_ttls_data *data,
+ struct wpabuf *in_buf)
+{
+ struct wpabuf *in_decrypted;
+ struct eap_ttls_avp parse;
+
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: received %lu bytes encrypted data for"
+ " Phase 2", (unsigned long) wpabuf_len(in_buf));
+
+ if (data->pending_phase2_eap_resp) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Pending Phase 2 EAP response "
+ "- skip decryption and use old data");
+ eap_ttls_process_phase2_eap(
+ sm, data, wpabuf_head(data->pending_phase2_eap_resp),
+ wpabuf_len(data->pending_phase2_eap_resp));
+ wpabuf_free(data->pending_phase2_eap_resp);
+ data->pending_phase2_eap_resp = NULL;
+ return;
+ }
+
+ in_decrypted = tls_connection_decrypt(sm->ssl_ctx, data->ssl.conn,
+ in_buf);
+ if (in_decrypted == NULL) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Failed to decrypt Phase 2 "
+ "data");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (data->state == PHASE_FINISHED) {
+ if (wpabuf_len(in_decrypted) == 0 &&
+ tls_connection_ia_final_phase_finished(sm->ssl_ctx,
+ data->ssl.conn)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: FinalPhaseFinished "
+ "received");
+ eap_ttls_state(data, SUCCESS);
+ } else {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Did not receive valid "
+ "FinalPhaseFinished");
+ eap_ttls_state(data, FAILURE);
+ }
+
+ wpabuf_free(in_decrypted);
+ return;
+ }
+
+ wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS: Decrypted Phase 2 EAP",
+ in_decrypted);
+
+ if (eap_ttls_avp_parse(in_decrypted, &parse) < 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to parse AVPs");
+ wpabuf_free(in_decrypted);
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ if (parse.user_name) {
+ os_free(sm->identity);
+ sm->identity = os_malloc(parse.user_name_len);
+ if (sm->identity) {
+ os_memcpy(sm->identity, parse.user_name,
+ parse.user_name_len);
+ sm->identity_len = parse.user_name_len;
+ }
+ if (eap_user_get(sm, parse.user_name, parse.user_name_len, 1)
+ != 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase2 Identity not "
+ "found in the user database");
+ eap_ttls_state(data, FAILURE);
+ goto done;
+ }
+ }
+
+#ifdef EAP_SERVER_TNC
+ if (data->tnc_started && parse.eap == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: TNC started but no EAP "
+ "response from peer");
+ eap_ttls_state(data, FAILURE);
+ goto done;
+ }
+#endif /* EAP_SERVER_TNC */
+
+ if (parse.eap) {
+ eap_ttls_process_phase2_eap(sm, data, parse.eap,
+ parse.eap_len);
+ } else if (parse.user_password) {
+ eap_ttls_process_phase2_pap(sm, data, parse.user_password,
+ parse.user_password_len);
+ } else if (parse.chap_password) {
+ eap_ttls_process_phase2_chap(sm, data,
+ parse.chap_challenge,
+ parse.chap_challenge_len,
+ parse.chap_password,
+ parse.chap_password_len);
+ } else if (parse.mschap_response) {
+ eap_ttls_process_phase2_mschap(sm, data,
+ parse.mschap_challenge,
+ parse.mschap_challenge_len,
+ parse.mschap_response,
+ parse.mschap_response_len);
+ } else if (parse.mschap2_response) {
+ eap_ttls_process_phase2_mschapv2(sm, data,
+ parse.mschap_challenge,
+ parse.mschap_challenge_len,
+ parse.mschap2_response,
+ parse.mschap2_response_len);
+ }
+
+done:
+ wpabuf_free(in_decrypted);
+ os_free(parse.eap);
+}
+
+
+static void eap_ttls_start_tnc(struct eap_sm *sm, struct eap_ttls_data *data)
+{
+#ifdef EAP_SERVER_TNC
+ if (!sm->tnc || data->state != SUCCESS || data->tnc_started)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Initialize TNC");
+ if (eap_ttls_phase2_eap_init(sm, data, EAP_TYPE_TNC)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to initialize TNC");
+ eap_ttls_state(data, FAILURE);
+ return;
+ }
+
+ data->tnc_started = 1;
+ eap_ttls_state(data, PHASE2_METHOD);
+#endif /* EAP_SERVER_TNC */
+}
+
+
+static int eap_ttls_process_version(struct eap_sm *sm, void *priv,
+ int peer_version)
+{
+ struct eap_ttls_data *data = priv;
+ if (peer_version < data->ttls_version) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: peer ver=%d, own ver=%d; "
+ "use version %d",
+ peer_version, data->ttls_version, peer_version);
+ data->ttls_version = peer_version;
+ }
+
+ if (data->ttls_version > 0 && !data->tls_ia_configured) {
+ if (tls_connection_set_ia(sm->ssl_ctx, data->ssl.conn, 1)) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Failed to enable "
+ "TLS/IA");
+ return -1;
+ }
+ data->tls_ia_configured = 1;
+ }
+
+ return 0;
+}
+
+
+static void eap_ttls_process_msg(struct eap_sm *sm, void *priv,
+ const struct wpabuf *respData)
+{
+ struct eap_ttls_data *data = priv;
+
+ switch (data->state) {
+ case PHASE1:
+ if (eap_server_tls_phase1(sm, &data->ssl) < 0)
+ eap_ttls_state(data, FAILURE);
+ break;
+ case PHASE2_START:
+ case PHASE2_METHOD:
+ case PHASE_FINISHED:
+ eap_ttls_process_phase2(sm, data, data->ssl.tls_in);
+ eap_ttls_start_tnc(sm, data);
+ break;
+ case PHASE2_MSCHAPV2_RESP:
+ if (data->mschapv2_resp_ok && wpabuf_len(data->ssl.tls_in) ==
+ 0) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Peer "
+ "acknowledged response");
+ eap_ttls_state(data, data->ttls_version > 0 ?
+ PHASE_FINISHED : SUCCESS);
+ } else if (!data->mschapv2_resp_ok) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Peer "
+ "acknowledged error");
+ eap_ttls_state(data, FAILURE);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Unexpected "
+ "frame from peer (payload len %lu, "
+ "expected empty frame)",
+ (unsigned long)
+ wpabuf_len(data->ssl.tls_in));
+ eap_ttls_state(data, FAILURE);
+ }
+ eap_ttls_start_tnc(sm, data);
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Unexpected state %d in %s",
+ data->state, __func__);
+ break;
+ }
+}
+
+
+static void eap_ttls_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_ttls_data *data = priv;
+ if (eap_server_tls_process(sm, &data->ssl, respData, data,
+ EAP_TYPE_TTLS, eap_ttls_process_version,
+ eap_ttls_process_msg) < 0)
+ eap_ttls_state(data, FAILURE);
+}
+
+
+static Boolean eap_ttls_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_ttls_data *data = priv;
+ return data->state == SUCCESS || data->state == FAILURE;
+}
+
+
+static u8 * eap_ttls_v1_derive_key(struct eap_sm *sm,
+ struct eap_ttls_data *data)
+{
+ struct tls_keys keys;
+ u8 *rnd, *key;
+
+ os_memset(&keys, 0, sizeof(keys));
+ if (tls_connection_get_keys(sm->ssl_ctx, data->ssl.conn, &keys) ||
+ keys.client_random == NULL || keys.server_random == NULL ||
+ keys.inner_secret == NULL) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: Could not get inner secret, "
+ "client random, or server random to derive keying "
+ "material");
+ return NULL;
+ }
+
+ rnd = os_malloc(keys.client_random_len + keys.server_random_len);
+ key = os_malloc(EAP_TLS_KEY_LEN);
+ if (rnd == NULL || key == NULL) {
+ wpa_printf(MSG_INFO, "EAP-TTLS: No memory for key derivation");
+ os_free(rnd);
+ os_free(key);
+ return NULL;
+ }
+ os_memcpy(rnd, keys.client_random, keys.client_random_len);
+ os_memcpy(rnd + keys.client_random_len, keys.server_random,
+ keys.server_random_len);
+
+ if (tls_prf(keys.inner_secret, keys.inner_secret_len,
+ "ttls v1 keying material", rnd, keys.client_random_len +
+ keys.server_random_len, key, EAP_TLS_KEY_LEN)) {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to derive key");
+ os_free(rnd);
+ os_free(key);
+ return NULL;
+ }
+
+ wpa_hexdump(MSG_DEBUG, "EAP-TTLS: client/server random",
+ rnd, keys.client_random_len + keys.server_random_len);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: TLS/IA inner secret",
+ keys.inner_secret, keys.inner_secret_len);
+
+ os_free(rnd);
+
+ return key;
+}
+
+
+static u8 * eap_ttls_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_ttls_data *data = priv;
+ u8 *eapKeyData;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ if (data->ttls_version == 0) {
+ eapKeyData = eap_server_tls_derive_key(sm, &data->ssl,
+ "ttls keying material",
+ EAP_TLS_KEY_LEN);
+ } else {
+ eapKeyData = eap_ttls_v1_derive_key(sm, data);
+ }
+
+ if (eapKeyData) {
+ *len = EAP_TLS_KEY_LEN;
+ wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: Derived key",
+ eapKeyData, EAP_TLS_KEY_LEN);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to derive key");
+ }
+
+ return eapKeyData;
+}
+
+
+static Boolean eap_ttls_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_ttls_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_ttls_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_IETF, EAP_TYPE_TTLS, "TTLS");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_ttls_init;
+ eap->reset = eap_ttls_reset;
+ eap->buildReq = eap_ttls_buildReq;
+ eap->check = eap_ttls_check;
+ eap->process = eap_ttls_process;
+ eap->isDone = eap_ttls_isDone;
+ eap->getKey = eap_ttls_getKey;
+ eap->isSuccess = eap_ttls_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_vendor_test.c b/src/eap_server/eap_server_vendor_test.c
new file mode 100644
index 0000000..0dd0aca
--- /dev/null
+++ b/src/eap_server/eap_server_vendor_test.c
@@ -0,0 +1,198 @@
+/*
+ * hostapd / Test method for vendor specific (expanded) EAP type
+ * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eap_i.h"
+
+
+#define EAP_VENDOR_ID 0xfffefd
+#define EAP_VENDOR_TYPE 0xfcfbfaf9
+
+
+struct eap_vendor_test_data {
+ enum { INIT, CONFIRM, SUCCESS, FAILURE } state;
+};
+
+
+static const char * eap_vendor_test_state_txt(int state)
+{
+ switch (state) {
+ case INIT:
+ return "INIT";
+ case CONFIRM:
+ return "CONFIRM";
+ case SUCCESS:
+ return "SUCCESS";
+ case FAILURE:
+ return "FAILURE";
+ default:
+ return "?";
+ }
+}
+
+
+static void eap_vendor_test_state(struct eap_vendor_test_data *data,
+ int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: %s -> %s",
+ eap_vendor_test_state_txt(data->state),
+ eap_vendor_test_state_txt(state));
+ data->state = state;
+}
+
+
+static void * eap_vendor_test_init(struct eap_sm *sm)
+{
+ struct eap_vendor_test_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = INIT;
+
+ return data;
+}
+
+
+static void eap_vendor_test_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_vendor_test_data *data = priv;
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_vendor_test_buildReq(struct eap_sm *sm, void *priv,
+ u8 id)
+{
+ struct eap_vendor_test_data *data = priv;
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_ID, EAP_VENDOR_TYPE, 1,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-VENDOR-TEST: Failed to allocate "
+ "memory for request");
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, data->state == INIT ? 1 : 3);
+
+ return req;
+}
+
+
+static Boolean eap_vendor_test_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_ID, EAP_VENDOR_TYPE, respData, &len);
+ if (pos == NULL || len < 1) {
+ wpa_printf(MSG_INFO, "EAP-VENDOR-TEST: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static void eap_vendor_test_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_vendor_test_data *data = priv;
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_ID, EAP_VENDOR_TYPE, respData, &len);
+ if (pos == NULL || len < 1)
+ return;
+
+ if (data->state == INIT) {
+ if (*pos == 2)
+ eap_vendor_test_state(data, CONFIRM);
+ else
+ eap_vendor_test_state(data, FAILURE);
+ } else if (data->state == CONFIRM) {
+ if (*pos == 4)
+ eap_vendor_test_state(data, SUCCESS);
+ else
+ eap_vendor_test_state(data, FAILURE);
+ } else
+ eap_vendor_test_state(data, FAILURE);
+}
+
+
+static Boolean eap_vendor_test_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_vendor_test_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+static u8 * eap_vendor_test_getKey(struct eap_sm *sm, void *priv, size_t *len)
+{
+ struct eap_vendor_test_data *data = priv;
+ u8 *key;
+ const int key_len = 64;
+
+ if (data->state != SUCCESS)
+ return NULL;
+
+ key = os_malloc(key_len);
+ if (key == NULL)
+ return NULL;
+
+ os_memset(key, 0x11, key_len / 2);
+ os_memset(key + key_len / 2, 0x22, key_len / 2);
+ *len = key_len;
+
+ return key;
+}
+
+
+static Boolean eap_vendor_test_isSuccess(struct eap_sm *sm, void *priv)
+{
+ struct eap_vendor_test_data *data = priv;
+ return data->state == SUCCESS;
+}
+
+
+int eap_server_vendor_test_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_ID, EAP_VENDOR_TYPE,
+ "VENDOR-TEST");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_vendor_test_init;
+ eap->reset = eap_vendor_test_reset;
+ eap->buildReq = eap_vendor_test_buildReq;
+ eap->check = eap_vendor_test_check;
+ eap->process = eap_vendor_test_process;
+ eap->isDone = eap_vendor_test_isDone;
+ eap->getKey = eap_vendor_test_getKey;
+ eap->isSuccess = eap_vendor_test_isSuccess;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_server_wsc.c b/src/eap_server/eap_server_wsc.c
new file mode 100644
index 0000000..e944a4d
--- /dev/null
+++ b/src/eap_server/eap_server_wsc.c
@@ -0,0 +1,517 @@
+/*
+ * EAP-WSC server for Wi-Fi Protected Setup
+ * Copyright (c) 2007-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "eloop.h"
+#include "eap_i.h"
+#include "eap_common/eap_wsc_common.h"
+#include "p2p/p2p.h"
+#include "wps/wps.h"
+
+
+struct eap_wsc_data {
+ enum { START, MESG, FRAG_ACK, WAIT_FRAG_ACK, DONE, FAIL } state;
+ int registrar;
+ struct wpabuf *in_buf;
+ struct wpabuf *out_buf;
+ enum wsc_op_code in_op_code, out_op_code;
+ size_t out_used;
+ size_t fragment_size;
+ struct wps_data *wps;
+ int ext_reg_timeout;
+};
+
+
+#ifndef CONFIG_NO_STDOUT_DEBUG
+static const char * eap_wsc_state_txt(int state)
+{
+ switch (state) {
+ case START:
+ return "START";
+ case MESG:
+ return "MESG";
+ case FRAG_ACK:
+ return "FRAG_ACK";
+ case WAIT_FRAG_ACK:
+ return "WAIT_FRAG_ACK";
+ case DONE:
+ return "DONE";
+ case FAIL:
+ return "FAIL";
+ default:
+ return "?";
+ }
+}
+#endif /* CONFIG_NO_STDOUT_DEBUG */
+
+
+static void eap_wsc_state(struct eap_wsc_data *data, int state)
+{
+ wpa_printf(MSG_DEBUG, "EAP-WSC: %s -> %s",
+ eap_wsc_state_txt(data->state),
+ eap_wsc_state_txt(state));
+ data->state = state;
+}
+
+
+static void eap_wsc_ext_reg_timeout(void *eloop_ctx, void *timeout_ctx)
+{
+ struct eap_sm *sm = eloop_ctx;
+ struct eap_wsc_data *data = timeout_ctx;
+
+ if (sm->method_pending != METHOD_PENDING_WAIT)
+ return;
+
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Timeout while waiting for an External "
+ "Registrar");
+ data->ext_reg_timeout = 1;
+ eap_sm_pending_cb(sm);
+}
+
+
+static void * eap_wsc_init(struct eap_sm *sm)
+{
+ struct eap_wsc_data *data;
+ int registrar;
+ struct wps_config cfg;
+
+ if (sm->identity && sm->identity_len == WSC_ID_REGISTRAR_LEN &&
+ os_memcmp(sm->identity, WSC_ID_REGISTRAR, WSC_ID_REGISTRAR_LEN) ==
+ 0)
+ registrar = 0; /* Supplicant is Registrar */
+ else if (sm->identity && sm->identity_len == WSC_ID_ENROLLEE_LEN &&
+ os_memcmp(sm->identity, WSC_ID_ENROLLEE, WSC_ID_ENROLLEE_LEN)
+ == 0)
+ registrar = 1; /* Supplicant is Enrollee */
+ else {
+ wpa_hexdump_ascii(MSG_INFO, "EAP-WSC: Unexpected identity",
+ sm->identity, sm->identity_len);
+ return NULL;
+ }
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+ data->state = registrar ? START : MESG;
+ data->registrar = registrar;
+
+ os_memset(&cfg, 0, sizeof(cfg));
+ cfg.wps = sm->wps;
+ cfg.registrar = registrar;
+ if (registrar) {
+ if (sm->wps == NULL || sm->wps->registrar == NULL) {
+ wpa_printf(MSG_INFO, "EAP-WSC: WPS Registrar not "
+ "initialized");
+ os_free(data);
+ return NULL;
+ }
+ } else {
+ if (sm->user == NULL || sm->user->password == NULL) {
+ /*
+ * In theory, this should not really be needed, but
+ * Windows 7 uses Registrar mode to probe AP's WPS
+ * capabilities before trying to use Enrollee and fails
+ * if the AP does not allow that probing to happen..
+ */
+ wpa_printf(MSG_DEBUG, "EAP-WSC: No AP PIN (password) "
+ "configured for Enrollee functionality - "
+ "allow for probing capabilities (M1)");
+ } else {
+ cfg.pin = sm->user->password;
+ cfg.pin_len = sm->user->password_len;
+ }
+ }
+ cfg.assoc_wps_ie = sm->assoc_wps_ie;
+ cfg.peer_addr = sm->peer_addr;
+#ifdef CONFIG_P2P
+ if (sm->assoc_p2p_ie) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Prefer PSK format for P2P "
+ "client");
+ cfg.use_psk_key = 1;
+ cfg.p2p_dev_addr = p2p_get_go_dev_addr(sm->assoc_p2p_ie);
+ }
+#endif /* CONFIG_P2P */
+ data->wps = wps_init(&cfg);
+ if (data->wps == NULL) {
+ os_free(data);
+ return NULL;
+ }
+ data->fragment_size = sm->fragment_size > 0 ? sm->fragment_size :
+ WSC_FRAGMENT_SIZE;
+
+ return data;
+}
+
+
+static void eap_wsc_reset(struct eap_sm *sm, void *priv)
+{
+ struct eap_wsc_data *data = priv;
+ eloop_cancel_timeout(eap_wsc_ext_reg_timeout, sm, data);
+ wpabuf_free(data->in_buf);
+ wpabuf_free(data->out_buf);
+ wps_deinit(data->wps);
+ os_free(data);
+}
+
+
+static struct wpabuf * eap_wsc_build_start(struct eap_sm *sm,
+ struct eap_wsc_data *data, u8 id)
+{
+ struct wpabuf *req;
+
+ req = eap_msg_alloc(EAP_VENDOR_WFA, EAP_VENDOR_TYPE_WSC, 2,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-WSC: Failed to allocate memory for "
+ "request");
+ return NULL;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Send WSC/Start");
+ wpabuf_put_u8(req, WSC_Start); /* Op-Code */
+ wpabuf_put_u8(req, 0); /* Flags */
+
+ return req;
+}
+
+
+static struct wpabuf * eap_wsc_build_msg(struct eap_wsc_data *data, u8 id)
+{
+ struct wpabuf *req;
+ u8 flags;
+ size_t send_len, plen;
+
+ flags = 0;
+ send_len = wpabuf_len(data->out_buf) - data->out_used;
+ if (2 + send_len > data->fragment_size) {
+ send_len = data->fragment_size - 2;
+ flags |= WSC_FLAGS_MF;
+ if (data->out_used == 0) {
+ flags |= WSC_FLAGS_LF;
+ send_len -= 2;
+ }
+ }
+ plen = 2 + send_len;
+ if (flags & WSC_FLAGS_LF)
+ plen += 2;
+ req = eap_msg_alloc(EAP_VENDOR_WFA, EAP_VENDOR_TYPE_WSC, plen,
+ EAP_CODE_REQUEST, id);
+ if (req == NULL) {
+ wpa_printf(MSG_ERROR, "EAP-WSC: Failed to allocate memory for "
+ "request");
+ return NULL;
+ }
+
+ wpabuf_put_u8(req, data->out_op_code); /* Op-Code */
+ wpabuf_put_u8(req, flags); /* Flags */
+ if (flags & WSC_FLAGS_LF)
+ wpabuf_put_be16(req, wpabuf_len(data->out_buf));
+
+ wpabuf_put_data(req, wpabuf_head_u8(data->out_buf) + data->out_used,
+ send_len);
+ data->out_used += send_len;
+
+ if (data->out_used == wpabuf_len(data->out_buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Sending out %lu bytes "
+ "(message sent completely)",
+ (unsigned long) send_len);
+ wpabuf_free(data->out_buf);
+ data->out_buf = NULL;
+ data->out_used = 0;
+ eap_wsc_state(data, MESG);
+ } else {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Sending out %lu bytes "
+ "(%lu more to send)", (unsigned long) send_len,
+ (unsigned long) wpabuf_len(data->out_buf) -
+ data->out_used);
+ eap_wsc_state(data, WAIT_FRAG_ACK);
+ }
+
+ return req;
+}
+
+
+static struct wpabuf * eap_wsc_buildReq(struct eap_sm *sm, void *priv, u8 id)
+{
+ struct eap_wsc_data *data = priv;
+
+ switch (data->state) {
+ case START:
+ return eap_wsc_build_start(sm, data, id);
+ case MESG:
+ if (data->out_buf == NULL) {
+ data->out_buf = wps_get_msg(data->wps,
+ &data->out_op_code);
+ if (data->out_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Failed to "
+ "receive message from WPS");
+ return NULL;
+ }
+ data->out_used = 0;
+ }
+ /* pass through */
+ case WAIT_FRAG_ACK:
+ return eap_wsc_build_msg(data, id);
+ case FRAG_ACK:
+ return eap_wsc_build_frag_ack(id, EAP_CODE_REQUEST);
+ default:
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Unexpected state %d in "
+ "buildReq", data->state);
+ return NULL;
+ }
+}
+
+
+static Boolean eap_wsc_check(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ const u8 *pos;
+ size_t len;
+
+ pos = eap_hdr_validate(EAP_VENDOR_WFA, EAP_VENDOR_TYPE_WSC,
+ respData, &len);
+ if (pos == NULL || len < 2) {
+ wpa_printf(MSG_INFO, "EAP-WSC: Invalid frame");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static int eap_wsc_process_cont(struct eap_wsc_data *data,
+ const u8 *buf, size_t len, u8 op_code)
+{
+ /* Process continuation of a pending message */
+ if (op_code != data->in_op_code) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Unexpected Op-Code %d in "
+ "fragment (expected %d)",
+ op_code, data->in_op_code);
+ eap_wsc_state(data, FAIL);
+ return -1;
+ }
+
+ if (len > wpabuf_tailroom(data->in_buf)) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Fragment overflow");
+ eap_wsc_state(data, FAIL);
+ return -1;
+ }
+
+ wpabuf_put_data(data->in_buf, buf, len);
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Received %lu bytes, waiting for %lu "
+ "bytes more", (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->in_buf));
+
+ return 0;
+}
+
+
+static int eap_wsc_process_fragment(struct eap_wsc_data *data,
+ u8 flags, u8 op_code, u16 message_length,
+ const u8 *buf, size_t len)
+{
+ /* Process a fragment that is not the last one of the message */
+ if (data->in_buf == NULL && !(flags & WSC_FLAGS_LF)) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: No Message Length "
+ "field in a fragmented packet");
+ return -1;
+ }
+
+ if (data->in_buf == NULL) {
+ /* First fragment of the message */
+ data->in_buf = wpabuf_alloc(message_length);
+ if (data->in_buf == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: No memory for "
+ "message");
+ return -1;
+ }
+ data->in_op_code = op_code;
+ wpabuf_put_data(data->in_buf, buf, len);
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Received %lu bytes in "
+ "first fragment, waiting for %lu bytes more",
+ (unsigned long) len,
+ (unsigned long) wpabuf_tailroom(data->in_buf));
+ }
+
+ return 0;
+}
+
+
+static void eap_wsc_process(struct eap_sm *sm, void *priv,
+ struct wpabuf *respData)
+{
+ struct eap_wsc_data *data = priv;
+ const u8 *start, *pos, *end;
+ size_t len;
+ u8 op_code, flags;
+ u16 message_length = 0;
+ enum wps_process_res res;
+ struct wpabuf tmpbuf;
+
+ eloop_cancel_timeout(eap_wsc_ext_reg_timeout, sm, data);
+ if (data->ext_reg_timeout) {
+ eap_wsc_state(data, FAIL);
+ return;
+ }
+
+ pos = eap_hdr_validate(EAP_VENDOR_WFA, EAP_VENDOR_TYPE_WSC,
+ respData, &len);
+ if (pos == NULL || len < 2)
+ return; /* Should not happen; message already verified */
+
+ start = pos;
+ end = start + len;
+
+ op_code = *pos++;
+ flags = *pos++;
+ if (flags & WSC_FLAGS_LF) {
+ if (end - pos < 2) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Message underflow");
+ return;
+ }
+ message_length = WPA_GET_BE16(pos);
+ pos += 2;
+
+ if (message_length < end - pos) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Invalid Message "
+ "Length");
+ return;
+ }
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Received packet: Op-Code %d "
+ "Flags 0x%x Message Length %d",
+ op_code, flags, message_length);
+
+ if (data->state == WAIT_FRAG_ACK) {
+ if (op_code != WSC_FRAG_ACK) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Unexpected Op-Code %d "
+ "in WAIT_FRAG_ACK state", op_code);
+ eap_wsc_state(data, FAIL);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Fragment acknowledged");
+ eap_wsc_state(data, MESG);
+ return;
+ }
+
+ if (op_code != WSC_ACK && op_code != WSC_NACK && op_code != WSC_MSG &&
+ op_code != WSC_Done) {
+ wpa_printf(MSG_DEBUG, "EAP-WSC: Unexpected Op-Code %d",
+ op_code);
+ eap_wsc_state(data, FAIL);
+ return;
+ }
+
+ if (data->in_buf &&
+ eap_wsc_process_cont(data, pos, end - pos, op_code) < 0) {
+ eap_wsc_state(data, FAIL);
+ return;
+ }
+
+ if (flags & WSC_FLAGS_MF) {
+ if (eap_wsc_process_fragment(data, flags, op_code,
+ message_length, pos, end - pos) <
+ 0)
+ eap_wsc_state(data, FAIL);
+ else
+ eap_wsc_state(data, FRAG_ACK);
+ return;
+ }
+
+ if (data->in_buf == NULL) {
+ /* Wrap unfragmented messages as wpabuf without extra copy */
+ wpabuf_set(&tmpbuf, pos, end - pos);
+ data->in_buf = &tmpbuf;
+ }
+
+ res = wps_process_msg(data->wps, op_code, data->in_buf);
+ switch (res) {
+ case WPS_DONE:
+ wpa_printf(MSG_DEBUG, "EAP-WSC: WPS processing completed "
+ "successfully - report EAP failure");
+ eap_wsc_state(data, FAIL);
+ break;
+ case WPS_CONTINUE:
+ eap_wsc_state(data, MESG);
+ break;
+ case WPS_FAILURE:
+ wpa_printf(MSG_DEBUG, "EAP-WSC: WPS processing failed");
+ eap_wsc_state(data, FAIL);
+ break;
+ case WPS_PENDING:
+ eap_wsc_state(data, MESG);
+ sm->method_pending = METHOD_PENDING_WAIT;
+ eloop_cancel_timeout(eap_wsc_ext_reg_timeout, sm, data);
+ eloop_register_timeout(5, 0, eap_wsc_ext_reg_timeout,
+ sm, data);
+ break;
+ }
+
+ if (data->in_buf != &tmpbuf)
+ wpabuf_free(data->in_buf);
+ data->in_buf = NULL;
+}
+
+
+static Boolean eap_wsc_isDone(struct eap_sm *sm, void *priv)
+{
+ struct eap_wsc_data *data = priv;
+ return data->state == FAIL;
+}
+
+
+static Boolean eap_wsc_isSuccess(struct eap_sm *sm, void *priv)
+{
+ /* EAP-WSC will always result in EAP-Failure */
+ return FALSE;
+}
+
+
+static int eap_wsc_getTimeout(struct eap_sm *sm, void *priv)
+{
+ /* Recommended retransmit times: retransmit timeout 5 seconds,
+ * per-message timeout 15 seconds, i.e., 3 tries. */
+ sm->MaxRetrans = 2; /* total 3 attempts */
+ return 5;
+}
+
+
+int eap_server_wsc_register(void)
+{
+ struct eap_method *eap;
+ int ret;
+
+ eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
+ EAP_VENDOR_WFA, EAP_VENDOR_TYPE_WSC,
+ "WSC");
+ if (eap == NULL)
+ return -1;
+
+ eap->init = eap_wsc_init;
+ eap->reset = eap_wsc_reset;
+ eap->buildReq = eap_wsc_buildReq;
+ eap->check = eap_wsc_check;
+ eap->process = eap_wsc_process;
+ eap->isDone = eap_wsc_isDone;
+ eap->isSuccess = eap_wsc_isSuccess;
+ eap->getTimeout = eap_wsc_getTimeout;
+
+ ret = eap_server_method_register(eap);
+ if (ret)
+ eap_server_method_free(eap);
+ return ret;
+}
diff --git a/src/eap_server/eap_sim_db.c b/src/eap_server/eap_sim_db.c
new file mode 100644
index 0000000..248b216
--- /dev/null
+++ b/src/eap_server/eap_sim_db.c
@@ -0,0 +1,1338 @@
+/*
+ * hostapd / EAP-SIM database/authenticator gateway
+ * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ *
+ * This is an example implementation of the EAP-SIM/AKA database/authentication
+ * gateway interface that is using an external program as an SS7 gateway to
+ * GSM/UMTS authentication center (HLR/AuC). hlr_auc_gw is an example
+ * implementation of such a gateway program. This eap_sim_db.c takes care of
+ * EAP-SIM/AKA pseudonyms and re-auth identities. It can be used with different
+ * gateway implementations for HLR/AuC access. Alternatively, it can also be
+ * completely replaced if the in-memory database of pseudonyms/re-auth
+ * identities is not suitable for some cases.
+ */
+
+#include "includes.h"
+#include <sys/un.h>
+
+#include "common.h"
+#include "crypto/random.h"
+#include "eap_common/eap_sim_common.h"
+#include "eap_server/eap_sim_db.h"
+#include "eloop.h"
+
+struct eap_sim_pseudonym {
+ struct eap_sim_pseudonym *next;
+ u8 *identity;
+ size_t identity_len;
+ char *pseudonym;
+};
+
+struct eap_sim_db_pending {
+ struct eap_sim_db_pending *next;
+ u8 imsi[20];
+ size_t imsi_len;
+ enum { PENDING, SUCCESS, FAILURE } state;
+ void *cb_session_ctx;
+ struct os_time timestamp;
+ int aka;
+ union {
+ struct {
+ u8 kc[EAP_SIM_MAX_CHAL][EAP_SIM_KC_LEN];
+ u8 sres[EAP_SIM_MAX_CHAL][EAP_SIM_SRES_LEN];
+ u8 rand[EAP_SIM_MAX_CHAL][GSM_RAND_LEN];
+ int num_chal;
+ } sim;
+ struct {
+ u8 rand[EAP_AKA_RAND_LEN];
+ u8 autn[EAP_AKA_AUTN_LEN];
+ u8 ik[EAP_AKA_IK_LEN];
+ u8 ck[EAP_AKA_CK_LEN];
+ u8 res[EAP_AKA_RES_MAX_LEN];
+ size_t res_len;
+ } aka;
+ } u;
+};
+
+struct eap_sim_db_data {
+ int sock;
+ char *fname;
+ char *local_sock;
+ void (*get_complete_cb)(void *ctx, void *session_ctx);
+ void *ctx;
+ struct eap_sim_pseudonym *pseudonyms;
+ struct eap_sim_reauth *reauths;
+ struct eap_sim_db_pending *pending;
+};
+
+
+static struct eap_sim_db_pending *
+eap_sim_db_get_pending(struct eap_sim_db_data *data, const u8 *imsi,
+ size_t imsi_len, int aka)
+{
+ struct eap_sim_db_pending *entry, *prev = NULL;
+
+ entry = data->pending;
+ while (entry) {
+ if (entry->aka == aka && entry->imsi_len == imsi_len &&
+ os_memcmp(entry->imsi, imsi, imsi_len) == 0) {
+ if (prev)
+ prev->next = entry->next;
+ else
+ data->pending = entry->next;
+ break;
+ }
+ prev = entry;
+ entry = entry->next;
+ }
+ return entry;
+}
+
+
+static void eap_sim_db_add_pending(struct eap_sim_db_data *data,
+ struct eap_sim_db_pending *entry)
+{
+ entry->next = data->pending;
+ data->pending = entry;
+}
+
+
+static void eap_sim_db_sim_resp_auth(struct eap_sim_db_data *data,
+ const char *imsi, char *buf)
+{
+ char *start, *end, *pos;
+ struct eap_sim_db_pending *entry;
+ int num_chal;
+
+ /*
+ * SIM-RESP-AUTH <IMSI> Kc(i):SRES(i):RAND(i) ...
+ * SIM-RESP-AUTH <IMSI> FAILURE
+ * (IMSI = ASCII string, Kc/SRES/RAND = hex string)
+ */
+
+ entry = eap_sim_db_get_pending(data, (u8 *) imsi, os_strlen(imsi), 0);
+ if (entry == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: No pending entry for the "
+ "received message found");
+ return;
+ }
+
+ start = buf;
+ if (os_strncmp(start, "FAILURE", 7) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: External server reported "
+ "failure");
+ entry->state = FAILURE;
+ eap_sim_db_add_pending(data, entry);
+ data->get_complete_cb(data->ctx, entry->cb_session_ctx);
+ return;
+ }
+
+ num_chal = 0;
+ while (num_chal < EAP_SIM_MAX_CHAL) {
+ end = os_strchr(start, ' ');
+ if (end)
+ *end = '\0';
+
+ pos = os_strchr(start, ':');
+ if (pos == NULL)
+ goto parse_fail;
+ *pos = '\0';
+ if (hexstr2bin(start, entry->u.sim.kc[num_chal],
+ EAP_SIM_KC_LEN))
+ goto parse_fail;
+
+ start = pos + 1;
+ pos = os_strchr(start, ':');
+ if (pos == NULL)
+ goto parse_fail;
+ *pos = '\0';
+ if (hexstr2bin(start, entry->u.sim.sres[num_chal],
+ EAP_SIM_SRES_LEN))
+ goto parse_fail;
+
+ start = pos + 1;
+ if (hexstr2bin(start, entry->u.sim.rand[num_chal],
+ GSM_RAND_LEN))
+ goto parse_fail;
+
+ num_chal++;
+ if (end == NULL)
+ break;
+ else
+ start = end + 1;
+ }
+ entry->u.sim.num_chal = num_chal;
+
+ entry->state = SUCCESS;
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Authentication data parsed "
+ "successfully - callback");
+ eap_sim_db_add_pending(data, entry);
+ data->get_complete_cb(data->ctx, entry->cb_session_ctx);
+ return;
+
+parse_fail:
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
+ os_free(entry);
+}
+
+
+static void eap_sim_db_aka_resp_auth(struct eap_sim_db_data *data,
+ const char *imsi, char *buf)
+{
+ char *start, *end;
+ struct eap_sim_db_pending *entry;
+
+ /*
+ * AKA-RESP-AUTH <IMSI> <RAND> <AUTN> <IK> <CK> <RES>
+ * AKA-RESP-AUTH <IMSI> FAILURE
+ * (IMSI = ASCII string, RAND/AUTN/IK/CK/RES = hex string)
+ */
+
+ entry = eap_sim_db_get_pending(data, (u8 *) imsi, os_strlen(imsi), 1);
+ if (entry == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: No pending entry for the "
+ "received message found");
+ return;
+ }
+
+ start = buf;
+ if (os_strncmp(start, "FAILURE", 7) == 0) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: External server reported "
+ "failure");
+ entry->state = FAILURE;
+ eap_sim_db_add_pending(data, entry);
+ data->get_complete_cb(data->ctx, entry->cb_session_ctx);
+ return;
+ }
+
+ end = os_strchr(start, ' ');
+ if (end == NULL)
+ goto parse_fail;
+ *end = '\0';
+ if (hexstr2bin(start, entry->u.aka.rand, EAP_AKA_RAND_LEN))
+ goto parse_fail;
+
+ start = end + 1;
+ end = os_strchr(start, ' ');
+ if (end == NULL)
+ goto parse_fail;
+ *end = '\0';
+ if (hexstr2bin(start, entry->u.aka.autn, EAP_AKA_AUTN_LEN))
+ goto parse_fail;
+
+ start = end + 1;
+ end = os_strchr(start, ' ');
+ if (end == NULL)
+ goto parse_fail;
+ *end = '\0';
+ if (hexstr2bin(start, entry->u.aka.ik, EAP_AKA_IK_LEN))
+ goto parse_fail;
+
+ start = end + 1;
+ end = os_strchr(start, ' ');
+ if (end == NULL)
+ goto parse_fail;
+ *end = '\0';
+ if (hexstr2bin(start, entry->u.aka.ck, EAP_AKA_CK_LEN))
+ goto parse_fail;
+
+ start = end + 1;
+ end = os_strchr(start, ' ');
+ if (end)
+ *end = '\0';
+ else {
+ end = start;
+ while (*end)
+ end++;
+ }
+ entry->u.aka.res_len = (end - start) / 2;
+ if (entry->u.aka.res_len > EAP_AKA_RES_MAX_LEN) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Too long RES");
+ entry->u.aka.res_len = 0;
+ goto parse_fail;
+ }
+ if (hexstr2bin(start, entry->u.aka.res, entry->u.aka.res_len))
+ goto parse_fail;
+
+ entry->state = SUCCESS;
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Authentication data parsed "
+ "successfully - callback");
+ eap_sim_db_add_pending(data, entry);
+ data->get_complete_cb(data->ctx, entry->cb_session_ctx);
+ return;
+
+parse_fail:
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
+ os_free(entry);
+}
+
+
+static void eap_sim_db_receive(int sock, void *eloop_ctx, void *sock_ctx)
+{
+ struct eap_sim_db_data *data = eloop_ctx;
+ char buf[1000], *pos, *cmd, *imsi;
+ int res;
+
+ res = recv(sock, buf, sizeof(buf), 0);
+ if (res < 0)
+ return;
+ wpa_hexdump_ascii_key(MSG_MSGDUMP, "EAP-SIM DB: Received from an "
+ "external source", (u8 *) buf, res);
+ if (res == 0)
+ return;
+ if (res >= (int) sizeof(buf))
+ res = sizeof(buf) - 1;
+ buf[res] = '\0';
+
+ if (data->get_complete_cb == NULL) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: No get_complete_cb "
+ "registered");
+ return;
+ }
+
+ /* <cmd> <IMSI> ... */
+
+ cmd = buf;
+ pos = os_strchr(cmd, ' ');
+ if (pos == NULL)
+ goto parse_fail;
+ *pos = '\0';
+ imsi = pos + 1;
+ pos = os_strchr(imsi, ' ');
+ if (pos == NULL)
+ goto parse_fail;
+ *pos = '\0';
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: External response=%s for IMSI %s",
+ cmd, imsi);
+
+ if (os_strcmp(cmd, "SIM-RESP-AUTH") == 0)
+ eap_sim_db_sim_resp_auth(data, imsi, pos + 1);
+ else if (os_strcmp(cmd, "AKA-RESP-AUTH") == 0)
+ eap_sim_db_aka_resp_auth(data, imsi, pos + 1);
+ else
+ wpa_printf(MSG_INFO, "EAP-SIM DB: Unknown external response "
+ "'%s'", cmd);
+ return;
+
+parse_fail:
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
+}
+
+
+static int eap_sim_db_open_socket(struct eap_sim_db_data *data)
+{
+ struct sockaddr_un addr;
+ static int counter = 0;
+
+ if (os_strncmp(data->fname, "unix:", 5) != 0)
+ return -1;
+
+ data->sock = socket(PF_UNIX, SOCK_DGRAM, 0);
+ if (data->sock < 0) {
+ perror("socket(eap_sim_db)");
+ return -1;
+ }
+
+ os_memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ os_snprintf(addr.sun_path, sizeof(addr.sun_path),
+ "/tmp/eap_sim_db_%d-%d", getpid(), counter++);
+ data->local_sock = os_strdup(addr.sun_path);
+ if (bind(data->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ perror("bind(eap_sim_db)");
+ close(data->sock);
+ data->sock = -1;
+ return -1;
+ }
+
+ os_memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ os_strlcpy(addr.sun_path, data->fname + 5, sizeof(addr.sun_path));
+ if (connect(data->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ perror("connect(eap_sim_db)");
+ wpa_hexdump_ascii(MSG_INFO, "HLR/AuC GW socket",
+ (u8 *) addr.sun_path,
+ os_strlen(addr.sun_path));
+ close(data->sock);
+ data->sock = -1;
+ return -1;
+ }
+
+ eloop_register_read_sock(data->sock, eap_sim_db_receive, data, NULL);
+
+ return 0;
+}
+
+
+static void eap_sim_db_close_socket(struct eap_sim_db_data *data)
+{
+ if (data->sock >= 0) {
+ eloop_unregister_read_sock(data->sock);
+ close(data->sock);
+ data->sock = -1;
+ }
+ if (data->local_sock) {
+ unlink(data->local_sock);
+ os_free(data->local_sock);
+ data->local_sock = NULL;
+ }
+}
+
+
+/**
+ * eap_sim_db_init - Initialize EAP-SIM DB / authentication gateway interface
+ * @config: Configuration data (e.g., file name)
+ * @get_complete_cb: Callback function for reporting availability of triplets
+ * @ctx: Context pointer for get_complete_cb
+ * Returns: Pointer to a private data structure or %NULL on failure
+ */
+void * eap_sim_db_init(const char *config,
+ void (*get_complete_cb)(void *ctx, void *session_ctx),
+ void *ctx)
+{
+ struct eap_sim_db_data *data;
+
+ data = os_zalloc(sizeof(*data));
+ if (data == NULL)
+ return NULL;
+
+ data->sock = -1;
+ data->get_complete_cb = get_complete_cb;
+ data->ctx = ctx;
+ data->fname = os_strdup(config);
+ if (data->fname == NULL)
+ goto fail;
+
+ if (os_strncmp(data->fname, "unix:", 5) == 0) {
+ if (eap_sim_db_open_socket(data))
+ goto fail;
+ }
+
+ return data;
+
+fail:
+ eap_sim_db_close_socket(data);
+ os_free(data->fname);
+ os_free(data);
+ return NULL;
+}
+
+
+static void eap_sim_db_free_pseudonym(struct eap_sim_pseudonym *p)
+{
+ os_free(p->identity);
+ os_free(p->pseudonym);
+ os_free(p);
+}
+
+
+static void eap_sim_db_free_reauth(struct eap_sim_reauth *r)
+{
+ os_free(r->identity);
+ os_free(r->reauth_id);
+ os_free(r);
+}
+
+
+/**
+ * eap_sim_db_deinit - Deinitialize EAP-SIM DB/authentication gw interface
+ * @priv: Private data pointer from eap_sim_db_init()
+ */
+void eap_sim_db_deinit(void *priv)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_pseudonym *p, *prev;
+ struct eap_sim_reauth *r, *prevr;
+ struct eap_sim_db_pending *pending, *prev_pending;
+
+ eap_sim_db_close_socket(data);
+ os_free(data->fname);
+
+ p = data->pseudonyms;
+ while (p) {
+ prev = p;
+ p = p->next;
+ eap_sim_db_free_pseudonym(prev);
+ }
+
+ r = data->reauths;
+ while (r) {
+ prevr = r;
+ r = r->next;
+ eap_sim_db_free_reauth(prevr);
+ }
+
+ pending = data->pending;
+ while (pending) {
+ prev_pending = pending;
+ pending = pending->next;
+ os_free(prev_pending);
+ }
+
+ os_free(data);
+}
+
+
+static int eap_sim_db_send(struct eap_sim_db_data *data, const char *msg,
+ size_t len)
+{
+ int _errno = 0;
+
+ if (send(data->sock, msg, len, 0) < 0) {
+ _errno = errno;
+ perror("send[EAP-SIM DB UNIX]");
+ }
+
+ if (_errno == ENOTCONN || _errno == EDESTADDRREQ || _errno == EINVAL ||
+ _errno == ECONNREFUSED) {
+ /* Try to reconnect */
+ eap_sim_db_close_socket(data);
+ if (eap_sim_db_open_socket(data) < 0)
+ return -1;
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Reconnected to the "
+ "external server");
+ if (send(data->sock, msg, len, 0) < 0) {
+ perror("send[EAP-SIM DB UNIX]");
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+
+static void eap_sim_db_expire_pending(struct eap_sim_db_data *data)
+{
+ /* TODO: add limit for maximum length for pending list; remove latest
+ * (i.e., last) entry from the list if the limit is reached; could also
+ * use timeout to expire pending entries */
+}
+
+
+/**
+ * eap_sim_db_get_gsm_triplets - Get GSM triplets
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: User name identity
+ * @identity_len: Length of identity in bytes
+ * @max_chal: Maximum number of triplets
+ * @_rand: Buffer for RAND values
+ * @kc: Buffer for Kc values
+ * @sres: Buffer for SRES values
+ * @cb_session_ctx: Session callback context for get_complete_cb()
+ * Returns: Number of triplets received (has to be less than or equal to
+ * max_chal), -1 (EAP_SIM_DB_FAILURE) on error (e.g., user not found), or
+ * -2 (EAP_SIM_DB_PENDING) if results are not yet available. In this case, the
+ * callback function registered with eap_sim_db_init() will be called once the
+ * results become available.
+ *
+ * In most cases, the user name is '1' | IMSI, i.e., 1 followed by the IMSI in
+ * ASCII format.
+ *
+ * When using an external server for GSM triplets, this function can always
+ * start a request and return EAP_SIM_DB_PENDING immediately if authentication
+ * triplets are not available. Once the triplets are received, callback
+ * function registered with eap_sim_db_init() is called to notify EAP state
+ * machine to reprocess the message. This eap_sim_db_get_gsm_triplets()
+ * function will then be called again and the newly received triplets will then
+ * be given to the caller.
+ */
+int eap_sim_db_get_gsm_triplets(void *priv, const u8 *identity,
+ size_t identity_len, int max_chal,
+ u8 *_rand, u8 *kc, u8 *sres,
+ void *cb_session_ctx)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_db_pending *entry;
+ int len, ret;
+ size_t i;
+ char msg[40];
+
+ if (identity_len < 2 || identity[0] != EAP_SIM_PERMANENT_PREFIX) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: unexpected identity",
+ identity, identity_len);
+ return EAP_SIM_DB_FAILURE;
+ }
+ identity++;
+ identity_len--;
+ for (i = 0; i < identity_len; i++) {
+ if (identity[i] == '@') {
+ identity_len = i;
+ break;
+ }
+ }
+ if (identity_len + 1 > sizeof(entry->imsi)) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: unexpected identity",
+ identity, identity_len);
+ return EAP_SIM_DB_FAILURE;
+ }
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: Get GSM triplets for IMSI",
+ identity, identity_len);
+
+ entry = eap_sim_db_get_pending(data, identity, identity_len, 0);
+ if (entry) {
+ int num_chal;
+ if (entry->state == FAILURE) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
+ "failure");
+ os_free(entry);
+ return EAP_SIM_DB_FAILURE;
+ }
+
+ if (entry->state == PENDING) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
+ "still pending");
+ eap_sim_db_add_pending(data, entry);
+ return EAP_SIM_DB_PENDING;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
+ "%d challenges", entry->u.sim.num_chal);
+ num_chal = entry->u.sim.num_chal;
+ if (num_chal > max_chal)
+ num_chal = max_chal;
+ os_memcpy(_rand, entry->u.sim.rand, num_chal * GSM_RAND_LEN);
+ os_memcpy(sres, entry->u.sim.sres,
+ num_chal * EAP_SIM_SRES_LEN);
+ os_memcpy(kc, entry->u.sim.kc, num_chal * EAP_SIM_KC_LEN);
+ os_free(entry);
+ return num_chal;
+ }
+
+ if (data->sock < 0) {
+ if (eap_sim_db_open_socket(data) < 0)
+ return EAP_SIM_DB_FAILURE;
+ }
+
+ len = os_snprintf(msg, sizeof(msg), "SIM-REQ-AUTH ");
+ if (len < 0 || len + identity_len >= sizeof(msg))
+ return EAP_SIM_DB_FAILURE;
+ os_memcpy(msg + len, identity, identity_len);
+ len += identity_len;
+ ret = os_snprintf(msg + len, sizeof(msg) - len, " %d", max_chal);
+ if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
+ return EAP_SIM_DB_FAILURE;
+ len += ret;
+
+ wpa_hexdump(MSG_DEBUG, "EAP-SIM DB: requesting SIM authentication "
+ "data for IMSI", identity, identity_len);
+ if (eap_sim_db_send(data, msg, len) < 0)
+ return EAP_SIM_DB_FAILURE;
+
+ entry = os_zalloc(sizeof(*entry));
+ if (entry == NULL)
+ return EAP_SIM_DB_FAILURE;
+
+ os_get_time(&entry->timestamp);
+ os_memcpy(entry->imsi, identity, identity_len);
+ entry->imsi_len = identity_len;
+ entry->cb_session_ctx = cb_session_ctx;
+ entry->state = PENDING;
+ eap_sim_db_add_pending(data, entry);
+ eap_sim_db_expire_pending(data);
+
+ return EAP_SIM_DB_PENDING;
+}
+
+
+static struct eap_sim_pseudonym *
+eap_sim_db_get_pseudonym(struct eap_sim_db_data *data, const u8 *identity,
+ size_t identity_len)
+{
+ char *pseudonym;
+ size_t len;
+ struct eap_sim_pseudonym *p;
+
+ if (identity_len == 0 ||
+ (identity[0] != EAP_SIM_PSEUDONYM_PREFIX &&
+ identity[0] != EAP_AKA_PSEUDONYM_PREFIX))
+ return NULL;
+
+ /* Remove possible realm from identity */
+ len = 0;
+ while (len < identity_len) {
+ if (identity[len] == '@')
+ break;
+ len++;
+ }
+
+ pseudonym = os_malloc(len + 1);
+ if (pseudonym == NULL)
+ return NULL;
+ os_memcpy(pseudonym, identity, len);
+ pseudonym[len] = '\0';
+
+ p = data->pseudonyms;
+ while (p) {
+ if (os_strcmp(p->pseudonym, pseudonym) == 0)
+ break;
+ p = p->next;
+ }
+
+ os_free(pseudonym);
+
+ return p;
+}
+
+
+static struct eap_sim_pseudonym *
+eap_sim_db_get_pseudonym_id(struct eap_sim_db_data *data, const u8 *identity,
+ size_t identity_len)
+{
+ struct eap_sim_pseudonym *p;
+
+ if (identity_len == 0 ||
+ (identity[0] != EAP_SIM_PERMANENT_PREFIX &&
+ identity[0] != EAP_AKA_PERMANENT_PREFIX))
+ return NULL;
+
+ p = data->pseudonyms;
+ while (p) {
+ if (identity_len == p->identity_len &&
+ os_memcmp(p->identity, identity, identity_len) == 0)
+ break;
+ p = p->next;
+ }
+
+ return p;
+}
+
+
+static struct eap_sim_reauth *
+eap_sim_db_get_reauth(struct eap_sim_db_data *data, const u8 *identity,
+ size_t identity_len)
+{
+ char *reauth_id;
+ size_t len;
+ struct eap_sim_reauth *r;
+
+ if (identity_len == 0 ||
+ (identity[0] != EAP_SIM_REAUTH_ID_PREFIX &&
+ identity[0] != EAP_AKA_REAUTH_ID_PREFIX))
+ return NULL;
+
+ /* Remove possible realm from identity */
+ len = 0;
+ while (len < identity_len) {
+ if (identity[len] == '@')
+ break;
+ len++;
+ }
+
+ reauth_id = os_malloc(len + 1);
+ if (reauth_id == NULL)
+ return NULL;
+ os_memcpy(reauth_id, identity, len);
+ reauth_id[len] = '\0';
+
+ r = data->reauths;
+ while (r) {
+ if (os_strcmp(r->reauth_id, reauth_id) == 0)
+ break;
+ r = r->next;
+ }
+
+ os_free(reauth_id);
+
+ return r;
+}
+
+
+static struct eap_sim_reauth *
+eap_sim_db_get_reauth_id(struct eap_sim_db_data *data, const u8 *identity,
+ size_t identity_len)
+{
+ struct eap_sim_pseudonym *p;
+ struct eap_sim_reauth *r;
+
+ if (identity_len == 0)
+ return NULL;
+
+ p = eap_sim_db_get_pseudonym(data, identity, identity_len);
+ if (p == NULL)
+ p = eap_sim_db_get_pseudonym_id(data, identity, identity_len);
+ if (p) {
+ identity = p->identity;
+ identity_len = p->identity_len;
+ }
+
+ r = data->reauths;
+ while (r) {
+ if (identity_len == r->identity_len &&
+ os_memcmp(r->identity, identity, identity_len) == 0)
+ break;
+ r = r->next;
+ }
+
+ return r;
+}
+
+
+/**
+ * eap_sim_db_identity_known - Verify whether the given identity is known
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: User name identity
+ * @identity_len: Length of identity in bytes
+ * Returns: 0 if the user is found or -1 on failure
+ *
+ * In most cases, the user name is ['0','1'] | IMSI, i.e., 1 followed by the
+ * IMSI in ASCII format, ['2','3'] | pseudonym, or ['4','5'] | reauth_id.
+ */
+int eap_sim_db_identity_known(void *priv, const u8 *identity,
+ size_t identity_len)
+{
+ struct eap_sim_db_data *data = priv;
+
+ if (identity == NULL || identity_len < 2)
+ return -1;
+
+ if (identity[0] == EAP_SIM_PSEUDONYM_PREFIX ||
+ identity[0] == EAP_AKA_PSEUDONYM_PREFIX) {
+ struct eap_sim_pseudonym *p =
+ eap_sim_db_get_pseudonym(data, identity, identity_len);
+ return p ? 0 : -1;
+ }
+
+ if (identity[0] == EAP_SIM_REAUTH_ID_PREFIX ||
+ identity[0] == EAP_AKA_REAUTH_ID_PREFIX) {
+ struct eap_sim_reauth *r =
+ eap_sim_db_get_reauth(data, identity, identity_len);
+ return r ? 0 : -1;
+ }
+
+ if (identity[0] != EAP_SIM_PERMANENT_PREFIX &&
+ identity[0] != EAP_AKA_PERMANENT_PREFIX) {
+ /* Unknown identity prefix */
+ return -1;
+ }
+
+ /* TODO: Should consider asking HLR/AuC gateway whether this permanent
+ * identity is known. If it is, EAP-SIM/AKA can skip identity request.
+ * In case of EAP-AKA, this would reduce number of needed round-trips.
+ * Ideally, this would be done with one wait, i.e., just request
+ * authentication data and store it for the next use. This would then
+ * need to use similar pending-request functionality as the normal
+ * request for authentication data at later phase.
+ */
+ return -1;
+}
+
+
+static char * eap_sim_db_get_next(struct eap_sim_db_data *data, char prefix)
+{
+ char *id, *pos, *end;
+ u8 buf[10];
+
+ if (random_get_bytes(buf, sizeof(buf)))
+ return NULL;
+ id = os_malloc(sizeof(buf) * 2 + 2);
+ if (id == NULL)
+ return NULL;
+
+ pos = id;
+ end = id + sizeof(buf) * 2 + 2;
+ *pos++ = prefix;
+ pos += wpa_snprintf_hex(pos, end - pos, buf, sizeof(buf));
+
+ return id;
+}
+
+
+/**
+ * eap_sim_db_get_next_pseudonym - EAP-SIM DB: Get next pseudonym
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @aka: Using EAP-AKA instead of EAP-SIM
+ * Returns: Next pseudonym (allocated string) or %NULL on failure
+ *
+ * This function is used to generate a pseudonym for EAP-SIM. The returned
+ * pseudonym is not added to database at this point; it will need to be added
+ * with eap_sim_db_add_pseudonym() once the authentication has been completed
+ * successfully. Caller is responsible for freeing the returned buffer.
+ */
+char * eap_sim_db_get_next_pseudonym(void *priv, int aka)
+{
+ struct eap_sim_db_data *data = priv;
+ return eap_sim_db_get_next(data, aka ? EAP_AKA_PSEUDONYM_PREFIX :
+ EAP_SIM_PSEUDONYM_PREFIX);
+}
+
+
+/**
+ * eap_sim_db_get_next_reauth_id - EAP-SIM DB: Get next reauth_id
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @aka: Using EAP-AKA instead of EAP-SIM
+ * Returns: Next reauth_id (allocated string) or %NULL on failure
+ *
+ * This function is used to generate a fast re-authentication identity for
+ * EAP-SIM. The returned reauth_id is not added to database at this point; it
+ * will need to be added with eap_sim_db_add_reauth() once the authentication
+ * has been completed successfully. Caller is responsible for freeing the
+ * returned buffer.
+ */
+char * eap_sim_db_get_next_reauth_id(void *priv, int aka)
+{
+ struct eap_sim_db_data *data = priv;
+ return eap_sim_db_get_next(data, aka ? EAP_AKA_REAUTH_ID_PREFIX :
+ EAP_SIM_REAUTH_ID_PREFIX);
+}
+
+
+/**
+ * eap_sim_db_add_pseudonym - EAP-SIM DB: Add new pseudonym
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: Identity of the user (may be permanent identity or pseudonym)
+ * @identity_len: Length of identity
+ * @pseudonym: Pseudonym for this user. This needs to be an allocated buffer,
+ * e.g., return value from eap_sim_db_get_next_pseudonym(). Caller must not
+ * free it.
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function adds a new pseudonym for EAP-SIM user. EAP-SIM DB is
+ * responsible of freeing pseudonym buffer once it is not needed anymore.
+ */
+int eap_sim_db_add_pseudonym(void *priv, const u8 *identity,
+ size_t identity_len, char *pseudonym)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_pseudonym *p;
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: Add pseudonym for identity",
+ identity, identity_len);
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pseudonym: %s", pseudonym);
+
+ /* TODO: could store last two pseudonyms */
+ p = eap_sim_db_get_pseudonym(data, identity, identity_len);
+ if (p == NULL)
+ p = eap_sim_db_get_pseudonym_id(data, identity, identity_len);
+
+ if (p) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Replacing previous "
+ "pseudonym: %s", p->pseudonym);
+ os_free(p->pseudonym);
+ p->pseudonym = pseudonym;
+ return 0;
+ }
+
+ p = os_zalloc(sizeof(*p));
+ if (p == NULL) {
+ os_free(pseudonym);
+ return -1;
+ }
+
+ p->next = data->pseudonyms;
+ p->identity = os_malloc(identity_len);
+ if (p->identity == NULL) {
+ os_free(p);
+ os_free(pseudonym);
+ return -1;
+ }
+ os_memcpy(p->identity, identity, identity_len);
+ p->identity_len = identity_len;
+ p->pseudonym = pseudonym;
+ data->pseudonyms = p;
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Added new pseudonym entry");
+ return 0;
+}
+
+
+static struct eap_sim_reauth *
+eap_sim_db_add_reauth_data(struct eap_sim_db_data *data, const u8 *identity,
+ size_t identity_len, char *reauth_id, u16 counter)
+{
+ struct eap_sim_reauth *r;
+
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: Add reauth_id for identity",
+ identity, identity_len);
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: reauth_id: %s", reauth_id);
+
+ r = eap_sim_db_get_reauth(data, identity, identity_len);
+ if (r == NULL)
+ r = eap_sim_db_get_reauth_id(data, identity, identity_len);
+
+ if (r) {
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Replacing previous "
+ "reauth_id: %s", r->reauth_id);
+ os_free(r->reauth_id);
+ r->reauth_id = reauth_id;
+ } else {
+ r = os_zalloc(sizeof(*r));
+ if (r == NULL) {
+ os_free(reauth_id);
+ return NULL;
+ }
+
+ r->next = data->reauths;
+ r->identity = os_malloc(identity_len);
+ if (r->identity == NULL) {
+ os_free(r);
+ os_free(reauth_id);
+ return NULL;
+ }
+ os_memcpy(r->identity, identity, identity_len);
+ r->identity_len = identity_len;
+ r->reauth_id = reauth_id;
+ data->reauths = r;
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Added new reauth entry");
+ }
+
+ r->counter = counter;
+
+ return r;
+}
+
+
+/**
+ * eap_sim_db_add_reauth - EAP-SIM DB: Add new re-authentication entry
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: Identity of the user (may be permanent identity or pseudonym)
+ * @identity_len: Length of identity
+ * @reauth_id: reauth_id for this user. This needs to be an allocated buffer,
+ * e.g., return value from eap_sim_db_get_next_reauth_id(). Caller must not
+ * free it.
+ * @counter: AT_COUNTER value for fast re-authentication
+ * @mk: 16-byte MK from the previous full authentication or %NULL
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function adds a new re-authentication entry for an EAP-SIM user.
+ * EAP-SIM DB is responsible of freeing reauth_id buffer once it is not needed
+ * anymore.
+ */
+int eap_sim_db_add_reauth(void *priv, const u8 *identity,
+ size_t identity_len, char *reauth_id, u16 counter,
+ const u8 *mk)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_reauth *r;
+
+ r = eap_sim_db_add_reauth_data(data, identity, identity_len, reauth_id,
+ counter);
+ if (r == NULL)
+ return -1;
+
+ os_memcpy(r->mk, mk, EAP_SIM_MK_LEN);
+ r->aka_prime = 0;
+
+ return 0;
+}
+
+
+#ifdef EAP_SERVER_AKA_PRIME
+/**
+ * eap_sim_db_add_reauth_prime - EAP-AKA' DB: Add new re-authentication entry
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: Identity of the user (may be permanent identity or pseudonym)
+ * @identity_len: Length of identity
+ * @reauth_id: reauth_id for this user. This needs to be an allocated buffer,
+ * e.g., return value from eap_sim_db_get_next_reauth_id(). Caller must not
+ * free it.
+ * @counter: AT_COUNTER value for fast re-authentication
+ * @k_encr: K_encr from the previous full authentication
+ * @k_aut: K_aut from the previous full authentication
+ * @k_re: 32-byte K_re from the previous full authentication
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function adds a new re-authentication entry for an EAP-AKA' user.
+ * EAP-SIM DB is responsible of freeing reauth_id buffer once it is not needed
+ * anymore.
+ */
+int eap_sim_db_add_reauth_prime(void *priv, const u8 *identity,
+ size_t identity_len, char *reauth_id,
+ u16 counter, const u8 *k_encr, const u8 *k_aut,
+ const u8 *k_re)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_reauth *r;
+
+ r = eap_sim_db_add_reauth_data(data, identity, identity_len, reauth_id,
+ counter);
+ if (r == NULL)
+ return -1;
+
+ r->aka_prime = 1;
+ os_memcpy(r->k_encr, k_encr, EAP_SIM_K_ENCR_LEN);
+ os_memcpy(r->k_aut, k_aut, EAP_AKA_PRIME_K_AUT_LEN);
+ os_memcpy(r->k_re, k_re, EAP_AKA_PRIME_K_RE_LEN);
+
+ return 0;
+}
+#endif /* EAP_SERVER_AKA_PRIME */
+
+
+/**
+ * eap_sim_db_get_permanent - EAP-SIM DB: Get permanent identity
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: Identity of the user (may be permanent identity or pseudonym)
+ * @identity_len: Length of identity
+ * @len: Buffer for length of the returned permanent identity
+ * Returns: Pointer to the permanent identity, or %NULL if not found
+ */
+const u8 * eap_sim_db_get_permanent(void *priv, const u8 *identity,
+ size_t identity_len, size_t *len)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_pseudonym *p;
+
+ if (identity == NULL)
+ return NULL;
+
+ p = eap_sim_db_get_pseudonym(data, identity, identity_len);
+ if (p == NULL)
+ p = eap_sim_db_get_pseudonym_id(data, identity, identity_len);
+ if (p == NULL)
+ return NULL;
+
+ *len = p->identity_len;
+ return p->identity;
+}
+
+
+/**
+ * eap_sim_db_get_reauth_entry - EAP-SIM DB: Get re-authentication entry
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: Identity of the user (may be permanent identity, pseudonym, or
+ * reauth_id)
+ * @identity_len: Length of identity
+ * Returns: Pointer to the re-auth entry, or %NULL if not found
+ */
+struct eap_sim_reauth *
+eap_sim_db_get_reauth_entry(void *priv, const u8 *identity,
+ size_t identity_len)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_reauth *r;
+
+ if (identity == NULL)
+ return NULL;
+ r = eap_sim_db_get_reauth(data, identity, identity_len);
+ if (r == NULL)
+ r = eap_sim_db_get_reauth_id(data, identity, identity_len);
+ return r;
+}
+
+
+/**
+ * eap_sim_db_remove_reauth - EAP-SIM DB: Remove re-authentication entry
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @reauth: Pointer to re-authentication entry from
+ * eap_sim_db_get_reauth_entry()
+ */
+void eap_sim_db_remove_reauth(void *priv, struct eap_sim_reauth *reauth)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_reauth *r, *prev = NULL;
+ r = data->reauths;
+ while (r) {
+ if (r == reauth) {
+ if (prev)
+ prev->next = r->next;
+ else
+ data->reauths = r->next;
+ eap_sim_db_free_reauth(r);
+ return;
+ }
+ prev = r;
+ r = r->next;
+ }
+}
+
+
+/**
+ * eap_sim_db_get_aka_auth - Get AKA authentication values
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: User name identity
+ * @identity_len: Length of identity in bytes
+ * @_rand: Buffer for RAND value
+ * @autn: Buffer for AUTN value
+ * @ik: Buffer for IK value
+ * @ck: Buffer for CK value
+ * @res: Buffer for RES value
+ * @res_len: Buffer for RES length
+ * @cb_session_ctx: Session callback context for get_complete_cb()
+ * Returns: 0 on success, -1 (EAP_SIM_DB_FAILURE) on error (e.g., user not
+ * found), or -2 (EAP_SIM_DB_PENDING) if results are not yet available. In this
+ * case, the callback function registered with eap_sim_db_init() will be
+ * called once the results become available.
+ *
+ * In most cases, the user name is '0' | IMSI, i.e., 0 followed by the IMSI in
+ * ASCII format.
+ *
+ * When using an external server for AKA authentication, this function can
+ * always start a request and return EAP_SIM_DB_PENDING immediately if
+ * authentication triplets are not available. Once the authentication data are
+ * received, callback function registered with eap_sim_db_init() is called to
+ * notify EAP state machine to reprocess the message. This
+ * eap_sim_db_get_aka_auth() function will then be called again and the newly
+ * received triplets will then be given to the caller.
+ */
+int eap_sim_db_get_aka_auth(void *priv, const u8 *identity,
+ size_t identity_len, u8 *_rand, u8 *autn, u8 *ik,
+ u8 *ck, u8 *res, size_t *res_len,
+ void *cb_session_ctx)
+{
+ struct eap_sim_db_data *data = priv;
+ struct eap_sim_db_pending *entry;
+ int len;
+ size_t i;
+ char msg[40];
+
+ if (identity_len < 2 || identity == NULL ||
+ identity[0] != EAP_AKA_PERMANENT_PREFIX) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: unexpected identity",
+ identity, identity_len);
+ return EAP_SIM_DB_FAILURE;
+ }
+ identity++;
+ identity_len--;
+ for (i = 0; i < identity_len; i++) {
+ if (identity[i] == '@') {
+ identity_len = i;
+ break;
+ }
+ }
+ if (identity_len + 1 > sizeof(entry->imsi)) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: unexpected identity",
+ identity, identity_len);
+ return EAP_SIM_DB_FAILURE;
+ }
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: Get AKA auth for IMSI",
+ identity, identity_len);
+
+ entry = eap_sim_db_get_pending(data, identity, identity_len, 1);
+ if (entry) {
+ if (entry->state == FAILURE) {
+ os_free(entry);
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failure");
+ return EAP_SIM_DB_FAILURE;
+ }
+
+ if (entry->state == PENDING) {
+ eap_sim_db_add_pending(data, entry);
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending");
+ return EAP_SIM_DB_PENDING;
+ }
+
+ wpa_printf(MSG_DEBUG, "EAP-SIM DB: Returning successfully "
+ "received authentication data");
+ os_memcpy(_rand, entry->u.aka.rand, EAP_AKA_RAND_LEN);
+ os_memcpy(autn, entry->u.aka.autn, EAP_AKA_AUTN_LEN);
+ os_memcpy(ik, entry->u.aka.ik, EAP_AKA_IK_LEN);
+ os_memcpy(ck, entry->u.aka.ck, EAP_AKA_CK_LEN);
+ os_memcpy(res, entry->u.aka.res, EAP_AKA_RES_MAX_LEN);
+ *res_len = entry->u.aka.res_len;
+ os_free(entry);
+ return 0;
+ }
+
+ if (data->sock < 0) {
+ if (eap_sim_db_open_socket(data) < 0)
+ return EAP_SIM_DB_FAILURE;
+ }
+
+ len = os_snprintf(msg, sizeof(msg), "AKA-REQ-AUTH ");
+ if (len < 0 || len + identity_len >= sizeof(msg))
+ return EAP_SIM_DB_FAILURE;
+ os_memcpy(msg + len, identity, identity_len);
+ len += identity_len;
+
+ wpa_hexdump(MSG_DEBUG, "EAP-SIM DB: requesting AKA authentication "
+ "data for IMSI", identity, identity_len);
+ if (eap_sim_db_send(data, msg, len) < 0)
+ return EAP_SIM_DB_FAILURE;
+
+ entry = os_zalloc(sizeof(*entry));
+ if (entry == NULL)
+ return EAP_SIM_DB_FAILURE;
+
+ os_get_time(&entry->timestamp);
+ entry->aka = 1;
+ os_memcpy(entry->imsi, identity, identity_len);
+ entry->imsi_len = identity_len;
+ entry->cb_session_ctx = cb_session_ctx;
+ entry->state = PENDING;
+ eap_sim_db_add_pending(data, entry);
+ eap_sim_db_expire_pending(data);
+
+ return EAP_SIM_DB_PENDING;
+}
+
+
+/**
+ * eap_sim_db_resynchronize - Resynchronize AKA AUTN
+ * @priv: Private data pointer from eap_sim_db_init()
+ * @identity: User name identity
+ * @identity_len: Length of identity in bytes
+ * @auts: AUTS value from the peer
+ * @_rand: RAND value used in the rejected message
+ * Returns: 0 on success, -1 on failure
+ *
+ * This function is called when the peer reports synchronization failure in the
+ * AUTN value by sending AUTS. The AUTS and RAND values should be sent to
+ * HLR/AuC to allow it to resynchronize with the peer. After this,
+ * eap_sim_db_get_aka_auth() will be called again to to fetch updated
+ * RAND/AUTN values for the next challenge.
+ */
+int eap_sim_db_resynchronize(void *priv, const u8 *identity,
+ size_t identity_len, const u8 *auts,
+ const u8 *_rand)
+{
+ struct eap_sim_db_data *data = priv;
+ size_t i;
+
+ if (identity_len < 2 || identity == NULL ||
+ identity[0] != EAP_AKA_PERMANENT_PREFIX) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: unexpected identity",
+ identity, identity_len);
+ return -1;
+ }
+ identity++;
+ identity_len--;
+ for (i = 0; i < identity_len; i++) {
+ if (identity[i] == '@') {
+ identity_len = i;
+ break;
+ }
+ }
+ if (identity_len > 20) {
+ wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM DB: unexpected identity",
+ identity, identity_len);
+ return -1;
+ }
+
+ if (data->sock >= 0) {
+ char msg[100];
+ int len, ret;
+
+ len = os_snprintf(msg, sizeof(msg), "AKA-AUTS ");
+ if (len < 0 || len + identity_len >= sizeof(msg))
+ return -1;
+ os_memcpy(msg + len, identity, identity_len);
+ len += identity_len;
+
+ ret = os_snprintf(msg + len, sizeof(msg) - len, " ");
+ if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
+ return -1;
+ len += ret;
+ len += wpa_snprintf_hex(msg + len, sizeof(msg) - len,
+ auts, EAP_AKA_AUTS_LEN);
+ ret = os_snprintf(msg + len, sizeof(msg) - len, " ");
+ if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
+ return -1;
+ len += ret;
+ len += wpa_snprintf_hex(msg + len, sizeof(msg) - len,
+ _rand, EAP_AKA_RAND_LEN);
+ wpa_hexdump(MSG_DEBUG, "EAP-SIM DB: reporting AKA AUTS for "
+ "IMSI", identity, identity_len);
+ if (eap_sim_db_send(data, msg, len) < 0)
+ return -1;
+ }
+
+ return 0;
+}
diff --git a/src/eap_server/eap_sim_db.h b/src/eap_server/eap_sim_db.h
new file mode 100644
index 0000000..ab89ae9
--- /dev/null
+++ b/src/eap_server/eap_sim_db.h
@@ -0,0 +1,91 @@
+/*
+ * hostapd / EAP-SIM database/authenticator gateway
+ * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef EAP_SIM_DB_H
+#define EAP_SIM_DB_H
+
+#include "eap_common/eap_sim_common.h"
+
+/* Identity prefixes */
+#define EAP_SIM_PERMANENT_PREFIX '1'
+#define EAP_SIM_PSEUDONYM_PREFIX '3'
+#define EAP_SIM_REAUTH_ID_PREFIX '5'
+#define EAP_AKA_PERMANENT_PREFIX '0'
+#define EAP_AKA_PSEUDONYM_PREFIX '2'
+#define EAP_AKA_REAUTH_ID_PREFIX '4'
+
+void * eap_sim_db_init(const char *config,
+ void (*get_complete_cb)(void *ctx, void *session_ctx),
+ void *ctx);
+
+void eap_sim_db_deinit(void *priv);
+
+int eap_sim_db_get_gsm_triplets(void *priv, const u8 *identity,
+ size_t identity_len, int max_chal,
+ u8 *_rand, u8 *kc, u8 *sres,
+ void *cb_session_ctx);
+
+#define EAP_SIM_DB_FAILURE -1
+#define EAP_SIM_DB_PENDING -2
+
+int eap_sim_db_identity_known(void *priv, const u8 *identity,
+ size_t identity_len);
+
+char * eap_sim_db_get_next_pseudonym(void *priv, int aka);
+
+char * eap_sim_db_get_next_reauth_id(void *priv, int aka);
+
+int eap_sim_db_add_pseudonym(void *priv, const u8 *identity,
+ size_t identity_len, char *pseudonym);
+
+int eap_sim_db_add_reauth(void *priv, const u8 *identity,
+ size_t identity_len, char *reauth_id, u16 counter,
+ const u8 *mk);
+int eap_sim_db_add_reauth_prime(void *priv, const u8 *identity,
+ size_t identity_len, char *reauth_id,
+ u16 counter, const u8 *k_encr, const u8 *k_aut,
+ const u8 *k_re);
+
+const u8 * eap_sim_db_get_permanent(void *priv, const u8 *identity,
+ size_t identity_len, size_t *len);
+
+struct eap_sim_reauth {
+ struct eap_sim_reauth *next;
+ u8 *identity;
+ size_t identity_len;
+ char *reauth_id;
+ u16 counter;
+ int aka_prime;
+ u8 mk[EAP_SIM_MK_LEN];
+ u8 k_encr[EAP_SIM_K_ENCR_LEN];
+ u8 k_aut[EAP_AKA_PRIME_K_AUT_LEN];
+ u8 k_re[EAP_AKA_PRIME_K_RE_LEN];
+};
+
+struct eap_sim_reauth *
+eap_sim_db_get_reauth_entry(void *priv, const u8 *identity,
+ size_t identity_len);
+
+void eap_sim_db_remove_reauth(void *priv, struct eap_sim_reauth *reauth);
+
+int eap_sim_db_get_aka_auth(void *priv, const u8 *identity,
+ size_t identity_len, u8 *_rand, u8 *autn, u8 *ik,
+ u8 *ck, u8 *res, size_t *res_len,
+ void *cb_session_ctx);
+
+int eap_sim_db_resynchronize(void *priv, const u8 *identity,
+ size_t identity_len, const u8 *auts,
+ const u8 *_rand);
+
+#endif /* EAP_SIM_DB_H */
diff --git a/src/eap_server/eap_tls_common.h b/src/eap_server/eap_tls_common.h
new file mode 100644
index 0000000..c34c401
--- /dev/null
+++ b/src/eap_server/eap_tls_common.h
@@ -0,0 +1,91 @@
+/*
+ * EAP-TLS/PEAP/TTLS/FAST server common functions
+ * Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef EAP_TLS_COMMON_H
+#define EAP_TLS_COMMON_H
+
+/**
+ * struct eap_ssl_data - TLS data for EAP methods
+ */
+struct eap_ssl_data {
+ /**
+ * conn - TLS connection context data from tls_connection_init()
+ */
+ struct tls_connection *conn;
+
+ /**
+ * tls_out - TLS message to be sent out in fragments
+ */
+ struct wpabuf *tls_out;
+
+ /**
+ * tls_out_pos - The current position in the outgoing TLS message
+ */
+ size_t tls_out_pos;
+
+ /**
+ * tls_out_limit - Maximum fragment size for outgoing TLS messages
+ */
+ size_t tls_out_limit;
+
+ /**
+ * tls_in - Received TLS message buffer for re-assembly
+ */
+ struct wpabuf *tls_in;
+
+ /**
+ * phase2 - Whether this TLS connection is used in EAP phase 2 (tunnel)
+ */
+ int phase2;
+
+ /**
+ * eap - EAP state machine allocated with eap_server_sm_init()
+ */
+ struct eap_sm *eap;
+
+ enum { MSG, FRAG_ACK, WAIT_FRAG_ACK } state;
+ struct wpabuf tmpbuf;
+};
+
+
+/* EAP TLS Flags */
+#define EAP_TLS_FLAGS_LENGTH_INCLUDED 0x80
+#define EAP_TLS_FLAGS_MORE_FRAGMENTS 0x40
+#define EAP_TLS_FLAGS_START 0x20
+#define EAP_TLS_VERSION_MASK 0x07
+
+ /* could be up to 128 bytes, but only the first 64 bytes are used */
+#define EAP_TLS_KEY_LEN 64
+
+
+int eap_server_tls_ssl_init(struct eap_sm *sm, struct eap_ssl_data *data,
+ int verify_peer);
+void eap_server_tls_ssl_deinit(struct eap_sm *sm, struct eap_ssl_data *data);
+u8 * eap_server_tls_derive_key(struct eap_sm *sm, struct eap_ssl_data *data,
+ char *label, size_t len);
+struct wpabuf * eap_server_tls_build_msg(struct eap_ssl_data *data,
+ int eap_type, int version, u8 id);
+struct wpabuf * eap_server_tls_build_ack(u8 id, int eap_type, int version);
+int eap_server_tls_phase1(struct eap_sm *sm, struct eap_ssl_data *data);
+struct wpabuf * eap_server_tls_encrypt(struct eap_sm *sm,
+ struct eap_ssl_data *data,
+ const struct wpabuf *plain);
+int eap_server_tls_process(struct eap_sm *sm, struct eap_ssl_data *data,
+ struct wpabuf *respData, void *priv, int eap_type,
+ int (*proc_version)(struct eap_sm *sm, void *priv,
+ int peer_version),
+ void (*proc_msg)(struct eap_sm *sm, void *priv,
+ const struct wpabuf *respData));
+
+#endif /* EAP_TLS_COMMON_H */
diff --git a/src/eap_server/ikev2.c b/src/eap_server/ikev2.c
new file mode 100644
index 0000000..9624d53
--- /dev/null
+++ b/src/eap_server/ikev2.c
@@ -0,0 +1,1206 @@
+/*
+ * IKEv2 initiator (RFC 4306) for EAP-IKEV2
+ * Copyright (c) 2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+
+#include "common.h"
+#include "crypto/dh_groups.h"
+#include "crypto/random.h"
+#include "ikev2.h"
+
+
+static int ikev2_process_idr(struct ikev2_initiator_data *data,
+ const u8 *idr, size_t idr_len);
+
+
+void ikev2_initiator_deinit(struct ikev2_initiator_data *data)
+{
+ ikev2_free_keys(&data->keys);
+ wpabuf_free(data->r_dh_public);
+ wpabuf_free(data->i_dh_private);
+ os_free(data->IDi);
+ os_free(data->IDr);
+ os_free(data->shared_secret);
+ wpabuf_free(data->i_sign_msg);
+ wpabuf_free(data->r_sign_msg);
+ os_free(data->key_pad);
+}
+
+
+static int ikev2_derive_keys(struct ikev2_initiator_data *data)
+{
+ u8 *buf, *pos, *pad, skeyseed[IKEV2_MAX_HASH_LEN];
+ size_t buf_len, pad_len;
+ struct wpabuf *shared;
+ const struct ikev2_integ_alg *integ;
+ const struct ikev2_prf_alg *prf;
+ const struct ikev2_encr_alg *encr;
+ int ret;
+ const u8 *addr[2];
+ size_t len[2];
+
+ /* RFC 4306, Sect. 2.14 */
+
+ integ = ikev2_get_integ(data->proposal.integ);
+ prf = ikev2_get_prf(data->proposal.prf);
+ encr = ikev2_get_encr(data->proposal.encr);
+ if (integ == NULL || prf == NULL || encr == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: Unsupported proposal");
+ return -1;
+ }
+
+ shared = dh_derive_shared(data->r_dh_public, data->i_dh_private,
+ data->dh);
+ if (shared == NULL)
+ return -1;
+
+ /* Construct Ni | Nr | SPIi | SPIr */
+
+ buf_len = data->i_nonce_len + data->r_nonce_len + 2 * IKEV2_SPI_LEN;
+ buf = os_malloc(buf_len);
+ if (buf == NULL) {
+ wpabuf_free(shared);
+ return -1;
+ }
+
+ pos = buf;
+ os_memcpy(pos, data->i_nonce, data->i_nonce_len);
+ pos += data->i_nonce_len;
+ os_memcpy(pos, data->r_nonce, data->r_nonce_len);
+ pos += data->r_nonce_len;
+ os_memcpy(pos, data->i_spi, IKEV2_SPI_LEN);
+ pos += IKEV2_SPI_LEN;
+ os_memcpy(pos, data->r_spi, IKEV2_SPI_LEN);
+
+ /* SKEYSEED = prf(Ni | Nr, g^ir) */
+
+ /* Use zero-padding per RFC 4306, Sect. 2.14 */
+ pad_len = data->dh->prime_len - wpabuf_len(shared);
+ pad = os_zalloc(pad_len ? pad_len : 1);
+ if (pad == NULL) {
+ wpabuf_free(shared);
+ os_free(buf);
+ return -1;
+ }
+ addr[0] = pad;
+ len[0] = pad_len;
+ addr[1] = wpabuf_head(shared);
+ len[1] = wpabuf_len(shared);
+ if (ikev2_prf_hash(prf->id, buf, data->i_nonce_len + data->r_nonce_len,
+ 2, addr, len, skeyseed) < 0) {
+ wpabuf_free(shared);
+ os_free(buf);
+ os_free(pad);
+ return -1;
+ }
+ os_free(pad);
+ wpabuf_free(shared);
+
+ /* DH parameters are not needed anymore, so free them */
+ wpabuf_free(data->r_dh_public);
+ data->r_dh_public = NULL;
+ wpabuf_free(data->i_dh_private);
+ data->i_dh_private = NULL;
+
+ wpa_hexdump_key(MSG_DEBUG, "IKEV2: SKEYSEED",
+ skeyseed, prf->hash_len);
+
+ ret = ikev2_derive_sk_keys(prf, integ, encr, skeyseed, buf, buf_len,
+ &data->keys);
+ os_free(buf);
+ return ret;
+}
+
+
+static int ikev2_parse_transform(struct ikev2_initiator_data *data,
+ struct ikev2_proposal_data *prop,
+ const u8 *pos, const u8 *end)
+{
+ int transform_len;
+ const struct ikev2_transform *t;
+ u16 transform_id;
+ const u8 *tend;
+
+ if (end - pos < (int) sizeof(*t)) {
+ wpa_printf(MSG_INFO, "IKEV2: Too short transform");
+ return -1;
+ }
+
+ t = (const struct ikev2_transform *) pos;
+ transform_len = WPA_GET_BE16(t->transform_length);
+ if (transform_len < (int) sizeof(*t) || pos + transform_len > end) {
+ wpa_printf(MSG_INFO, "IKEV2: Invalid transform length %d",
+ transform_len);
+ return -1;
+ }
+ tend = pos + transform_len;
+
+ transform_id = WPA_GET_BE16(t->transform_id);
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Transform:");
+ wpa_printf(MSG_DEBUG, "IKEV2: Type: %d Transform Length: %d "
+ "Transform Type: %d Transform ID: %d",
+ t->type, transform_len, t->transform_type, transform_id);
+
+ if (t->type != 0 && t->type != 3) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Transform type");
+ return -1;
+ }
+
+ pos = (const u8 *) (t + 1);
+ if (pos < tend) {
+ wpa_hexdump(MSG_DEBUG, "IKEV2: Transform Attributes",
+ pos, tend - pos);
+ }
+
+ switch (t->transform_type) {
+ case IKEV2_TRANSFORM_ENCR:
+ if (ikev2_get_encr(transform_id) &&
+ transform_id == data->proposal.encr) {
+ if (transform_id == ENCR_AES_CBC) {
+ if (tend - pos != 4) {
+ wpa_printf(MSG_DEBUG, "IKEV2: No "
+ "Transform Attr for AES");
+ break;
+ }
+ if (WPA_GET_BE16(pos) != 0x800e) {
+ wpa_printf(MSG_DEBUG, "IKEV2: Not a "
+ "Key Size attribute for "
+ "AES");
+ break;
+ }
+ if (WPA_GET_BE16(pos + 2) != 128) {
+ wpa_printf(MSG_DEBUG, "IKEV2: "
+ "Unsupported AES key size "
+ "%d bits",
+ WPA_GET_BE16(pos + 2));
+ break;
+ }
+ }
+ prop->encr = transform_id;
+ }
+ break;
+ case IKEV2_TRANSFORM_PRF:
+ if (ikev2_get_prf(transform_id) &&
+ transform_id == data->proposal.prf)
+ prop->prf = transform_id;
+ break;
+ case IKEV2_TRANSFORM_INTEG:
+ if (ikev2_get_integ(transform_id) &&
+ transform_id == data->proposal.integ)
+ prop->integ = transform_id;
+ break;
+ case IKEV2_TRANSFORM_DH:
+ if (dh_groups_get(transform_id) &&
+ transform_id == data->proposal.dh)
+ prop->dh = transform_id;
+ break;
+ }
+
+ return transform_len;
+}
+
+
+static int ikev2_parse_proposal(struct ikev2_initiator_data *data,
+ struct ikev2_proposal_data *prop,
+ const u8 *pos, const u8 *end)
+{
+ const u8 *pend, *ppos;
+ int proposal_len, i;
+ const struct ikev2_proposal *p;
+
+ if (end - pos < (int) sizeof(*p)) {
+ wpa_printf(MSG_INFO, "IKEV2: Too short proposal");
+ return -1;
+ }
+
+ p = (const struct ikev2_proposal *) pos;
+ proposal_len = WPA_GET_BE16(p->proposal_length);
+ if (proposal_len < (int) sizeof(*p) || pos + proposal_len > end) {
+ wpa_printf(MSG_INFO, "IKEV2: Invalid proposal length %d",
+ proposal_len);
+ return -1;
+ }
+ wpa_printf(MSG_DEBUG, "IKEV2: SAi1 Proposal # %d",
+ p->proposal_num);
+ wpa_printf(MSG_DEBUG, "IKEV2: Type: %d Proposal Length: %d "
+ " Protocol ID: %d",
+ p->type, proposal_len, p->protocol_id);
+ wpa_printf(MSG_DEBUG, "IKEV2: SPI Size: %d Transforms: %d",
+ p->spi_size, p->num_transforms);
+
+ if (p->type != 0 && p->type != 2) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Proposal type");
+ return -1;
+ }
+
+ if (p->protocol_id != IKEV2_PROTOCOL_IKE) {
+ wpa_printf(MSG_DEBUG, "IKEV2: Unexpected Protocol ID "
+ "(only IKE allowed for EAP-IKEv2)");
+ return -1;
+ }
+
+ if (p->proposal_num != prop->proposal_num) {
+ if (p->proposal_num == prop->proposal_num + 1)
+ prop->proposal_num = p->proposal_num;
+ else {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Proposal #");
+ return -1;
+ }
+ }
+
+ ppos = (const u8 *) (p + 1);
+ pend = pos + proposal_len;
+ if (ppos + p->spi_size > pend) {
+ wpa_printf(MSG_INFO, "IKEV2: Not enough room for SPI "
+ "in proposal");
+ return -1;
+ }
+ if (p->spi_size) {
+ wpa_hexdump(MSG_DEBUG, "IKEV2: SPI",
+ ppos, p->spi_size);
+ ppos += p->spi_size;
+ }
+
+ /*
+ * For initial IKE_SA negotiation, SPI Size MUST be zero; for
+ * subsequent negotiations, it must be 8 for IKE. We only support
+ * initial case for now.
+ */
+ if (p->spi_size != 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected SPI Size");
+ return -1;
+ }
+
+ if (p->num_transforms == 0) {
+ wpa_printf(MSG_INFO, "IKEV2: At least one transform required");
+ return -1;
+ }
+
+ for (i = 0; i < (int) p->num_transforms; i++) {
+ int tlen = ikev2_parse_transform(data, prop, ppos, pend);
+ if (tlen < 0)
+ return -1;
+ ppos += tlen;
+ }
+
+ if (ppos != pend) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected data after "
+ "transforms");
+ return -1;
+ }
+
+ return proposal_len;
+}
+
+
+static int ikev2_process_sar1(struct ikev2_initiator_data *data,
+ const u8 *sar1, size_t sar1_len)
+{
+ struct ikev2_proposal_data prop;
+ const u8 *pos, *end;
+ int found = 0;
+
+ /* Security Association Payloads: <Proposals> */
+
+ if (sar1 == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: SAr1 not received");
+ return -1;
+ }
+
+ os_memset(&prop, 0, sizeof(prop));
+ prop.proposal_num = 1;
+
+ pos = sar1;
+ end = sar1 + sar1_len;
+
+ while (pos < end) {
+ int plen;
+
+ prop.integ = -1;
+ prop.prf = -1;
+ prop.encr = -1;
+ prop.dh = -1;
+ plen = ikev2_parse_proposal(data, &prop, pos, end);
+ if (plen < 0)
+ return -1;
+
+ if (!found && prop.integ != -1 && prop.prf != -1 &&
+ prop.encr != -1 && prop.dh != -1) {
+ found = 1;
+ }
+
+ pos += plen;
+
+ /* Only one proposal expected in SAr */
+ break;
+ }
+
+ if (pos != end) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected data after proposal");
+ return -1;
+ }
+
+ if (!found) {
+ wpa_printf(MSG_INFO, "IKEV2: No acceptable proposal found");
+ return -1;
+ }
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Accepted proposal #%d: ENCR:%d PRF:%d "
+ "INTEG:%d D-H:%d", data->proposal.proposal_num,
+ data->proposal.encr, data->proposal.prf,
+ data->proposal.integ, data->proposal.dh);
+
+ return 0;
+}
+
+
+static int ikev2_process_ker(struct ikev2_initiator_data *data,
+ const u8 *ker, size_t ker_len)
+{
+ u16 group;
+
+ /*
+ * Key Exchange Payload:
+ * DH Group # (16 bits)
+ * RESERVED (16 bits)
+ * Key Exchange Data (Diffie-Hellman public value)
+ */
+
+ if (ker == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: KEr not received");
+ return -1;
+ }
+
+ if (ker_len < 4 + 96) {
+ wpa_printf(MSG_INFO, "IKEV2: Too show Key Exchange Payload");
+ return -1;
+ }
+
+ group = WPA_GET_BE16(ker);
+ wpa_printf(MSG_DEBUG, "IKEV2: KEr DH Group #%u", group);
+
+ if (group != data->proposal.dh) {
+ wpa_printf(MSG_DEBUG, "IKEV2: KEr DH Group #%u does not match "
+ "with the selected proposal (%u)",
+ group, data->proposal.dh);
+ return -1;
+ }
+
+ if (data->dh == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: Unsupported DH group");
+ return -1;
+ }
+
+ /* RFC 4306, Section 3.4:
+ * The length of DH public value MUST be equal to the lenght of the
+ * prime modulus.
+ */
+ if (ker_len - 4 != data->dh->prime_len) {
+ wpa_printf(MSG_INFO, "IKEV2: Invalid DH public value length "
+ "%ld (expected %ld)",
+ (long) (ker_len - 4), (long) data->dh->prime_len);
+ return -1;
+ }
+
+ wpabuf_free(data->r_dh_public);
+ data->r_dh_public = wpabuf_alloc_copy(ker + 4, ker_len - 4);
+ if (data->r_dh_public == NULL)
+ return -1;
+
+ wpa_hexdump_buf(MSG_DEBUG, "IKEV2: KEr Diffie-Hellman Public Value",
+ data->r_dh_public);
+
+ return 0;
+}
+
+
+static int ikev2_process_nr(struct ikev2_initiator_data *data,
+ const u8 *nr, size_t nr_len)
+{
+ if (nr == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: Nr not received");
+ return -1;
+ }
+
+ if (nr_len < IKEV2_NONCE_MIN_LEN || nr_len > IKEV2_NONCE_MAX_LEN) {
+ wpa_printf(MSG_INFO, "IKEV2: Invalid Nr length %ld",
+ (long) nr_len);
+ return -1;
+ }
+
+ data->r_nonce_len = nr_len;
+ os_memcpy(data->r_nonce, nr, nr_len);
+ wpa_hexdump(MSG_MSGDUMP, "IKEV2: Nr",
+ data->r_nonce, data->r_nonce_len);
+
+ return 0;
+}
+
+
+static int ikev2_process_sa_init_encr(struct ikev2_initiator_data *data,
+ const struct ikev2_hdr *hdr,
+ const u8 *encrypted,
+ size_t encrypted_len, u8 next_payload)
+{
+ u8 *decrypted;
+ size_t decrypted_len;
+ struct ikev2_payloads pl;
+ int ret = 0;
+
+ decrypted = ikev2_decrypt_payload(data->proposal.encr,
+ data->proposal.integ, &data->keys, 0,
+ hdr, encrypted, encrypted_len,
+ &decrypted_len);
+ if (decrypted == NULL)
+ return -1;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Processing decrypted payloads");
+
+ if (ikev2_parse_payloads(&pl, next_payload, decrypted,
+ decrypted + decrypted_len) < 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Failed to parse decrypted "
+ "payloads");
+ return -1;
+ }
+
+ if (pl.idr)
+ ret = ikev2_process_idr(data, pl.idr, pl.idr_len);
+
+ os_free(decrypted);
+
+ return ret;
+}
+
+
+static int ikev2_process_sa_init(struct ikev2_initiator_data *data,
+ const struct ikev2_hdr *hdr,
+ struct ikev2_payloads *pl)
+{
+ if (ikev2_process_sar1(data, pl->sa, pl->sa_len) < 0 ||
+ ikev2_process_ker(data, pl->ke, pl->ke_len) < 0 ||
+ ikev2_process_nr(data, pl->nonce, pl->nonce_len) < 0)
+ return -1;
+
+ os_memcpy(data->r_spi, hdr->r_spi, IKEV2_SPI_LEN);
+
+ if (ikev2_derive_keys(data) < 0)
+ return -1;
+
+ if (pl->encrypted) {
+ wpa_printf(MSG_DEBUG, "IKEV2: Encrypted payload in SA_INIT - "
+ "try to get IDr from it");
+ if (ikev2_process_sa_init_encr(data, hdr, pl->encrypted,
+ pl->encrypted_len,
+ pl->encr_next_payload) < 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Failed to process "
+ "encrypted payload");
+ return -1;
+ }
+ }
+
+ data->state = SA_AUTH;
+
+ return 0;
+}
+
+
+static int ikev2_process_idr(struct ikev2_initiator_data *data,
+ const u8 *idr, size_t idr_len)
+{
+ u8 id_type;
+
+ if (idr == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: No IDr received");
+ return -1;
+ }
+
+ if (idr_len < 4) {
+ wpa_printf(MSG_INFO, "IKEV2: Too short IDr payload");
+ return -1;
+ }
+
+ id_type = idr[0];
+ idr += 4;
+ idr_len -= 4;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: IDr ID Type %d", id_type);
+ wpa_hexdump_ascii(MSG_DEBUG, "IKEV2: IDr", idr, idr_len);
+ if (data->IDr) {
+ if (id_type != data->IDr_type || idr_len != data->IDr_len ||
+ os_memcmp(idr, data->IDr, idr_len) != 0) {
+ wpa_printf(MSG_INFO, "IKEV2: IDr differs from the one "
+ "received earlier");
+ wpa_printf(MSG_DEBUG, "IKEV2: Previous IDr ID Type %d",
+ id_type);
+ wpa_hexdump_ascii(MSG_DEBUG, "Previous IKEV2: IDr",
+ data->IDr, data->IDr_len);
+ return -1;
+ }
+ os_free(data->IDr);
+ }
+ data->IDr = os_malloc(idr_len);
+ if (data->IDr == NULL)
+ return -1;
+ os_memcpy(data->IDr, idr, idr_len);
+ data->IDr_len = idr_len;
+ data->IDr_type = id_type;
+
+ return 0;
+}
+
+
+static int ikev2_process_cert(struct ikev2_initiator_data *data,
+ const u8 *cert, size_t cert_len)
+{
+ u8 cert_encoding;
+
+ if (cert == NULL) {
+ if (data->peer_auth == PEER_AUTH_CERT) {
+ wpa_printf(MSG_INFO, "IKEV2: No Certificate received");
+ return -1;
+ }
+ return 0;
+ }
+
+ if (cert_len < 1) {
+ wpa_printf(MSG_INFO, "IKEV2: No Cert Encoding field");
+ return -1;
+ }
+
+ cert_encoding = cert[0];
+ cert++;
+ cert_len--;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Cert Encoding %d", cert_encoding);
+ wpa_hexdump(MSG_MSGDUMP, "IKEV2: Certificate Data", cert, cert_len);
+
+ /* TODO: validate certificate */
+
+ return 0;
+}
+
+
+static int ikev2_process_auth_cert(struct ikev2_initiator_data *data,
+ u8 method, const u8 *auth, size_t auth_len)
+{
+ if (method != AUTH_RSA_SIGN) {
+ wpa_printf(MSG_INFO, "IKEV2: Unsupported authentication "
+ "method %d", method);
+ return -1;
+ }
+
+ /* TODO: validate AUTH */
+ return 0;
+}
+
+
+static int ikev2_process_auth_secret(struct ikev2_initiator_data *data,
+ u8 method, const u8 *auth,
+ size_t auth_len)
+{
+ u8 auth_data[IKEV2_MAX_HASH_LEN];
+ const struct ikev2_prf_alg *prf;
+
+ if (method != AUTH_SHARED_KEY_MIC) {
+ wpa_printf(MSG_INFO, "IKEV2: Unsupported authentication "
+ "method %d", method);
+ return -1;
+ }
+
+ /* msg | Ni | prf(SK_pr,IDr') */
+ if (ikev2_derive_auth_data(data->proposal.prf, data->r_sign_msg,
+ data->IDr, data->IDr_len, data->IDr_type,
+ &data->keys, 0, data->shared_secret,
+ data->shared_secret_len,
+ data->i_nonce, data->i_nonce_len,
+ data->key_pad, data->key_pad_len,
+ auth_data) < 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Could not derive AUTH data");
+ return -1;
+ }
+
+ wpabuf_free(data->r_sign_msg);
+ data->r_sign_msg = NULL;
+
+ prf = ikev2_get_prf(data->proposal.prf);
+ if (prf == NULL)
+ return -1;
+
+ if (auth_len != prf->hash_len ||
+ os_memcmp(auth, auth_data, auth_len) != 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Invalid Authentication Data");
+ wpa_hexdump(MSG_DEBUG, "IKEV2: Received Authentication Data",
+ auth, auth_len);
+ wpa_hexdump(MSG_DEBUG, "IKEV2: Expected Authentication Data",
+ auth_data, prf->hash_len);
+ return -1;
+ }
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Peer authenticated successfully "
+ "using shared keys");
+
+ return 0;
+}
+
+
+static int ikev2_process_auth(struct ikev2_initiator_data *data,
+ const u8 *auth, size_t auth_len)
+{
+ u8 auth_method;
+
+ if (auth == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: No Authentication Payload");
+ return -1;
+ }
+
+ if (auth_len < 4) {
+ wpa_printf(MSG_INFO, "IKEV2: Too short Authentication "
+ "Payload");
+ return -1;
+ }
+
+ auth_method = auth[0];
+ auth += 4;
+ auth_len -= 4;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Auth Method %d", auth_method);
+ wpa_hexdump(MSG_MSGDUMP, "IKEV2: Authentication Data", auth, auth_len);
+
+ switch (data->peer_auth) {
+ case PEER_AUTH_CERT:
+ return ikev2_process_auth_cert(data, auth_method, auth,
+ auth_len);
+ case PEER_AUTH_SECRET:
+ return ikev2_process_auth_secret(data, auth_method, auth,
+ auth_len);
+ }
+
+ return -1;
+}
+
+
+static int ikev2_process_sa_auth_decrypted(struct ikev2_initiator_data *data,
+ u8 next_payload,
+ u8 *payload, size_t payload_len)
+{
+ struct ikev2_payloads pl;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Processing decrypted payloads");
+
+ if (ikev2_parse_payloads(&pl, next_payload, payload, payload +
+ payload_len) < 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Failed to parse decrypted "
+ "payloads");
+ return -1;
+ }
+
+ if (ikev2_process_idr(data, pl.idr, pl.idr_len) < 0 ||
+ ikev2_process_cert(data, pl.cert, pl.cert_len) < 0 ||
+ ikev2_process_auth(data, pl.auth, pl.auth_len) < 0)
+ return -1;
+
+ return 0;
+}
+
+
+static int ikev2_process_sa_auth(struct ikev2_initiator_data *data,
+ const struct ikev2_hdr *hdr,
+ struct ikev2_payloads *pl)
+{
+ u8 *decrypted;
+ size_t decrypted_len;
+ int ret;
+
+ decrypted = ikev2_decrypt_payload(data->proposal.encr,
+ data->proposal.integ,
+ &data->keys, 0, hdr, pl->encrypted,
+ pl->encrypted_len, &decrypted_len);
+ if (decrypted == NULL)
+ return -1;
+
+ ret = ikev2_process_sa_auth_decrypted(data, pl->encr_next_payload,
+ decrypted, decrypted_len);
+ os_free(decrypted);
+
+ if (ret == 0 && !data->unknown_user) {
+ wpa_printf(MSG_DEBUG, "IKEV2: Authentication completed");
+ data->state = IKEV2_DONE;
+ }
+
+ return ret;
+}
+
+
+static int ikev2_validate_rx_state(struct ikev2_initiator_data *data,
+ u8 exchange_type, u32 message_id)
+{
+ switch (data->state) {
+ case SA_INIT:
+ /* Expect to receive IKE_SA_INIT: HDR, SAr, KEr, Nr, [CERTREQ],
+ * [SK{IDr}] */
+ if (exchange_type != IKE_SA_INIT) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Exchange Type "
+ "%u in SA_INIT state", exchange_type);
+ return -1;
+ }
+ if (message_id != 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Message ID %u "
+ "in SA_INIT state", message_id);
+ return -1;
+ }
+ break;
+ case SA_AUTH:
+ /* Expect to receive IKE_SA_AUTH:
+ * HDR, SK {IDr, [CERT,] [CERTREQ,] [NFID,] AUTH}
+ */
+ if (exchange_type != IKE_SA_AUTH) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Exchange Type "
+ "%u in SA_AUTH state", exchange_type);
+ return -1;
+ }
+ if (message_id != 1) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Message ID %u "
+ "in SA_AUTH state", message_id);
+ return -1;
+ }
+ break;
+ case CHILD_SA:
+ if (exchange_type != CREATE_CHILD_SA) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Exchange Type "
+ "%u in CHILD_SA state", exchange_type);
+ return -1;
+ }
+ if (message_id != 2) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Message ID %u "
+ "in CHILD_SA state", message_id);
+ return -1;
+ }
+ break;
+ case IKEV2_DONE:
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int ikev2_initiator_process(struct ikev2_initiator_data *data,
+ const struct wpabuf *buf)
+{
+ const struct ikev2_hdr *hdr;
+ u32 length, message_id;
+ const u8 *pos, *end;
+ struct ikev2_payloads pl;
+
+ wpa_printf(MSG_MSGDUMP, "IKEV2: Received message (len %lu)",
+ (unsigned long) wpabuf_len(buf));
+
+ if (wpabuf_len(buf) < sizeof(*hdr)) {
+ wpa_printf(MSG_INFO, "IKEV2: Too short frame to include HDR");
+ return -1;
+ }
+
+ hdr = (const struct ikev2_hdr *) wpabuf_head(buf);
+ end = wpabuf_head_u8(buf) + wpabuf_len(buf);
+ message_id = WPA_GET_BE32(hdr->message_id);
+ length = WPA_GET_BE32(hdr->length);
+
+ wpa_hexdump(MSG_DEBUG, "IKEV2: IKE_SA Initiator's SPI",
+ hdr->i_spi, IKEV2_SPI_LEN);
+ wpa_hexdump(MSG_DEBUG, "IKEV2: IKE_SA Initiator's SPI",
+ hdr->r_spi, IKEV2_SPI_LEN);
+ wpa_printf(MSG_DEBUG, "IKEV2: Next Payload: %u Version: 0x%x "
+ "Exchange Type: %u",
+ hdr->next_payload, hdr->version, hdr->exchange_type);
+ wpa_printf(MSG_DEBUG, "IKEV2: Message ID: %u Length: %u",
+ message_id, length);
+
+ if (hdr->version != IKEV2_VERSION) {
+ wpa_printf(MSG_INFO, "IKEV2: Unsupported HDR version 0x%x "
+ "(expected 0x%x)", hdr->version, IKEV2_VERSION);
+ return -1;
+ }
+
+ if (length != wpabuf_len(buf)) {
+ wpa_printf(MSG_INFO, "IKEV2: Invalid length (HDR: %lu != "
+ "RX: %lu)", (unsigned long) length,
+ (unsigned long) wpabuf_len(buf));
+ return -1;
+ }
+
+ if (ikev2_validate_rx_state(data, hdr->exchange_type, message_id) < 0)
+ return -1;
+
+ if ((hdr->flags & (IKEV2_HDR_INITIATOR | IKEV2_HDR_RESPONSE)) !=
+ IKEV2_HDR_RESPONSE) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected Flags value 0x%x",
+ hdr->flags);
+ return -1;
+ }
+
+ if (data->state != SA_INIT) {
+ if (os_memcmp(data->i_spi, hdr->i_spi, IKEV2_SPI_LEN) != 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected IKE_SA "
+ "Initiator's SPI");
+ return -1;
+ }
+ if (os_memcmp(data->r_spi, hdr->r_spi, IKEV2_SPI_LEN) != 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Unexpected IKE_SA "
+ "Responder's SPI");
+ return -1;
+ }
+ }
+
+ pos = (const u8 *) (hdr + 1);
+ if (ikev2_parse_payloads(&pl, hdr->next_payload, pos, end) < 0)
+ return -1;
+
+ switch (data->state) {
+ case SA_INIT:
+ if (ikev2_process_sa_init(data, hdr, &pl) < 0)
+ return -1;
+ wpabuf_free(data->r_sign_msg);
+ data->r_sign_msg = wpabuf_dup(buf);
+ break;
+ case SA_AUTH:
+ if (ikev2_process_sa_auth(data, hdr, &pl) < 0)
+ return -1;
+ break;
+ case CHILD_SA:
+ case IKEV2_DONE:
+ break;
+ }
+
+ return 0;
+}
+
+
+static void ikev2_build_hdr(struct ikev2_initiator_data *data,
+ struct wpabuf *msg, u8 exchange_type,
+ u8 next_payload, u32 message_id)
+{
+ struct ikev2_hdr *hdr;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Adding HDR");
+
+ /* HDR - RFC 4306, Sect. 3.1 */
+ hdr = wpabuf_put(msg, sizeof(*hdr));
+ os_memcpy(hdr->i_spi, data->i_spi, IKEV2_SPI_LEN);
+ os_memcpy(hdr->r_spi, data->r_spi, IKEV2_SPI_LEN);
+ hdr->next_payload = next_payload;
+ hdr->version = IKEV2_VERSION;
+ hdr->exchange_type = exchange_type;
+ hdr->flags = IKEV2_HDR_INITIATOR;
+ WPA_PUT_BE32(hdr->message_id, message_id);
+}
+
+
+static int ikev2_build_sai(struct ikev2_initiator_data *data,
+ struct wpabuf *msg, u8 next_payload)
+{
+ struct ikev2_payload_hdr *phdr;
+ size_t plen;
+ struct ikev2_proposal *p;
+ struct ikev2_transform *t;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Adding SAi payload");
+
+ /* SAi1 - RFC 4306, Sect. 2.7 and 3.3 */
+ phdr = wpabuf_put(msg, sizeof(*phdr));
+ phdr->next_payload = next_payload;
+ phdr->flags = 0;
+
+ /* TODO: support for multiple proposals */
+ p = wpabuf_put(msg, sizeof(*p));
+ p->proposal_num = data->proposal.proposal_num;
+ p->protocol_id = IKEV2_PROTOCOL_IKE;
+ p->num_transforms = 4;
+
+ t = wpabuf_put(msg, sizeof(*t));
+ t->type = 3;
+ t->transform_type = IKEV2_TRANSFORM_ENCR;
+ WPA_PUT_BE16(t->transform_id, data->proposal.encr);
+ if (data->proposal.encr == ENCR_AES_CBC) {
+ /* Transform Attribute: Key Len = 128 bits */
+ wpabuf_put_be16(msg, 0x800e); /* AF=1, AttrType=14 */
+ wpabuf_put_be16(msg, 128); /* 128-bit key */
+ }
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) t;
+ WPA_PUT_BE16(t->transform_length, plen);
+
+ t = wpabuf_put(msg, sizeof(*t));
+ t->type = 3;
+ WPA_PUT_BE16(t->transform_length, sizeof(*t));
+ t->transform_type = IKEV2_TRANSFORM_PRF;
+ WPA_PUT_BE16(t->transform_id, data->proposal.prf);
+
+ t = wpabuf_put(msg, sizeof(*t));
+ t->type = 3;
+ WPA_PUT_BE16(t->transform_length, sizeof(*t));
+ t->transform_type = IKEV2_TRANSFORM_INTEG;
+ WPA_PUT_BE16(t->transform_id, data->proposal.integ);
+
+ t = wpabuf_put(msg, sizeof(*t));
+ WPA_PUT_BE16(t->transform_length, sizeof(*t));
+ t->transform_type = IKEV2_TRANSFORM_DH;
+ WPA_PUT_BE16(t->transform_id, data->proposal.dh);
+
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) p;
+ WPA_PUT_BE16(p->proposal_length, plen);
+
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
+ WPA_PUT_BE16(phdr->payload_length, plen);
+
+ return 0;
+}
+
+
+static int ikev2_build_kei(struct ikev2_initiator_data *data,
+ struct wpabuf *msg, u8 next_payload)
+{
+ struct ikev2_payload_hdr *phdr;
+ size_t plen;
+ struct wpabuf *pv;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Adding KEi payload");
+
+ data->dh = dh_groups_get(data->proposal.dh);
+ pv = dh_init(data->dh, &data->i_dh_private);
+ if (pv == NULL) {
+ wpa_printf(MSG_DEBUG, "IKEV2: Failed to initialize DH");
+ return -1;
+ }
+
+ /* KEi - RFC 4306, Sect. 3.4 */
+ phdr = wpabuf_put(msg, sizeof(*phdr));
+ phdr->next_payload = next_payload;
+ phdr->flags = 0;
+
+ wpabuf_put_be16(msg, data->proposal.dh); /* DH Group # */
+ wpabuf_put(msg, 2); /* RESERVED */
+ /*
+ * RFC 4306, Sect. 3.4: possible zero padding for public value to
+ * match the length of the prime.
+ */
+ wpabuf_put(msg, data->dh->prime_len - wpabuf_len(pv));
+ wpabuf_put_buf(msg, pv);
+ os_free(pv);
+
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
+ WPA_PUT_BE16(phdr->payload_length, plen);
+ return 0;
+}
+
+
+static int ikev2_build_ni(struct ikev2_initiator_data *data,
+ struct wpabuf *msg, u8 next_payload)
+{
+ struct ikev2_payload_hdr *phdr;
+ size_t plen;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Adding Ni payload");
+
+ /* Ni - RFC 4306, Sect. 3.9 */
+ phdr = wpabuf_put(msg, sizeof(*phdr));
+ phdr->next_payload = next_payload;
+ phdr->flags = 0;
+ wpabuf_put_data(msg, data->i_nonce, data->i_nonce_len);
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
+ WPA_PUT_BE16(phdr->payload_length, plen);
+ return 0;
+}
+
+
+static int ikev2_build_idi(struct ikev2_initiator_data *data,
+ struct wpabuf *msg, u8 next_payload)
+{
+ struct ikev2_payload_hdr *phdr;
+ size_t plen;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Adding IDi payload");
+
+ if (data->IDi == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: No IDi available");
+ return -1;
+ }
+
+ /* IDi - RFC 4306, Sect. 3.5 */
+ phdr = wpabuf_put(msg, sizeof(*phdr));
+ phdr->next_payload = next_payload;
+ phdr->flags = 0;
+ wpabuf_put_u8(msg, ID_KEY_ID);
+ wpabuf_put(msg, 3); /* RESERVED */
+ wpabuf_put_data(msg, data->IDi, data->IDi_len);
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
+ WPA_PUT_BE16(phdr->payload_length, plen);
+ return 0;
+}
+
+
+static int ikev2_build_auth(struct ikev2_initiator_data *data,
+ struct wpabuf *msg, u8 next_payload)
+{
+ struct ikev2_payload_hdr *phdr;
+ size_t plen;
+ const struct ikev2_prf_alg *prf;
+
+ wpa_printf(MSG_DEBUG, "IKEV2: Adding AUTH payload");
+
+ prf = ikev2_get_prf(data->proposal.prf);
+ if (prf == NULL)
+ return -1;
+
+ /* Authentication - RFC 4306, Sect. 3.8 */
+ phdr = wpabuf_put(msg, sizeof(*phdr));
+ phdr->next_payload = next_payload;
+ phdr->flags = 0;
+ wpabuf_put_u8(msg, AUTH_SHARED_KEY_MIC);
+ wpabuf_put(msg, 3); /* RESERVED */
+
+ /* msg | Nr | prf(SK_pi,IDi') */
+ if (ikev2_derive_auth_data(data->proposal.prf, data->i_sign_msg,
+ data->IDi, data->IDi_len, ID_KEY_ID,
+ &data->keys, 1, data->shared_secret,
+ data->shared_secret_len,
+ data->r_nonce, data->r_nonce_len,
+ data->key_pad, data->key_pad_len,
+ wpabuf_put(msg, prf->hash_len)) < 0) {
+ wpa_printf(MSG_INFO, "IKEV2: Could not derive AUTH data");
+ return -1;
+ }
+ wpabuf_free(data->i_sign_msg);
+ data->i_sign_msg = NULL;
+
+ plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
+ WPA_PUT_BE16(phdr->payload_length, plen);
+ return 0;
+}
+
+
+static struct wpabuf * ikev2_build_sa_init(struct ikev2_initiator_data *data)
+{
+ struct wpabuf *msg;
+
+ /* build IKE_SA_INIT: HDR, SAi, KEi, Ni */
+
+ if (os_get_random(data->i_spi, IKEV2_SPI_LEN))
+ return NULL;
+ wpa_hexdump(MSG_DEBUG, "IKEV2: IKE_SA Initiator's SPI",
+ data->i_spi, IKEV2_SPI_LEN);
+
+ data->i_nonce_len = IKEV2_NONCE_MIN_LEN;
+ if (random_get_bytes(data->i_nonce, data->i_nonce_len))
+ return NULL;
+ wpa_hexdump(MSG_DEBUG, "IKEV2: Ni", data->i_nonce, data->i_nonce_len);
+
+ msg = wpabuf_alloc(sizeof(struct ikev2_hdr) + 1000);
+ if (msg == NULL)
+ return NULL;
+
+ ikev2_build_hdr(data, msg, IKE_SA_INIT, IKEV2_PAYLOAD_SA, 0);
+ if (ikev2_build_sai(data, msg, IKEV2_PAYLOAD_KEY_EXCHANGE) ||
+ ikev2_build_kei(data, msg, IKEV2_PAYLOAD_NONCE) ||
+ ikev2_build_ni(data, msg, IKEV2_PAYLOAD_NO_NEXT_PAYLOAD)) {
+ wpabuf_free(msg);
+ return NULL;
+ }
+
+ ikev2_update_hdr(msg);
+
+ wpa_hexdump_buf(MSG_MSGDUMP, "IKEV2: Sending message (SA_INIT)", msg);
+
+ wpabuf_free(data->i_sign_msg);
+ data->i_sign_msg = wpabuf_dup(msg);
+
+ return msg;
+}
+
+
+static struct wpabuf * ikev2_build_sa_auth(struct ikev2_initiator_data *data)
+{
+ struct wpabuf *msg, *plain;
+ const u8 *secret;
+ size_t secret_len;
+
+ secret = data->get_shared_secret(data->cb_ctx, data->IDr,
+ data->IDr_len, &secret_len);
+ if (secret == NULL) {
+ wpa_printf(MSG_INFO, "IKEV2: Could not get shared secret - "
+ "use fake value");
+ /* RFC 5106, Sect. 7:
+ * Use a random key to fake AUTH generation in order to prevent
+ * probing of user identities.
+ */
+ data->unknown_user = 1;
+ os_free(data->shared_secret);
+ data->shared_secret = os_malloc(16);
+ if (data->shared_secret == NULL)
+ return NULL;
+ data->shared_secret_len = 16;
+ if (random_get_bytes(data->shared_secret, 16))
+ return NULL;
+ } else {
+ os_free(data->shared_secret);
+ data->shared_secret = os_malloc(secret_len);
+ if (data->shared_secret == NULL)
+ return NULL;
+ os_memcpy(data->shared_secret, secret, secret_len);
+ data->shared_secret_len = secret_len;
+ }
+
+ /* build IKE_SA_AUTH: HDR, SK {IDi, [CERT,] [CERTREQ,] AUTH} */
+
+ msg = wpabuf_alloc(sizeof(struct ikev2_hdr) + data->IDr_len + 1000);
+ if (msg == NULL)
+ return NULL;
+ ikev2_build_hdr(data, msg, IKE_SA_AUTH, IKEV2_PAYLOAD_ENCRYPTED, 1);
+
+ plain = wpabuf_alloc(data->IDr_len + 1000);
+ if (plain == NULL) {
+ wpabuf_free(msg);
+ return NULL;
+ }
+
+ if (ikev2_build_idi(data, plain, IKEV2_PAYLOAD_AUTHENTICATION) ||
+ ikev2_build_auth(data, plain, IKEV2_PAYLOAD_NO_NEXT_PAYLOAD) ||
+ ikev2_build_encrypted(data->proposal.encr, data->proposal.integ,
+ &data->keys, 1, msg, plain,
+ IKEV2_PAYLOAD_IDi)) {
+ wpabuf_free(plain);
+ wpabuf_free(msg);
+ return NULL;
+ }
+ wpabuf_free(plain);
+
+ wpa_hexdump_buf(MSG_MSGDUMP, "IKEV2: Sending message (SA_AUTH)", msg);
+
+ return msg;
+}
+
+
+struct wpabuf * ikev2_initiator_build(struct ikev2_initiator_data *data)
+{
+ switch (data->state) {
+ case SA_INIT:
+ return ikev2_build_sa_init(data);
+ case SA_AUTH:
+ return ikev2_build_sa_auth(data);
+ case CHILD_SA:
+ return NULL;
+ case IKEV2_DONE:
+ return NULL;
+ }
+ return NULL;
+}
diff --git a/src/eap_server/ikev2.h b/src/eap_server/ikev2.h
new file mode 100644
index 0000000..8349fbe
--- /dev/null
+++ b/src/eap_server/ikev2.h
@@ -0,0 +1,67 @@
+/*
+ * IKEv2 initiator (RFC 4306) for EAP-IKEV2
+ * Copyright (c) 2007, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef IKEV2_H
+#define IKEV2_H
+
+#include "eap_common/ikev2_common.h"
+
+struct ikev2_proposal_data {
+ u8 proposal_num;
+ int integ;
+ int prf;
+ int encr;
+ int dh;
+};
+
+
+struct ikev2_initiator_data {
+ enum { SA_INIT, SA_AUTH, CHILD_SA, IKEV2_DONE } state;
+ u8 i_spi[IKEV2_SPI_LEN];
+ u8 r_spi[IKEV2_SPI_LEN];
+ u8 i_nonce[IKEV2_NONCE_MAX_LEN];
+ size_t i_nonce_len;
+ u8 r_nonce[IKEV2_NONCE_MAX_LEN];
+ size_t r_nonce_len;
+ struct wpabuf *r_dh_public;
+ struct wpabuf *i_dh_private;
+ struct ikev2_proposal_data proposal;
+ const struct dh_group *dh;
+ struct ikev2_keys keys;
+ u8 *IDi;
+ size_t IDi_len;
+ u8 *IDr;
+ size_t IDr_len;
+ u8 IDr_type;
+ struct wpabuf *r_sign_msg;
+ struct wpabuf *i_sign_msg;
+ u8 *shared_secret;
+ size_t shared_secret_len;
+ enum { PEER_AUTH_CERT, PEER_AUTH_SECRET } peer_auth;
+ u8 *key_pad;
+ size_t key_pad_len;
+
+ const u8 * (*get_shared_secret)(void *ctx, const u8 *IDr,
+ size_t IDr_len, size_t *secret_len);
+ void *cb_ctx;
+ int unknown_user;
+};
+
+
+void ikev2_initiator_deinit(struct ikev2_initiator_data *data);
+int ikev2_initiator_process(struct ikev2_initiator_data *data,
+ const struct wpabuf *buf);
+struct wpabuf * ikev2_initiator_build(struct ikev2_initiator_data *data);
+
+#endif /* IKEV2_H */
diff --git a/src/eap_server/tncs.c b/src/eap_server/tncs.c
new file mode 100644
index 0000000..637b6f8
--- /dev/null
+++ b/src/eap_server/tncs.c
@@ -0,0 +1,1273 @@
+/*
+ * EAP-TNC - TNCS (IF-IMV, IF-TNCCS, and IF-TNCCS-SOH)
+ * Copyright (c) 2007-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#include "includes.h"
+#include <dlfcn.h>
+
+#include "common.h"
+#include "base64.h"
+#include "tncs.h"
+#include "eap_common/eap_tlv_common.h"
+#include "eap_common/eap_defs.h"
+
+
+/* TODO: TNCS must be thread-safe; review the code and add locking etc. if
+ * needed.. */
+
+#define TNC_CONFIG_FILE "/etc/tnc_config"
+#define IF_TNCCS_START \
+"<?xml version=\"1.0\"?>\n" \
+"<TNCCS-Batch BatchId=\"%d\" Recipient=\"TNCS\" " \
+"xmlns=\"http://www.trustedcomputinggroup.org/IWG/TNC/1_0/IF_TNCCS#\" " \
+"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " \
+"xsi:schemaLocation=\"http://www.trustedcomputinggroup.org/IWG/TNC/1_0/" \
+"IF_TNCCS# https://www.trustedcomputinggroup.org/XML/SCHEMA/TNCCS_1.0.xsd\">\n"
+#define IF_TNCCS_END "\n</TNCCS-Batch>"
+
+/* TNC IF-IMV */
+
+typedef unsigned long TNC_UInt32;
+typedef unsigned char *TNC_BufferReference;
+
+typedef TNC_UInt32 TNC_IMVID;
+typedef TNC_UInt32 TNC_ConnectionID;
+typedef TNC_UInt32 TNC_ConnectionState;
+typedef TNC_UInt32 TNC_RetryReason;
+typedef TNC_UInt32 TNC_IMV_Action_Recommendation;
+typedef TNC_UInt32 TNC_IMV_Evaluation_Result;
+typedef TNC_UInt32 TNC_MessageType;
+typedef TNC_MessageType *TNC_MessageTypeList;
+typedef TNC_UInt32 TNC_VendorID;
+typedef TNC_UInt32 TNC_Subtype;
+typedef TNC_UInt32 TNC_Version;
+typedef TNC_UInt32 TNC_Result;
+typedef TNC_UInt32 TNC_AttributeID;
+
+typedef TNC_Result (*TNC_TNCS_BindFunctionPointer)(
+ TNC_IMVID imvID,
+ char *functionName,
+ void **pOutfunctionPointer);
+
+#define TNC_RESULT_SUCCESS 0
+#define TNC_RESULT_NOT_INITIALIZED 1
+#define TNC_RESULT_ALREADY_INITIALIZED 2
+#define TNC_RESULT_NO_COMMON_VERSION 3
+#define TNC_RESULT_CANT_RETRY 4
+#define TNC_RESULT_WONT_RETRY 5
+#define TNC_RESULT_INVALID_PARAMETER 6
+#define TNC_RESULT_CANT_RESPOND 7
+#define TNC_RESULT_ILLEGAL_OPERATION 8
+#define TNC_RESULT_OTHER 9
+#define TNC_RESULT_FATAL 10
+
+#define TNC_CONNECTION_STATE_CREATE 0
+#define TNC_CONNECTION_STATE_HANDSHAKE 1
+#define TNC_CONNECTION_STATE_ACCESS_ALLOWED 2
+#define TNC_CONNECTION_STATE_ACCESS_ISOLATED 3
+#define TNC_CONNECTION_STATE_ACCESS_NONE 4
+#define TNC_CONNECTION_STATE_DELETE 5
+
+#define TNC_IFIMV_VERSION_1 1
+
+#define TNC_VENDORID_ANY ((TNC_VendorID) 0xffffff)
+#define TNC_SUBTYPE_ANY ((TNC_Subtype) 0xff)
+
+/* TNCC-TNCS Message Types */
+#define TNC_TNCCS_RECOMMENDATION 0x00000001
+#define TNC_TNCCS_ERROR 0x00000002
+#define TNC_TNCCS_PREFERREDLANGUAGE 0x00000003
+#define TNC_TNCCS_REASONSTRINGS 0x00000004
+
+/* Possible TNC_IMV_Action_Recommendation values: */
+enum IMV_Action_Recommendation {
+ TNC_IMV_ACTION_RECOMMENDATION_ALLOW,
+ TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS,
+ TNC_IMV_ACTION_RECOMMENDATION_ISOLATE,
+ TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION
+};
+
+/* Possible TNC_IMV_Evaluation_Result values: */
+enum IMV_Evaluation_Result {
+ TNC_IMV_EVALUATION_RESULT_COMPLIANT,
+ TNC_IMV_EVALUATION_RESULT_NONCOMPLIANT_MINOR,
+ TNC_IMV_EVALUATION_RESULT_NONCOMPLIANT_MAJOR,
+ TNC_IMV_EVALUATION_RESULT_ERROR,
+ TNC_IMV_EVALUATION_RESULT_DONT_KNOW
+};
+
+struct tnc_if_imv {
+ struct tnc_if_imv *next;
+ char *name;
+ char *path;
+ void *dlhandle; /* from dlopen() */
+ TNC_IMVID imvID;
+ TNC_MessageTypeList supported_types;
+ size_t num_supported_types;
+
+ /* Functions implemented by IMVs (with TNC_IMV_ prefix) */
+ TNC_Result (*Initialize)(
+ TNC_IMVID imvID,
+ TNC_Version minVersion,
+ TNC_Version maxVersion,
+ TNC_Version *pOutActualVersion);
+ TNC_Result (*NotifyConnectionChange)(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_ConnectionState newState);
+ TNC_Result (*ReceiveMessage)(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_BufferReference message,
+ TNC_UInt32 messageLength,
+ TNC_MessageType messageType);
+ TNC_Result (*SolicitRecommendation)(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID);
+ TNC_Result (*BatchEnding)(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID);
+ TNC_Result (*Terminate)(TNC_IMVID imvID);
+ TNC_Result (*ProvideBindFunction)(
+ TNC_IMVID imvID,
+ TNC_TNCS_BindFunctionPointer bindFunction);
+};
+
+
+#define TNC_MAX_IMV_ID 10
+
+struct tncs_data {
+ struct tncs_data *next;
+ struct tnc_if_imv *imv; /* local copy of tncs_global_data->imv */
+ TNC_ConnectionID connectionID;
+ unsigned int last_batchid;
+ enum IMV_Action_Recommendation recommendation;
+ int done;
+
+ struct conn_imv {
+ u8 *imv_send;
+ size_t imv_send_len;
+ enum IMV_Action_Recommendation recommendation;
+ int recommendation_set;
+ } imv_data[TNC_MAX_IMV_ID];
+
+ char *tncs_message;
+};
+
+
+struct tncs_global {
+ struct tnc_if_imv *imv;
+ TNC_ConnectionID next_conn_id;
+ struct tncs_data *connections;
+};
+
+static struct tncs_global *tncs_global_data = NULL;
+
+
+static struct tnc_if_imv * tncs_get_imv(TNC_IMVID imvID)
+{
+ struct tnc_if_imv *imv;
+
+ if (imvID >= TNC_MAX_IMV_ID || tncs_global_data == NULL)
+ return NULL;
+ imv = tncs_global_data->imv;
+ while (imv) {
+ if (imv->imvID == imvID)
+ return imv;
+ imv = imv->next;
+ }
+ return NULL;
+}
+
+
+static struct tncs_data * tncs_get_conn(TNC_ConnectionID connectionID)
+{
+ struct tncs_data *tncs;
+
+ if (tncs_global_data == NULL)
+ return NULL;
+
+ tncs = tncs_global_data->connections;
+ while (tncs) {
+ if (tncs->connectionID == connectionID)
+ return tncs;
+ tncs = tncs->next;
+ }
+
+ wpa_printf(MSG_DEBUG, "TNC: Connection ID %lu not found",
+ (unsigned long) connectionID);
+
+ return NULL;
+}
+
+
+/* TNCS functions that IMVs can call */
+TNC_Result TNC_TNCS_ReportMessageTypes(
+ TNC_IMVID imvID,
+ TNC_MessageTypeList supportedTypes,
+ TNC_UInt32 typeCount)
+{
+ TNC_UInt32 i;
+ struct tnc_if_imv *imv;
+
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_ReportMessageTypes(imvID=%lu "
+ "typeCount=%lu)",
+ (unsigned long) imvID, (unsigned long) typeCount);
+
+ for (i = 0; i < typeCount; i++) {
+ wpa_printf(MSG_DEBUG, "TNC: supportedTypes[%lu] = %lu",
+ i, supportedTypes[i]);
+ }
+
+ imv = tncs_get_imv(imvID);
+ if (imv == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+ os_free(imv->supported_types);
+ imv->supported_types =
+ os_malloc(typeCount * sizeof(TNC_MessageType));
+ if (imv->supported_types == NULL)
+ return TNC_RESULT_FATAL;
+ os_memcpy(imv->supported_types, supportedTypes,
+ typeCount * sizeof(TNC_MessageType));
+ imv->num_supported_types = typeCount;
+
+ return TNC_RESULT_SUCCESS;
+}
+
+
+TNC_Result TNC_TNCS_SendMessage(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_BufferReference message,
+ TNC_UInt32 messageLength,
+ TNC_MessageType messageType)
+{
+ struct tncs_data *tncs;
+ unsigned char *b64;
+ size_t b64len;
+
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_SendMessage(imvID=%lu "
+ "connectionID=%lu messageType=%lu)",
+ imvID, connectionID, messageType);
+ wpa_hexdump_ascii(MSG_DEBUG, "TNC: TNC_TNCS_SendMessage",
+ message, messageLength);
+
+ if (tncs_get_imv(imvID) == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+
+ tncs = tncs_get_conn(connectionID);
+ if (tncs == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+
+ b64 = base64_encode(message, messageLength, &b64len);
+ if (b64 == NULL)
+ return TNC_RESULT_FATAL;
+
+ os_free(tncs->imv_data[imvID].imv_send);
+ tncs->imv_data[imvID].imv_send_len = 0;
+ tncs->imv_data[imvID].imv_send = os_zalloc(b64len + 100);
+ if (tncs->imv_data[imvID].imv_send == NULL) {
+ os_free(b64);
+ return TNC_RESULT_OTHER;
+ }
+
+ tncs->imv_data[imvID].imv_send_len =
+ os_snprintf((char *) tncs->imv_data[imvID].imv_send,
+ b64len + 100,
+ "<IMC-IMV-Message><Type>%08X</Type>"
+ "<Base64>%s</Base64></IMC-IMV-Message>",
+ (unsigned int) messageType, b64);
+
+ os_free(b64);
+
+ return TNC_RESULT_SUCCESS;
+}
+
+
+TNC_Result TNC_TNCS_RequestHandshakeRetry(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_RetryReason reason)
+{
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_RequestHandshakeRetry");
+ /* TODO */
+ return TNC_RESULT_SUCCESS;
+}
+
+
+TNC_Result TNC_TNCS_ProvideRecommendation(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_IMV_Action_Recommendation recommendation,
+ TNC_IMV_Evaluation_Result evaluation)
+{
+ struct tncs_data *tncs;
+
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_ProvideRecommendation(imvID=%lu "
+ "connectionID=%lu recommendation=%lu evaluation=%lu)",
+ (unsigned long) imvID, (unsigned long) connectionID,
+ (unsigned long) recommendation, (unsigned long) evaluation);
+
+ if (tncs_get_imv(imvID) == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+
+ tncs = tncs_get_conn(connectionID);
+ if (tncs == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+
+ tncs->imv_data[imvID].recommendation = recommendation;
+ tncs->imv_data[imvID].recommendation_set = 1;
+
+ return TNC_RESULT_SUCCESS;
+}
+
+
+TNC_Result TNC_TNCS_GetAttribute(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_AttributeID attribureID,
+ TNC_UInt32 bufferLength,
+ TNC_BufferReference buffer,
+ TNC_UInt32 *pOutValueLength)
+{
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_GetAttribute");
+ /* TODO */
+ return TNC_RESULT_SUCCESS;
+}
+
+
+TNC_Result TNC_TNCS_SetAttribute(
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_AttributeID attribureID,
+ TNC_UInt32 bufferLength,
+ TNC_BufferReference buffer)
+{
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_SetAttribute");
+ /* TODO */
+ return TNC_RESULT_SUCCESS;
+}
+
+
+TNC_Result TNC_TNCS_BindFunction(
+ TNC_IMVID imvID,
+ char *functionName,
+ void **pOutFunctionPointer)
+{
+ wpa_printf(MSG_DEBUG, "TNC: TNC_TNCS_BindFunction(imcID=%lu, "
+ "functionName='%s')", (unsigned long) imvID, functionName);
+
+ if (tncs_get_imv(imvID) == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+
+ if (pOutFunctionPointer == NULL)
+ return TNC_RESULT_INVALID_PARAMETER;
+
+ if (os_strcmp(functionName, "TNC_TNCS_ReportMessageTypes") == 0)
+ *pOutFunctionPointer = TNC_TNCS_ReportMessageTypes;
+ else if (os_strcmp(functionName, "TNC_TNCS_SendMessage") == 0)
+ *pOutFunctionPointer = TNC_TNCS_SendMessage;
+ else if (os_strcmp(functionName, "TNC_TNCS_RequestHandshakeRetry") ==
+ 0)
+ *pOutFunctionPointer = TNC_TNCS_RequestHandshakeRetry;
+ else if (os_strcmp(functionName, "TNC_TNCS_ProvideRecommendation") ==
+ 0)
+ *pOutFunctionPointer = TNC_TNCS_ProvideRecommendation;
+ else if (os_strcmp(functionName, "TNC_TNCS_GetAttribute") == 0)
+ *pOutFunctionPointer = TNC_TNCS_GetAttribute;
+ else if (os_strcmp(functionName, "TNC_TNCS_SetAttribute") == 0)
+ *pOutFunctionPointer = TNC_TNCS_SetAttribute;
+ else
+ *pOutFunctionPointer = NULL;
+
+ return TNC_RESULT_SUCCESS;
+}
+
+
+static void * tncs_get_sym(void *handle, char *func)
+{
+ void *fptr;
+
+ fptr = dlsym(handle, func);
+
+ return fptr;
+}
+
+
+static int tncs_imv_resolve_funcs(struct tnc_if_imv *imv)
+{
+ void *handle = imv->dlhandle;
+
+ /* Mandatory IMV functions */
+ imv->Initialize = tncs_get_sym(handle, "TNC_IMV_Initialize");
+ if (imv->Initialize == NULL) {
+ wpa_printf(MSG_ERROR, "TNC: IMV does not export "
+ "TNC_IMV_Initialize");
+ return -1;
+ }
+
+ imv->SolicitRecommendation = tncs_get_sym(
+ handle, "TNC_IMV_SolicitRecommendation");
+ if (imv->SolicitRecommendation == NULL) {
+ wpa_printf(MSG_ERROR, "TNC: IMV does not export "
+ "TNC_IMV_SolicitRecommendation");
+ return -1;
+ }
+
+ imv->ProvideBindFunction =
+ tncs_get_sym(handle, "TNC_IMV_ProvideBindFunction");
+ if (imv->ProvideBindFunction == NULL) {
+ wpa_printf(MSG_ERROR, "TNC: IMV does not export "
+ "TNC_IMV_ProvideBindFunction");
+ return -1;
+ }
+
+ /* Optional IMV functions */
+ imv->NotifyConnectionChange =
+ tncs_get_sym(handle, "TNC_IMV_NotifyConnectionChange");
+ imv->ReceiveMessage = tncs_get_sym(handle, "TNC_IMV_ReceiveMessage");
+ imv->BatchEnding = tncs_get_sym(handle, "TNC_IMV_BatchEnding");
+ imv->Terminate = tncs_get_sym(handle, "TNC_IMV_Terminate");
+
+ return 0;
+}
+
+
+static int tncs_imv_initialize(struct tnc_if_imv *imv)
+{
+ TNC_Result res;
+ TNC_Version imv_ver;
+
+ wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMV_Initialize for IMV '%s'",
+ imv->name);
+ res = imv->Initialize(imv->imvID, TNC_IFIMV_VERSION_1,
+ TNC_IFIMV_VERSION_1, &imv_ver);
+ wpa_printf(MSG_DEBUG, "TNC: TNC_IMV_Initialize: res=%lu imv_ver=%lu",
+ (unsigned long) res, (unsigned long) imv_ver);
+
+ return res == TNC_RESULT_SUCCESS ? 0 : -1;
+}
+
+
+static int tncs_imv_terminate(struct tnc_if_imv *imv)
+{
+ TNC_Result res;
+
+ if (imv->Terminate == NULL)
+ return 0;
+
+ wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMV_Terminate for IMV '%s'",
+ imv->name);
+ res = imv->Terminate(imv->imvID);
+ wpa_printf(MSG_DEBUG, "TNC: TNC_IMV_Terminate: %lu",
+ (unsigned long) res);
+
+ return res == TNC_RESULT_SUCCESS ? 0 : -1;
+}
+
+
+static int tncs_imv_provide_bind_function(struct tnc_if_imv *imv)
+{
+ TNC_Result res;
+
+ wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMV_ProvideBindFunction for "
+ "IMV '%s'", imv->name);
+ res = imv->ProvideBindFunction(imv->imvID, TNC_TNCS_BindFunction);
+ wpa_printf(MSG_DEBUG, "TNC: TNC_IMV_ProvideBindFunction: res=%lu",
+ (unsigned long) res);
+
+ return res == TNC_RESULT_SUCCESS ? 0 : -1;
+}
+
+
+static int tncs_imv_notify_connection_change(struct tnc_if_imv *imv,
+ TNC_ConnectionID conn,
+ TNC_ConnectionState state)
+{
+ TNC_Result res;
+
+ if (imv->NotifyConnectionChange == NULL)
+ return 0;
+
+ wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMV_NotifyConnectionChange(%d)"
+ " for IMV '%s'", (int) state, imv->name);
+ res = imv->NotifyConnectionChange(imv->imvID, conn, state);
+ wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_NotifyConnectionChange: %lu",
+ (unsigned long) res);
+
+ return res == TNC_RESULT_SUCCESS ? 0 : -1;
+}
+
+
+static int tncs_load_imv(struct tnc_if_imv *imv)
+{
+ if (imv->path == NULL) {
+ wpa_printf(MSG_DEBUG, "TNC: No IMV configured");
+ return -1;
+ }
+
+ wpa_printf(MSG_DEBUG, "TNC: Opening IMV: %s (%s)",
+ imv->name, imv->path);
+ imv->dlhandle = dlopen(imv->path, RTLD_LAZY);
+ if (imv->dlhandle == NULL) {
+ wpa_printf(MSG_ERROR, "TNC: Failed to open IMV '%s' (%s): %s",
+ imv->name, imv->path, dlerror());
+ return -1;
+ }
+
+ if (tncs_imv_resolve_funcs(imv) < 0) {
+ wpa_printf(MSG_ERROR, "TNC: Failed to resolve IMV functions");
+ return -1;
+ }
+
+ if (tncs_imv_initialize(imv) < 0 ||
+ tncs_imv_provide_bind_function(imv) < 0) {
+ wpa_printf(MSG_ERROR, "TNC: Failed to initialize IMV");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static void tncs_free_imv(struct tnc_if_imv *imv)
+{
+ os_free(imv->name);
+ os_free(imv->path);
+ os_free(imv->supported_types);
+}
+
+static void tncs_unload_imv(struct tnc_if_imv *imv)
+{
+ tncs_imv_terminate(imv);
+
+ if (imv->dlhandle)
+ dlclose(imv->dlhandle);
+
+ tncs_free_imv(imv);
+}
+
+
+static int tncs_supported_type(struct tnc_if_imv *imv, unsigned int type)
+{
+ size_t i;
+ unsigned int vendor, subtype;
+
+ if (imv == NULL || imv->supported_types == NULL)
+ return 0;
+
+ vendor = type >> 8;
+ subtype = type & 0xff;
+
+ for (i = 0; i < imv->num_supported_types; i++) {
+ unsigned int svendor, ssubtype;
+ svendor = imv->supported_types[i] >> 8;
+ ssubtype = imv->supported_types[i] & 0xff;
+ if ((vendor == svendor || svendor == TNC_VENDORID_ANY) &&
+ (subtype == ssubtype || ssubtype == TNC_SUBTYPE_ANY))
+ return 1;
+ }
+
+ return 0;
+}
+
+
+static void tncs_send_to_imvs(struct tncs_data *tncs, unsigned int type,
+ const u8 *msg, size_t len)
+{
+ struct tnc_if_imv *imv;
+ TNC_Result res;
+
+ wpa_hexdump_ascii(MSG_MSGDUMP, "TNC: Message to IMV(s)", msg, len);
+
+ for (imv = tncs->imv; imv; imv = imv->next) {
+ if (imv->ReceiveMessage == NULL ||
+ !tncs_supported_type(imv, type))
+ continue;
+
+ wpa_printf(MSG_DEBUG, "TNC: Call ReceiveMessage for IMV '%s'",
+ imv->name);
+ res = imv->ReceiveMessage(imv->imvID, tncs->connectionID,
+ (TNC_BufferReference) msg, len,
+ type);
+ wpa_printf(MSG_DEBUG, "TNC: ReceiveMessage: %lu",
+ (unsigned long) res);
+ }
+}
+
+
+static void tncs_batch_ending(struct tncs_data *tncs)
+{
+ struct tnc_if_imv *imv;
+ TNC_Result res;
+
+ for (imv = tncs->imv; imv; imv = imv->next) {
+ if (imv->BatchEnding == NULL)
+ continue;
+
+ wpa_printf(MSG_DEBUG, "TNC: Call BatchEnding for IMV '%s'",
+ imv->name);
+ res = imv->BatchEnding(imv->imvID, tncs->connectionID);
+ wpa_printf(MSG_DEBUG, "TNC: BatchEnding: %lu",
+ (unsigned long) res);
+ }
+}
+
+
+static void tncs_solicit_recommendation(struct tncs_data *tncs)
+{
+ struct tnc_if_imv *imv;
+ TNC_Result res;
+
+ for (imv = tncs->imv; imv; imv = imv->next) {
+ if (tncs->imv_data[imv->imvID].recommendation_set)
+ continue;
+
+ wpa_printf(MSG_DEBUG, "TNC: Call SolicitRecommendation for "
+ "IMV '%s'", imv->name);
+ res = imv->SolicitRecommendation(imv->imvID,
+ tncs->connectionID);
+ wpa_printf(MSG_DEBUG, "TNC: SolicitRecommendation: %lu",
+ (unsigned long) res);
+ }
+}
+
+
+void tncs_init_connection(struct tncs_data *tncs)
+{
+ struct tnc_if_imv *imv;
+ int i;
+
+ for (imv = tncs->imv; imv; imv = imv->next) {
+ tncs_imv_notify_connection_change(
+ imv, tncs->connectionID, TNC_CONNECTION_STATE_CREATE);
+ tncs_imv_notify_connection_change(
+ imv, tncs->connectionID,
+ TNC_CONNECTION_STATE_HANDSHAKE);
+ }
+
+ for (i = 0; i < TNC_MAX_IMV_ID; i++) {
+ os_free(tncs->imv_data[i].imv_send);
+ tncs->imv_data[i].imv_send = NULL;
+ tncs->imv_data[i].imv_send_len = 0;
+ }
+}
+
+
+size_t tncs_total_send_len(struct tncs_data *tncs)
+{
+ int i;
+ size_t len = 0;
+
+ for (i = 0; i < TNC_MAX_IMV_ID; i++)
+ len += tncs->imv_data[i].imv_send_len;
+ if (tncs->tncs_message)
+ len += os_strlen(tncs->tncs_message);
+ return len;
+}
+
+
+u8 * tncs_copy_send_buf(struct tncs_data *tncs, u8 *pos)
+{
+ int i;
+
+ for (i = 0; i < TNC_MAX_IMV_ID; i++) {
+ if (tncs->imv_data[i].imv_send == NULL)
+ continue;
+
+ os_memcpy(pos, tncs->imv_data[i].imv_send,
+ tncs->imv_data[i].imv_send_len);
+ pos += tncs->imv_data[i].imv_send_len;
+ os_free(tncs->imv_data[i].imv_send);
+ tncs->imv_data[i].imv_send = NULL;
+ tncs->imv_data[i].imv_send_len = 0;
+ }
+
+ if (tncs->tncs_message) {
+ size_t len = os_strlen(tncs->tncs_message);
+ os_memcpy(pos, tncs->tncs_message, len);
+ pos += len;
+ os_free(tncs->tncs_message);
+ tncs->tncs_message = NULL;
+ }
+
+ return pos;
+}
+
+
+char * tncs_if_tnccs_start(struct tncs_data *tncs)
+{
+ char *buf = os_malloc(1000);
+ if (buf == NULL)
+ return NULL;
+ tncs->last_batchid++;
+ os_snprintf(buf, 1000, IF_TNCCS_START, tncs->last_batchid);
+ return buf;
+}
+
+
+char * tncs_if_tnccs_end(void)
+{
+ char *buf = os_malloc(100);
+ if (buf == NULL)
+ return NULL;
+ os_snprintf(buf, 100, IF_TNCCS_END);
+ return buf;
+}
+
+
+static int tncs_get_type(char *start, unsigned int *type)
+{
+ char *pos = os_strstr(start, "<Type>");
+ if (pos == NULL)
+ return -1;
+ pos += 6;
+ *type = strtoul(pos, NULL, 16);
+ return 0;
+}
+
+
+static unsigned char * tncs_get_base64(char *start, size_t *decoded_len)
+{
+ char *pos, *pos2;
+ unsigned char *decoded;
+
+ pos = os_strstr(start, "<Base64>");
+ if (pos == NULL)
+ return NULL;
+
+ pos += 8;
+ pos2 = os_strstr(pos, "</Base64>");
+ if (pos2 == NULL)
+ return NULL;
+ *pos2 = '\0';
+
+ decoded = base64_decode((unsigned char *) pos, os_strlen(pos),
+ decoded_len);
+ *pos2 = '<';
+ if (decoded == NULL) {
+ wpa_printf(MSG_DEBUG, "TNC: Failed to decode Base64 data");
+ }
+
+ return decoded;
+}
+
+
+static enum tncs_process_res tncs_derive_recommendation(struct tncs_data *tncs)
+{
+ enum IMV_Action_Recommendation rec;
+ struct tnc_if_imv *imv;
+ TNC_ConnectionState state;
+ char *txt;
+
+ wpa_printf(MSG_DEBUG, "TNC: No more messages from IMVs");
+
+ if (tncs->done)
+ return TNCCS_PROCESS_OK_NO_RECOMMENDATION;
+
+ tncs_solicit_recommendation(tncs);
+
+ /* Select the most restrictive recommendation */
+ rec = TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION;
+ for (imv = tncs->imv; imv; imv = imv->next) {
+ TNC_IMV_Action_Recommendation irec;
+ irec = tncs->imv_data[imv->imvID].recommendation;
+ if (irec == TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS)
+ rec = TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS;
+ if (irec == TNC_IMV_ACTION_RECOMMENDATION_ISOLATE &&
+ rec != TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS)
+ rec = TNC_IMV_ACTION_RECOMMENDATION_ISOLATE;
+ if (irec == TNC_IMV_ACTION_RECOMMENDATION_ALLOW &&
+ rec == TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION)
+ rec = TNC_IMV_ACTION_RECOMMENDATION_ALLOW;
+ }
+
+ wpa_printf(MSG_DEBUG, "TNC: Recommendation: %d", rec);
+ tncs->recommendation = rec;
+ tncs->done = 1;
+
+ txt = NULL;
+ switch (rec) {
+ case TNC_IMV_ACTION_RECOMMENDATION_ALLOW:
+ case TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION:
+ txt = "allow";
+ state = TNC_CONNECTION_STATE_ACCESS_ALLOWED;
+ break;
+ case TNC_IMV_ACTION_RECOMMENDATION_ISOLATE:
+ txt = "isolate";
+ state = TNC_CONNECTION_STATE_ACCESS_ISOLATED;
+ break;
+ case TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS:
+ txt = "none";
+ state = TNC_CONNECTION_STATE_ACCESS_NONE;
+ break;
+ default:
+ state = TNC_CONNECTION_STATE_ACCESS_ALLOWED;
+ break;
+ }
+
+ if (txt) {
+ os_free(tncs->tncs_message);
+ tncs->tncs_message = os_zalloc(200);
+ if (tncs->tncs_message) {
+ os_snprintf(tncs->tncs_message, 199,
+ "<TNCC-TNCS-Message><Type>%08X</Type>"
+ "<XML><TNCCS-Recommendation type=\"%s\">"
+ "</TNCCS-Recommendation></XML>"
+ "</TNCC-TNCS-Message>",
+ TNC_TNCCS_RECOMMENDATION, txt);
+ }
+ }
+
+ for (imv = tncs->imv; imv; imv = imv->next) {
+ tncs_imv_notify_connection_change(imv, tncs->connectionID,
+ state);
+ }
+
+ switch (rec) {
+ case TNC_IMV_ACTION_RECOMMENDATION_ALLOW:
+ return TNCCS_RECOMMENDATION_ALLOW;
+ case TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS:
+ return TNCCS_RECOMMENDATION_NO_ACCESS;
+ case TNC_IMV_ACTION_RECOMMENDATION_ISOLATE:
+ return TNCCS_RECOMMENDATION_ISOLATE;
+ case TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION:
+ return TNCCS_RECOMMENDATION_NO_RECOMMENDATION;
+ default:
+ return TNCCS_PROCESS_ERROR;
+ }
+}
+
+
+enum tncs_process_res tncs_process_if_tnccs(struct tncs_data *tncs,
+ const u8 *msg, size_t len)
+{
+ char *buf, *start, *end, *pos, *pos2, *payload;
+ unsigned int batch_id;
+ unsigned char *decoded;
+ size_t decoded_len;
+
+ buf = os_malloc(len + 1);
+ if (buf == NULL)
+ return TNCCS_PROCESS_ERROR;
+
+ os_memcpy(buf, msg, len);
+ buf[len] = '\0';
+ start = os_strstr(buf, "<TNCCS-Batch ");
+ end = os_strstr(buf, "</TNCCS-Batch>");
+ if (start == NULL || end == NULL || start > end) {
+ os_free(buf);
+ return TNCCS_PROCESS_ERROR;
+ }
+
+ start += 13;
+ while (*start == ' ')
+ start++;
+ *end = '\0';
+
+ pos = os_strstr(start, "BatchId=");
+ if (pos == NULL) {
+ os_free(buf);
+ return TNCCS_PROCESS_ERROR;
+ }
+
+ pos += 8;
+ if (*pos == '"')
+ pos++;
+ batch_id = atoi(pos);
+ wpa_printf(MSG_DEBUG, "TNC: Received IF-TNCCS BatchId=%u",
+ batch_id);
+ if (batch_id != tncs->last_batchid + 1) {
+ wpa_printf(MSG_DEBUG, "TNC: Unexpected IF-TNCCS BatchId "
+ "%u (expected %u)",
+ batch_id, tncs->last_batchid + 1);
+ os_free(buf);
+ return TNCCS_PROCESS_ERROR;
+ }
+ tncs->last_batchid = batch_id;
+
+ while (*pos != '\0' && *pos != '>')
+ pos++;
+ if (*pos == '\0') {
+ os_free(buf);
+ return TNCCS_PROCESS_ERROR;
+ }
+ pos++;
+ payload = start;
+
+ /*
+ * <IMC-IMV-Message>
+ * <Type>01234567</Type>
+ * <Base64>foo==</Base64>
+ * </IMC-IMV-Message>
+ */
+
+ while (*start) {
+ char *endpos;
+ unsigned int type;
+
+ pos = os_strstr(start, "<IMC-IMV-Message>");
+ if (pos == NULL)
+ break;
+ start = pos + 17;
+ end = os_strstr(start, "</IMC-IMV-Message>");
+ if (end == NULL)
+ break;
+ *end = '\0';
+ endpos = end;
+ end += 18;
+
+ if (tncs_get_type(start, &type) < 0) {
+ *endpos = '<';
+ start = end;
+ continue;
+ }
+ wpa_printf(MSG_DEBUG, "TNC: IMC-IMV-Message Type 0x%x", type);
+
+ decoded = tncs_get_base64(start, &decoded_len);
+ if (decoded == NULL) {
+ *endpos = '<';
+ start = end;
+ continue;
+ }
+
+ tncs_send_to_imvs(tncs, type, decoded, decoded_len);
+
+ os_free(decoded);
+
+ start = end;
+ }
+
+ /*
+ * <TNCC-TNCS-Message>
+ * <Type>01234567</Type>
+ * <XML><TNCCS-Foo type="foo"></TNCCS-Foo></XML>
+ * <Base64>foo==</Base64>
+ * </TNCC-TNCS-Message>
+ */
+
+ start = payload;
+ while (*start) {
+ unsigned int type;
+ char *xml, *xmlend, *endpos;
+
+ pos = os_strstr(start, "<TNCC-TNCS-Message>");
+ if (pos == NULL)
+ break;
+ start = pos + 19;
+ end = os_strstr(start, "</TNCC-TNCS-Message>");
+ if (end == NULL)
+ break;
+ *end = '\0';
+ endpos = end;
+ end += 20;
+
+ if (tncs_get_type(start, &type) < 0) {
+ *endpos = '<';
+ start = end;
+ continue;
+ }
+ wpa_printf(MSG_DEBUG, "TNC: TNCC-TNCS-Message Type 0x%x",
+ type);
+
+ /* Base64 OR XML */
+ decoded = NULL;
+ xml = NULL;
+ xmlend = NULL;
+ pos = os_strstr(start, "<XML>");
+ if (pos) {
+ pos += 5;
+ pos2 = os_strstr(pos, "</XML>");
+ if (pos2 == NULL) {
+ *endpos = '<';
+ start = end;
+ continue;
+ }
+ xmlend = pos2;
+ xml = pos;
+ } else {
+ decoded = tncs_get_base64(start, &decoded_len);
+ if (decoded == NULL) {
+ *endpos = '<';
+ start = end;
+ continue;
+ }
+ }
+
+ if (decoded) {
+ wpa_hexdump_ascii(MSG_MSGDUMP,
+ "TNC: TNCC-TNCS-Message Base64",
+ decoded, decoded_len);
+ os_free(decoded);
+ }
+
+ if (xml) {
+ wpa_hexdump_ascii(MSG_MSGDUMP,
+ "TNC: TNCC-TNCS-Message XML",
+ (unsigned char *) xml,
+ xmlend - xml);
+ }
+
+ start = end;
+ }
+
+ os_free(buf);
+
+ tncs_batch_ending(tncs);
+
+ if (tncs_total_send_len(tncs) == 0)
+ return tncs_derive_recommendation(tncs);
+
+ return TNCCS_PROCESS_OK_NO_RECOMMENDATION;
+}
+
+
+static struct tnc_if_imv * tncs_parse_imv(int id, char *start, char *end,
+ int *error)
+{
+ struct tnc_if_imv *imv;
+ char *pos, *pos2;
+
+ if (id >= TNC_MAX_IMV_ID) {
+ wpa_printf(MSG_DEBUG, "TNC: Too many IMVs");
+ return NULL;
+ }
+
+ imv = os_zalloc(sizeof(*imv));
+ if (imv == NULL) {
+ *error = 1;
+ return NULL;
+ }
+
+ imv->imvID = id;
+
+ pos = start;
+ wpa_printf(MSG_DEBUG, "TNC: Configured IMV: %s", pos);
+ if (pos + 1 >= end || *pos != '"') {
+ wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMV line '%s' "
+ "(no starting quotation mark)", start);
+ os_free(imv);
+ return NULL;
+ }
+
+ pos++;
+ pos2 = pos;
+ while (pos2 < end && *pos2 != '"')
+ pos2++;
+ if (pos2 >= end) {
+ wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMV line '%s' "
+ "(no ending quotation mark)", start);
+ os_free(imv);
+ return NULL;
+ }
+ *pos2 = '\0';
+ wpa_printf(MSG_DEBUG, "TNC: Name: '%s'", pos);
+ imv->name = os_strdup(pos);
+
+ pos = pos2 + 1;
+ if (pos >= end || *pos != ' ') {
+ wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMV line '%s' "
+ "(no space after name)", start);
+ os_free(imv);
+ return NULL;
+ }
+
+ pos++;
+ wpa_printf(MSG_DEBUG, "TNC: IMV file: '%s'", pos);
+ imv->path = os_strdup(pos);
+
+ return imv;
+}
+
+
+static int tncs_read_config(struct tncs_global *global)
+{
+ char *config, *end, *pos, *line_end;
+ size_t config_len;
+ struct tnc_if_imv *imv, *last;
+ int id = 0;
+
+ last = NULL;
+
+ config = os_readfile(TNC_CONFIG_FILE, &config_len);
+ if (config == NULL) {
+ wpa_printf(MSG_ERROR, "TNC: Could not open TNC configuration "
+ "file '%s'", TNC_CONFIG_FILE);
+ return -1;
+ }
+
+ end = config + config_len;
+ for (pos = config; pos < end; pos = line_end + 1) {
+ line_end = pos;
+ while (*line_end != '\n' && *line_end != '\r' &&
+ line_end < end)
+ line_end++;
+ *line_end = '\0';
+
+ if (os_strncmp(pos, "IMV ", 4) == 0) {
+ int error = 0;
+
+ imv = tncs_parse_imv(id++, pos + 4, line_end, &error);
+ if (error)
+ return -1;
+ if (imv) {
+ if (last == NULL)
+ global->imv = imv;
+ else
+ last->next = imv;
+ last = imv;
+ }
+ }
+ }
+
+ os_free(config);
+
+ return 0;
+}
+
+
+struct tncs_data * tncs_init(void)
+{
+ struct tncs_data *tncs;
+
+ if (tncs_global_data == NULL)
+ return NULL;
+
+ tncs = os_zalloc(sizeof(*tncs));
+ if (tncs == NULL)
+ return NULL;
+ tncs->imv = tncs_global_data->imv;
+ tncs->connectionID = tncs_global_data->next_conn_id++;
+ tncs->next = tncs_global_data->connections;
+ tncs_global_data->connections = tncs;
+
+ return tncs;
+}
+
+
+void tncs_deinit(struct tncs_data *tncs)
+{
+ int i;
+ struct tncs_data *prev, *conn;
+
+ if (tncs == NULL)
+ return;
+
+ for (i = 0; i < TNC_MAX_IMV_ID; i++)
+ os_free(tncs->imv_data[i].imv_send);
+
+ prev = NULL;
+ conn = tncs_global_data->connections;
+ while (conn) {
+ if (conn == tncs) {
+ if (prev)
+ prev->next = tncs->next;
+ else
+ tncs_global_data->connections = tncs->next;
+ break;
+ }
+ prev = conn;
+ conn = conn->next;
+ }
+
+ os_free(tncs->tncs_message);
+ os_free(tncs);
+}
+
+
+int tncs_global_init(void)
+{
+ struct tnc_if_imv *imv;
+
+ tncs_global_data = os_zalloc(sizeof(*tncs_global_data));
+ if (tncs_global_data == NULL)
+ return -1;
+
+ if (tncs_read_config(tncs_global_data) < 0) {
+ wpa_printf(MSG_ERROR, "TNC: Failed to read TNC configuration");
+ goto failed;
+ }
+
+ for (imv = tncs_global_data->imv; imv; imv = imv->next) {
+ if (tncs_load_imv(imv)) {
+ wpa_printf(MSG_ERROR, "TNC: Failed to load IMV '%s'",
+ imv->name);
+ goto failed;
+ }
+ }
+
+ return 0;
+
+failed:
+ tncs_global_deinit();
+ return -1;
+}
+
+
+void tncs_global_deinit(void)
+{
+ struct tnc_if_imv *imv, *prev;
+
+ if (tncs_global_data == NULL)
+ return;
+
+ imv = tncs_global_data->imv;
+ while (imv) {
+ tncs_unload_imv(imv);
+
+ prev = imv;
+ imv = imv->next;
+ os_free(prev);
+ }
+
+ os_free(tncs_global_data);
+ tncs_global_data = NULL;
+}
+
+
+struct wpabuf * tncs_build_soh_request(void)
+{
+ struct wpabuf *buf;
+
+ /*
+ * Build a SoH Request TLV (to be used inside SoH EAP Extensions
+ * Method)
+ */
+
+ buf = wpabuf_alloc(8 + 4);
+ if (buf == NULL)
+ return NULL;
+
+ /* Vendor-Specific TLV (Microsoft) - SoH Request */
+ wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); /* TLV Type */
+ wpabuf_put_be16(buf, 8); /* Length */
+
+ wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* Vendor_Id */
+
+ wpabuf_put_be16(buf, 0x02); /* TLV Type - SoH Request TLV */
+ wpabuf_put_be16(buf, 0); /* Length */
+
+ return buf;
+}
+
+
+struct wpabuf * tncs_process_soh(const u8 *soh_tlv, size_t soh_tlv_len,
+ int *failure)
+{
+ wpa_hexdump(MSG_DEBUG, "TNC: SoH TLV", soh_tlv, soh_tlv_len);
+ *failure = 0;
+
+ /* TODO: return MS-SoH Response TLV */
+
+ return NULL;
+}
diff --git a/src/eap_server/tncs.h b/src/eap_server/tncs.h
new file mode 100644
index 0000000..18a3a1f
--- /dev/null
+++ b/src/eap_server/tncs.h
@@ -0,0 +1,49 @@
+/*
+ * EAP-TNC - TNCS (IF-IMV, IF-TNCCS, and IF-TNCCS-SOH)
+ * Copyright (c) 2007-2008, Jouni Malinen <j@w1.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Alternatively, this software may be distributed under the terms of BSD
+ * license.
+ *
+ * See README and COPYING for more details.
+ */
+
+#ifndef TNCS_H
+#define TNCS_H
+
+struct tncs_data;
+
+struct tncs_data * tncs_init(void);
+void tncs_deinit(struct tncs_data *tncs);
+void tncs_init_connection(struct tncs_data *tncs);
+size_t tncs_total_send_len(struct tncs_data *tncs);
+u8 * tncs_copy_send_buf(struct tncs_data *tncs, u8 *pos);
+char * tncs_if_tnccs_start(struct tncs_data *tncs);
+char * tncs_if_tnccs_end(void);
+
+enum tncs_process_res {
+ TNCCS_PROCESS_ERROR = -1,
+ TNCCS_PROCESS_OK_NO_RECOMMENDATION = 0,
+ TNCCS_RECOMMENDATION_ERROR,
+ TNCCS_RECOMMENDATION_ALLOW,
+ TNCCS_RECOMMENDATION_NONE,
+ TNCCS_RECOMMENDATION_ISOLATE,
+ TNCCS_RECOMMENDATION_NO_ACCESS,
+ TNCCS_RECOMMENDATION_NO_RECOMMENDATION
+};
+
+enum tncs_process_res tncs_process_if_tnccs(struct tncs_data *tncs,
+ const u8 *msg, size_t len);
+
+int tncs_global_init(void);
+void tncs_global_deinit(void);
+
+struct wpabuf * tncs_build_soh_request(void);
+struct wpabuf * tncs_process_soh(const u8 *soh_tlv, size_t soh_tlv_len,
+ int *failure);
+
+#endif /* TNCS_H */