/* * hostapd / EAP-AKA (RFC 4187) * Copyright (c) 2005-2006, Jouni Malinen <jkmaline@cc.hut.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 "hostapd.h"#include "common.h"#include "crypto.h"#include "eap_i.h"#include "eap_sim_common.h"#include "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_SIM_K_AUT_LEN];	u8 k_encr[EAP_SIM_K_ENCR_LEN];	u8 msk[EAP_SIM_KEYING_DATA_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, 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 */};static void eap_aka_determine_identity(struct eap_sm *sm,				       struct eap_aka_data *data,				       int before_identity);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";	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 = wpa_zalloc(sizeof(*data));	if (data == NULL)		return NULL;	data->state = IDENTITY;	eap_aka_determine_identity(sm, data, 1);	return data;}static void eap_aka_reset(struct eap_sm *sm, void *priv){	struct eap_aka_data *data = priv;	free(data->next_pseudonym);	free(data->next_reauth_id);	free(data);}static u8 * eap_aka_build_identity(struct eap_sm *sm,				   struct eap_aka_data *data,				   int id, size_t *reqDataLen){	struct eap_sim_msg *msg;	wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Identity");	msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_AKA,			       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);	}	return eap_sim_msg_finish(msg, reqDataLen, NULL, NULL, 0);}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){	free(data->next_pseudonym);	data->next_pseudonym =		eap_sim_db_get_next_pseudonym(sm->eap_sim_db_priv, 1);	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,				strlen(data->next_pseudonym),				data->next_pseudonym,				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,				strlen(data->next_reauth_id),				data->next_reauth_id,				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 u8 * eap_aka_build_challenge(struct eap_sm *sm,				    struct eap_aka_data *data,				    int id, size_t *reqDataLen){	struct eap_sim_msg *msg;	wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Challenge");	msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_AKA,			       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);	eap_sim_msg_add(msg, EAP_SIM_AT_AUTN, 0, data->autn, EAP_AKA_AUTN_LEN);	if (eap_aka_build_encr(sm, data, msg, 0, NULL)) {		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, reqDataLen, data->k_aut, NULL, 0);}static u8 * eap_aka_build_reauth(struct eap_sm *sm,				 struct eap_aka_data *data,				 int id, size_t *reqDataLen){	struct eap_sim_msg *msg;	wpa_printf(MSG_DEBUG, "EAP-AKA: Generating Re-authentication");	if (hostapd_get_rand(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);	eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk);	eap_sim_derive_keys_reauth(data->counter, sm->identity,				   sm->identity_len, data->nonce_s, data->mk,				   data->msk);	msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_AKA,			       EAP_AKA_SUBTYPE_REAUTHENTICATION);	if (eap_aka_build_encr(sm, data, msg, data->counter, data->nonce_s)) {		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, reqDataLen, data->k_aut, NULL, 0);}static u8 * eap_aka_buildReq(struct eap_sm *sm, void *priv, int id,			     size_t *reqDataLen){	struct eap_aka_data *data = priv;	data->auts_reported = 0;	switch (data->state) {	case IDENTITY:		return eap_aka_build_identity(sm, data, id, reqDataLen);	case CHALLENGE:		return eap_aka_build_challenge(sm, data, id, reqDataLen);	case REAUTH:		return eap_aka_build_reauth(sm, data, id, reqDataLen);	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,			     u8 *respData, size_t respDataLen){	struct eap_aka_data *data = priv;	struct eap_hdr *resp;	u8 *pos, subtype;	size_t len;	resp = (struct eap_hdr *) respData;	pos = (u8 *) (resp + 1);	if (respDataLen < sizeof(*resp) + 4 || *pos != EAP_TYPE_AKA ||	    (len = ntohs(resp->length)) > respDataLen) {		wpa_printf(MSG_INFO, "EAP-AKA: Invalid frame");		return TRUE;	}	subtype = pos[1];	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;	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){	const u8 *identity;	size_t identity_len;	int res;	identity = NULL;	identity_len = 0;	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) {				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;				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");