/* * EAP peer method: EAP-AKA (RFC 4187) * 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"#include "crypto.h"#include "pcsc_funcs.h"#include "eap_sim_common.h"struct eap_aka_data {	u8 ik[EAP_AKA_IK_LEN], ck[EAP_AKA_CK_LEN], res[EAP_AKA_RES_MAX_LEN];	size_t res_len;	u8 nonce_s[EAP_SIM_NONCE_S_LEN];	u8 mk[EAP_SIM_MK_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 rand[EAP_AKA_RAND_LEN], autn[EAP_AKA_AUTN_LEN];	u8 auts[EAP_AKA_AUTS_LEN];	int num_id_req, num_notification;	u8 *pseudonym;	size_t pseudonym_len;	u8 *reauth_id;	size_t reauth_id_len;	int reauth;	unsigned int counter, counter_too_small;	u8 *last_eap_identity;	size_t last_eap_identity_len;	enum { CONTINUE, SUCCESS, FAILURE } state;};static void * eap_aka_init(struct eap_sm *sm){	struct eap_aka_data *data;	data = os_zalloc(sizeof(*data));	if (data == NULL)		return NULL;	data->state = CONTINUE;	return data;}static void eap_aka_deinit(struct eap_sm *sm, void *priv){	struct eap_aka_data *data = priv;	if (data) {		os_free(data->pseudonym);		os_free(data->reauth_id);		os_free(data->last_eap_identity);		os_free(data);	}}static int eap_aka_umts_auth(struct eap_sm *sm, struct eap_aka_data *data){	wpa_printf(MSG_DEBUG, "EAP-AKA: UMTS authentication algorithm");#ifdef PCSC_FUNCS	return scard_umts_auth(sm->scard_ctx, data->rand,			       data->autn, data->res, &data->res_len,			       data->ik, data->ck, data->auts);#else /* PCSC_FUNCS */	/* These hardcoded Kc and SRES values are used for testing.	 * Could consider making them configurable. */	os_memset(data->res, '2', EAP_AKA_RES_MAX_LEN);	data->res_len = EAP_AKA_RES_MAX_LEN;	os_memset(data->ik, '3', EAP_AKA_IK_LEN);	os_memset(data->ck, '4', EAP_AKA_CK_LEN);	{		u8 autn[EAP_AKA_AUTN_LEN];		os_memset(autn, '1', EAP_AKA_AUTN_LEN);		if (os_memcmp(autn, data->autn, EAP_AKA_AUTN_LEN) != 0) {			wpa_printf(MSG_WARNING, "EAP-AKA: AUTN did not match "				   "with expected value");			return -1;		}	}#if 0	{		static int test_resync = 1;		if (test_resync) {			/* Test Resynchronization */			test_resync = 0;			return -2;		}	}#endif	return 0;#endif /* PCSC_FUNCS */}#define CLEAR_PSEUDONYM	0x01#define CLEAR_REAUTH_ID	0x02#define CLEAR_EAP_ID	0x04static void eap_aka_clear_identities(struct eap_aka_data *data, int id){	wpa_printf(MSG_DEBUG, "EAP-AKA: forgetting old%s%s%s",		   id & CLEAR_PSEUDONYM ? " pseudonym" : "",		   id & CLEAR_REAUTH_ID ? " reauth_id" : "",		   id & CLEAR_EAP_ID ? " eap_id" : "");	if (id & CLEAR_PSEUDONYM) {		os_free(data->pseudonym);		data->pseudonym = NULL;		data->pseudonym_len = 0;	}	if (id & CLEAR_REAUTH_ID) {		os_free(data->reauth_id);		data->reauth_id = NULL;		data->reauth_id_len = 0;	}	if (id & CLEAR_EAP_ID) {		os_free(data->last_eap_identity);		data->last_eap_identity = NULL;		data->last_eap_identity_len = 0;	}}static int eap_aka_learn_ids(struct eap_aka_data *data,			     struct eap_sim_attrs *attr){	if (attr->next_pseudonym) {		os_free(data->pseudonym);		data->pseudonym = os_malloc(attr->next_pseudonym_len);		if (data->pseudonym == NULL) {			wpa_printf(MSG_INFO, "EAP-AKA: (encr) No memory for "				   "next pseudonym");			return -1;		}		os_memcpy(data->pseudonym, attr->next_pseudonym,			  attr->next_pseudonym_len);		data->pseudonym_len = attr->next_pseudonym_len;		wpa_hexdump_ascii(MSG_DEBUG,				  "EAP-AKA: (encr) AT_NEXT_PSEUDONYM",				  data->pseudonym,				  data->pseudonym_len);	}	if (attr->next_reauth_id) {		os_free(data->reauth_id);		data->reauth_id = os_malloc(attr->next_reauth_id_len);		if (data->reauth_id == NULL) {			wpa_printf(MSG_INFO, "EAP-AKA: (encr) No memory for "				   "next reauth_id");			return -1;		}		os_memcpy(data->reauth_id, attr->next_reauth_id,			  attr->next_reauth_id_len);		data->reauth_id_len = attr->next_reauth_id_len;		wpa_hexdump_ascii(MSG_DEBUG,				  "EAP-AKA: (encr) AT_NEXT_REAUTH_ID",				  data->reauth_id,				  data->reauth_id_len);	}	return 0;}static u8 * eap_aka_client_error(struct eap_aka_data *data,				 const struct eap_hdr *req,				 size_t *respDataLen, int err){	struct eap_sim_msg *msg;	data->state = FAILURE;	data->num_id_req = 0;	data->num_notification = 0;	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA, EAP_AKA_SUBTYPE_CLIENT_ERROR);	eap_sim_msg_add(msg, EAP_SIM_AT_CLIENT_ERROR_CODE, err, NULL, 0);	return eap_sim_msg_finish(msg, respDataLen, NULL, NULL, 0);}static u8 * eap_aka_authentication_reject(struct eap_aka_data *data,					  const struct eap_hdr *req,					  size_t *respDataLen){	struct eap_sim_msg *msg;	data->state = FAILURE;	data->num_id_req = 0;	data->num_notification = 0;	wpa_printf(MSG_DEBUG, "Generating EAP-AKA Authentication-Reject "		   "(id=%d)", req->identifier);	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA,			       EAP_AKA_SUBTYPE_AUTHENTICATION_REJECT);	return eap_sim_msg_finish(msg, respDataLen, NULL, NULL, 0);}static u8 * eap_aka_synchronization_failure(struct eap_aka_data *data,					    const struct eap_hdr *req,					    size_t *respDataLen){	struct eap_sim_msg *msg;	data->num_id_req = 0;	data->num_notification = 0;	wpa_printf(MSG_DEBUG, "Generating EAP-AKA Synchronization-Failure "		   "(id=%d)", req->identifier);	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA,			       EAP_AKA_SUBTYPE_SYNCHRONIZATION_FAILURE);	wpa_printf(MSG_DEBUG, "   AT_AUTS");	eap_sim_msg_add_full(msg, EAP_SIM_AT_AUTS, data->auts,			     EAP_AKA_AUTS_LEN);	return eap_sim_msg_finish(msg, respDataLen, NULL, NULL, 0);}static u8 * eap_aka_response_identity(struct eap_sm *sm,				      struct eap_aka_data *data,				      const struct eap_hdr *req,				      size_t *respDataLen,				      enum eap_sim_id_req id_req){	const u8 *identity = NULL;	size_t identity_len = 0;	struct eap_sim_msg *msg;	data->reauth = 0;	if (id_req == ANY_ID && data->reauth_id) {		identity = data->reauth_id;		identity_len = data->reauth_id_len;		data->reauth = 1;	} else if ((id_req == ANY_ID || id_req == FULLAUTH_ID) &&		   data->pseudonym) {		identity = data->pseudonym;		identity_len = data->pseudonym_len;		eap_aka_clear_identities(data, CLEAR_REAUTH_ID);	} else if (id_req != NO_ID_REQ) {		identity = eap_get_config_identity(sm, &identity_len);		if (identity) {			eap_aka_clear_identities(data, CLEAR_PSEUDONYM |						 CLEAR_REAUTH_ID);		}	}	if (id_req != NO_ID_REQ)		eap_aka_clear_identities(data, CLEAR_EAP_ID);	wpa_printf(MSG_DEBUG, "Generating EAP-AKA Identity (id=%d)",		   req->identifier);	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA, EAP_AKA_SUBTYPE_IDENTITY);	if (identity) {		wpa_hexdump_ascii(MSG_DEBUG, "   AT_IDENTITY",				  identity, identity_len);		eap_sim_msg_add(msg, EAP_SIM_AT_IDENTITY, identity_len,				identity, identity_len);	}	return eap_sim_msg_finish(msg, respDataLen, NULL, NULL, 0);}static u8 * eap_aka_response_challenge(struct eap_aka_data *data,				       const struct eap_hdr *req,				       size_t *respDataLen){	struct eap_sim_msg *msg;	wpa_printf(MSG_DEBUG, "Generating EAP-AKA Challenge (id=%d)",		   req->identifier);	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA, EAP_AKA_SUBTYPE_CHALLENGE);	wpa_printf(MSG_DEBUG, "   AT_RES");	eap_sim_msg_add(msg, EAP_SIM_AT_RES, data->res_len,			data->res, data->res_len);	wpa_printf(MSG_DEBUG, "   AT_MAC");	eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);	return eap_sim_msg_finish(msg, respDataLen, data->k_aut, (u8 *) "", 0);}static u8 * eap_aka_response_reauth(struct eap_aka_data *data,				    const struct eap_hdr *req,				    size_t *respDataLen, int counter_too_small,				    const u8 *nonce_s){	struct eap_sim_msg *msg;	unsigned int counter;	wpa_printf(MSG_DEBUG, "Generating EAP-AKA Reauthentication (id=%d)",		   req->identifier);	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA,			       EAP_AKA_SUBTYPE_REAUTHENTICATION);	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_too_small) {		wpa_printf(MSG_DEBUG, "   *AT_COUNTER_TOO_SMALL");		eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER_TOO_SMALL, 0, NULL, 0);		counter = data->counter_too_small;	} else		counter = data->counter;	wpa_printf(MSG_DEBUG, "   *AT_COUNTER %d", counter);	eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, 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, respDataLen, data->k_aut, nonce_s,				  EAP_SIM_NONCE_S_LEN);}static u8 * eap_aka_response_notification(struct eap_aka_data *data,					  const struct eap_hdr *req,					  size_t *respDataLen,					  u16 notification){	struct eap_sim_msg *msg;	u8 *k_aut = (notification & 0x4000) == 0 ? data->k_aut : NULL;	wpa_printf(MSG_DEBUG, "Generating EAP-AKA Notification (id=%d)",		   req->identifier);	msg = eap_sim_msg_init(EAP_CODE_RESPONSE, req->identifier,			       EAP_TYPE_AKA, EAP_AKA_SUBTYPE_NOTIFICATION);	if (k_aut && 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 %d", 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;		}	}	if (k_aut) {		wpa_printf(MSG_DEBUG, "   AT_MAC");		eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);	}	return eap_sim_msg_finish(msg, respDataLen, k_aut, (u8 *) "", 0);}static u8 * eap_aka_process_identity(struct eap_sm *sm,				     struct eap_aka_data *data,				     const struct eap_hdr *req,				     size_t *respDataLen,				     struct eap_sim_attrs *attr){	int id_error;	wpa_printf(MSG_DEBUG, "EAP-AKA: subtype Identity");	id_error = 0;	switch (attr->id_req) {	case NO_ID_REQ:		break;	case ANY_ID:		if (data->num_id_req > 0)			id_error++;		data->num_id_req++;		break;	case FULLAUTH_ID:		if (data->num_id_req > 1)			id_error++;		data->num_id_req++;		break;	case PERMANENT_ID:		if (data->num_id_req > 2)			id_error++;		data->num_id_req++;		break;	}	if (id_error) {		wpa_printf(MSG_INFO, "EAP-AKA: Too many ID requests "			   "used within one authentication");		return eap_aka_client_error(data, req, respDataLen,					    EAP_AKA_UNABLE_TO_PROCESS_PACKET);	}	return eap_aka_response_identity(sm, data, req, respDataLen,					 attr->id_req);}static u8 * eap_aka_process_challenge(struct eap_sm *sm,				      struct eap_aka_data *data,				      const struct eap_hdr *req,				      size_t reqDataLen,				      size_t *respDataLen,				      struct eap_sim_attrs *attr){	const u8 *identity;	size_t identity_len;	int res;	struct eap_sim_attrs eattr;	wpa_printf(MSG_DEBUG, "EAP-AKA: subtype Challenge");	data->reauth = 0;	if (!attr->mac || !attr->rand || !attr->autn) {		wpa_printf(MSG_WARNING, "EAP-AKA: Challenge message "			   "did not include%s%s%s",			   !attr->mac ? " AT_MAC" : "",			   !attr->rand ? " AT_RAND" : "",			   !attr->autn ? " AT_AUTN" : "");		return eap_aka_client_error(data, req, respDataLen,					    EAP_AKA_UNABLE_TO_PROCESS_PACKET);	}	os_memcpy(data->rand, attr->rand, EAP_AKA_RAND_LEN);	os_memcpy(data->autn, attr->autn, EAP_AKA_AUTN_LEN);	res = eap_aka_umts_auth(sm, data);	if (res == -1) {		wpa_printf(MSG_WARNING, "EAP-AKA: UMTS authentication "			   "failed (AUTN)");		return eap_aka_authentication_reject(data, req, respDataLen);	} else if (res == -2) {		wpa_printf(MSG_WARNING, "EAP-AKA: UMTS authentication "			   "failed (AUTN seq# -> AUTS)");		return eap_aka_synchronization_failure(data, req, respDataLen);	} else if (res) {		wpa_printf(MSG_WARNING, "EAP-AKA: UMTS authentication failed");		return eap_aka_client_error(data, req, respDataLen,					    EAP_AKA_UNABLE_TO_PROCESS_PACKET);	}	if (data->last_eap_identity) {		identity = data->last_eap_identity;		identity_len = data->last_eap_identity_len;	} else if (data->pseudonym) {		identity = data->pseudonym;		identity_len = data->pseudonym_len;	} else		identity = eap_get_config_identity(sm, &identity_len);