Home | History | Annotate | Download | only in pae
      1 /*
      2  * IEEE 802.1X-2010 Key Agree Protocol of PAE state machine
      3  * Copyright (c) 2013, Qualcomm Atheros, Inc.
      4  *
      5  * This software may be distributed under the terms of the BSD license.
      6  * See README for more details.
      7  */
      8 
      9 #include <time.h>
     10 #include "includes.h"
     11 #include "common.h"
     12 #include "list.h"
     13 #include "eloop.h"
     14 #include "wpabuf.h"
     15 #include "state_machine.h"
     16 #include "l2_packet/l2_packet.h"
     17 #include "common/eapol_common.h"
     18 #include "crypto/aes_wrap.h"
     19 #include "ieee802_1x_cp.h"
     20 #include "ieee802_1x_key.h"
     21 #include "ieee802_1x_kay.h"
     22 #include "ieee802_1x_kay_i.h"
     23 #include "ieee802_1x_secy_ops.h"
     24 
     25 
     26 #define DEFAULT_SA_KEY_LEN	16
     27 #define DEFAULT_ICV_LEN		16
     28 #define MAX_ICV_LEN		32  /* 32 bytes, 256 bits */
     29 
     30 #define PENDING_PN_EXHAUSTION 0xC0000000
     31 
     32 /* IEEE Std 802.1X-2010, Table 9-1 - MKA Algorithm Agility */
     33 #define MKA_ALGO_AGILITY_2009 { 0x00, 0x80, 0xC2, 0x01 }
     34 static u8 mka_algo_agility[4] = MKA_ALGO_AGILITY_2009;
     35 
     36 /* IEEE802.1AE-2006 Table 14-1 MACsec Cipher Suites */
     37 static struct macsec_ciphersuite cipher_suite_tbl[] = {
     38 	/* GCM-AES-128 */
     39 	{
     40 		CS_ID_GCM_AES_128,
     41 		CS_NAME_GCM_AES_128,
     42 		MACSEC_CAP_INTEG_AND_CONF_0_30_50,
     43 		16,
     44 
     45 		0 /* index */
     46 	},
     47 };
     48 #define CS_TABLE_SIZE (ARRAY_SIZE(cipher_suite_tbl))
     49 #define DEFAULT_CS_INDEX  0
     50 
     51 static struct mka_alg mka_alg_tbl[] = {
     52 	{
     53 		MKA_ALGO_AGILITY_2009,
     54 		/* 128-bit CAK, KEK, ICK, ICV */
     55 		16, 16,	16, 16,
     56 		ieee802_1x_cak_128bits_aes_cmac,
     57 		ieee802_1x_ckn_128bits_aes_cmac,
     58 		ieee802_1x_kek_128bits_aes_cmac,
     59 		ieee802_1x_ick_128bits_aes_cmac,
     60 		ieee802_1x_icv_128bits_aes_cmac,
     61 
     62 		1, /* index */
     63 	},
     64 };
     65 #define MKA_ALG_TABLE_SIZE (ARRAY_SIZE(mka_alg_tbl))
     66 
     67 
     68 static int is_ki_equal(struct ieee802_1x_mka_ki *ki1,
     69 		       struct ieee802_1x_mka_ki *ki2)
     70 {
     71 	return os_memcmp(ki1->mi, ki2->mi, MI_LEN) == 0 &&
     72 		ki1->kn == ki2->kn;
     73 }
     74 
     75 
     76 struct mka_param_body_handler {
     77 	int (*body_tx)(struct ieee802_1x_mka_participant *participant,
     78 		       struct wpabuf *buf);
     79 	int (*body_rx)(struct ieee802_1x_mka_participant *participant,
     80 		       const u8 *mka_msg, size_t msg_len);
     81 	int (*body_length)(struct ieee802_1x_mka_participant *participant);
     82 	Boolean (*body_present)(struct ieee802_1x_mka_participant *participant);
     83 };
     84 
     85 
     86 static void set_mka_param_body_len(void *body, unsigned int len)
     87 {
     88 	struct ieee802_1x_mka_hdr *hdr = body;
     89 	hdr->length = (len >> 8) & 0x0f;
     90 	hdr->length1 = len & 0xff;
     91 }
     92 
     93 
     94 static unsigned int get_mka_param_body_len(const void *body)
     95 {
     96 	const struct ieee802_1x_mka_hdr *hdr = body;
     97 	return (hdr->length << 8) | hdr->length1;
     98 }
     99 
    100 
    101 static int get_mka_param_body_type(const void *body)
    102 {
    103 	const struct ieee802_1x_mka_hdr *hdr = body;
    104 	return hdr->type;
    105 }
    106 
    107 
    108 /**
    109  * ieee802_1x_mka_dump_basic_body -
    110  */
    111 static void
    112 ieee802_1x_mka_dump_basic_body(struct ieee802_1x_mka_basic_body *body)
    113 {
    114 	size_t body_len;
    115 
    116 	if (!body)
    117 		return;
    118 
    119 	body_len = get_mka_param_body_len(body);
    120 	wpa_printf(MSG_DEBUG, "*** MKA Basic Parameter set ***");
    121 	wpa_printf(MSG_DEBUG, "\tVersion.......: %d", body->version);
    122 	wpa_printf(MSG_DEBUG, "\tPriority......: %d", body->priority);
    123 	wpa_printf(MSG_DEBUG, "\tKeySvr........: %d", body->key_server);
    124 	wpa_printf(MSG_DEBUG, "\tMACSecDesired.: %d", body->macsec_desired);
    125 	wpa_printf(MSG_DEBUG, "\tMACSecCapable.: %d", body->macsec_capbility);
    126 	wpa_printf(MSG_DEBUG, "\tBody Length...: %d", (int) body_len);
    127 	wpa_printf(MSG_DEBUG, "\tSCI MAC.......: " MACSTR,
    128 		   MAC2STR(body->actor_sci.addr));
    129 	wpa_printf(MSG_DEBUG, "\tSCI Port .....: %d",
    130 		   be_to_host16(body->actor_sci.port));
    131 	wpa_hexdump(MSG_DEBUG, "\tMember Id.....:",
    132 		    body->actor_mi, sizeof(body->actor_mi));
    133 	wpa_printf(MSG_DEBUG, "\tMessage Number: %d",
    134 		   be_to_host32(body->actor_mn));
    135 	wpa_hexdump(MSG_DEBUG, "\tAlgo Agility..:",
    136 		    body->algo_agility, sizeof(body->algo_agility));
    137 	wpa_hexdump_ascii(MSG_DEBUG, "\tCAK Name......:", body->ckn,
    138 			  body_len + MKA_HDR_LEN - sizeof(*body));
    139 }
    140 
    141 
    142 /**
    143  * ieee802_1x_mka_dump_peer_body -
    144  */
    145 static void
    146 ieee802_1x_mka_dump_peer_body(struct ieee802_1x_mka_peer_body *body)
    147 {
    148 	size_t body_len;
    149 	size_t i;
    150 	u8 *mi;
    151 	u32 mn;
    152 
    153 	if (body == NULL)
    154 		return;
    155 
    156 	body_len = get_mka_param_body_len(body);
    157 	if (body->type == MKA_LIVE_PEER_LIST) {
    158 		wpa_printf(MSG_DEBUG, "*** Live Peer List ***");
    159 		wpa_printf(MSG_DEBUG, "\tBody Length...: %d", (int) body_len);
    160 	} else if (body->type == MKA_POTENTIAL_PEER_LIST) {
    161 		wpa_printf(MSG_DEBUG, "*** Potential Live Peer List ***");
    162 		wpa_printf(MSG_DEBUG, "\tBody Length...: %d", (int) body_len);
    163 	}
    164 
    165 	for (i = 0; i < body_len; i += MI_LEN + sizeof(mn)) {
    166 		mi = body->peer + i;
    167 		os_memcpy(&mn, mi + MI_LEN, sizeof(mn));
    168 		wpa_hexdump_ascii(MSG_DEBUG, "\tMember Id.....:", mi, MI_LEN);
    169 		wpa_printf(MSG_DEBUG, "\tMessage Number: %d", be_to_host32(mn));
    170 	}
    171 }
    172 
    173 
    174 /**
    175  * ieee802_1x_mka_dump_dist_sak_body -
    176  */
    177 static void
    178 ieee802_1x_mka_dump_dist_sak_body(struct ieee802_1x_mka_dist_sak_body *body)
    179 {
    180 	size_t body_len;
    181 
    182 	if (body == NULL)
    183 		return;
    184 
    185 	body_len = get_mka_param_body_len(body);
    186 	wpa_printf(MSG_INFO, "*** Distributed SAK ***");
    187 	wpa_printf(MSG_INFO, "\tDistributed AN........: %d", body->dan);
    188 	wpa_printf(MSG_INFO, "\tConfidentiality Offset: %d",
    189 		   body->confid_offset);
    190 	wpa_printf(MSG_INFO, "\tBody Length...........: %d", (int) body_len);
    191 	if (!body_len)
    192 		return;
    193 
    194 	wpa_printf(MSG_INFO, "\tKey Number............: %d",
    195 		   be_to_host32(body->kn));
    196 	wpa_hexdump(MSG_INFO, "\tAES Key Wrap of SAK...:", body->sak, 24);
    197 }
    198 
    199 
    200 static const char * yes_no(int val)
    201 {
    202 	return val ? "Yes" : "No";
    203 }
    204 
    205 
    206 /**
    207  * ieee802_1x_mka_dump_sak_use_body -
    208  */
    209 static void
    210 ieee802_1x_mka_dump_sak_use_body(struct ieee802_1x_mka_sak_use_body *body)
    211 {
    212 	int body_len;
    213 
    214 	if (body == NULL)
    215 		return;
    216 
    217 	body_len = get_mka_param_body_len(body);
    218 	wpa_printf(MSG_DEBUG, "*** MACsec SAK Use ***");
    219 	wpa_printf(MSG_DEBUG, "\tLatest Key AN....: %d", body->lan);
    220 	wpa_printf(MSG_DEBUG, "\tLatest Key Tx....: %s", yes_no(body->ltx));
    221 	wpa_printf(MSG_DEBUG, "\tLatest Key Rx....: %s", yes_no(body->lrx));
    222 	wpa_printf(MSG_DEBUG, "\tOld Key AN....: %d", body->oan);
    223 	wpa_printf(MSG_DEBUG, "\tOld Key Tx....: %s", yes_no(body->otx));
    224 	wpa_printf(MSG_DEBUG, "\tOld Key Rx....: %s", yes_no(body->orx));
    225 	wpa_printf(MSG_DEBUG, "\tPlain Key Tx....: %s", yes_no(body->ptx));
    226 	wpa_printf(MSG_DEBUG, "\tPlain Key Rx....: %s", yes_no(body->prx));
    227 	wpa_printf(MSG_DEBUG, "\tDelay Protect....: %s",
    228 		   yes_no(body->delay_protect));
    229 	wpa_printf(MSG_DEBUG, "\tBody Length......: %d", body_len);
    230 	if (!body_len)
    231 		return;
    232 
    233 	wpa_hexdump(MSG_DEBUG, "\tKey Server MI....:",
    234 		    body->lsrv_mi, sizeof(body->lsrv_mi));
    235 	wpa_printf(MSG_DEBUG, "\tKey Number.......: %u",
    236 		   be_to_host32(body->lkn));
    237 	wpa_printf(MSG_DEBUG, "\tLowest PN........: %u",
    238 		   be_to_host32(body->llpn));
    239 	wpa_hexdump_ascii(MSG_DEBUG, "\tOld Key Server MI....:",
    240 			  body->osrv_mi, sizeof(body->osrv_mi));
    241 	wpa_printf(MSG_DEBUG, "\tOld Key Number.......: %u",
    242 		   be_to_host32(body->okn));
    243 	wpa_printf(MSG_DEBUG, "\tOld Lowest PN........: %u",
    244 		   be_to_host32(body->olpn));
    245 }
    246 
    247 
    248 /**
    249  * ieee802_1x_kay_get_participant -
    250  */
    251 static struct ieee802_1x_mka_participant *
    252 ieee802_1x_kay_get_participant(struct ieee802_1x_kay *kay, const u8 *ckn)
    253 {
    254 	struct ieee802_1x_mka_participant *participant;
    255 
    256 	dl_list_for_each(participant, &kay->participant_list,
    257 			 struct ieee802_1x_mka_participant, list) {
    258 		if (os_memcmp(participant->ckn.name, ckn,
    259 			      participant->ckn.len) == 0)
    260 			return participant;
    261 	}
    262 
    263 	wpa_printf(MSG_DEBUG, "KaY: participant is not found");
    264 
    265 	return NULL;
    266 }
    267 
    268 
    269 /**
    270  * ieee802_1x_kay_get_principal_participant -
    271  */
    272 static struct ieee802_1x_mka_participant *
    273 ieee802_1x_kay_get_principal_participant(struct ieee802_1x_kay *kay)
    274 {
    275 	struct ieee802_1x_mka_participant *participant;
    276 
    277 	dl_list_for_each(participant, &kay->participant_list,
    278 			 struct ieee802_1x_mka_participant, list) {
    279 		if (participant->principal)
    280 			return participant;
    281 	}
    282 
    283 	wpa_printf(MSG_DEBUG, "KaY: principal participant is not founded");
    284 	return NULL;
    285 }
    286 
    287 
    288 static struct ieee802_1x_kay_peer * get_peer_mi(struct dl_list *peers,
    289 						const u8 *mi)
    290 {
    291 	struct ieee802_1x_kay_peer *peer;
    292 
    293 	dl_list_for_each(peer, peers, struct ieee802_1x_kay_peer, list) {
    294 		if (os_memcmp(peer->mi, mi, MI_LEN) == 0)
    295 			return peer;
    296 	}
    297 
    298 	return NULL;
    299 }
    300 
    301 
    302 /**
    303  * ieee802_1x_kay_is_in_potential_peer
    304  */
    305 static Boolean
    306 ieee802_1x_kay_is_in_potential_peer(
    307 	struct ieee802_1x_mka_participant *participant, const u8 *mi)
    308 {
    309 	return get_peer_mi(&participant->potential_peers, mi) != NULL;
    310 }
    311 
    312 
    313 /**
    314  * ieee802_1x_kay_is_in_live_peer
    315  */
    316 static Boolean
    317 ieee802_1x_kay_is_in_live_peer(
    318 	struct ieee802_1x_mka_participant *participant, const u8 *mi)
    319 {
    320 	return get_peer_mi(&participant->live_peers, mi) != NULL;
    321 }
    322 
    323 
    324 /**
    325  * ieee802_1x_kay_is_in_peer
    326  */
    327 static Boolean
    328 ieee802_1x_kay_is_in_peer(struct ieee802_1x_mka_participant *participant,
    329 			  const u8 *mi)
    330 {
    331 	return ieee802_1x_kay_is_in_live_peer(participant, mi) ||
    332 		ieee802_1x_kay_is_in_potential_peer(participant, mi);
    333 }
    334 
    335 
    336 /**
    337  * ieee802_1x_kay_get_peer
    338  */
    339 static struct ieee802_1x_kay_peer *
    340 ieee802_1x_kay_get_peer(struct ieee802_1x_mka_participant *participant,
    341 			const u8 *mi)
    342 {
    343 	struct ieee802_1x_kay_peer *peer;
    344 
    345 	peer = get_peer_mi(&participant->live_peers, mi);
    346 	if (peer)
    347 		return peer;
    348 
    349 	return get_peer_mi(&participant->potential_peers, mi);
    350 }
    351 
    352 
    353 /**
    354  * ieee802_1x_kay_get_live_peer
    355  */
    356 static struct ieee802_1x_kay_peer *
    357 ieee802_1x_kay_get_live_peer(struct ieee802_1x_mka_participant *participant,
    358 			     const u8 *mi)
    359 {
    360 	return get_peer_mi(&participant->live_peers, mi);
    361 }
    362 
    363 
    364 /**
    365  * ieee802_1x_kay_get_cipher_suite
    366  */
    367 static struct macsec_ciphersuite *
    368 ieee802_1x_kay_get_cipher_suite(struct ieee802_1x_mka_participant *participant,
    369 				u8 *cs_id)
    370 {
    371 	unsigned int i;
    372 
    373 	for (i = 0; i < CS_TABLE_SIZE; i++) {
    374 		if (os_memcmp(cipher_suite_tbl[i].id, cs_id, CS_ID_LEN) == 0)
    375 			break;
    376 	}
    377 	if (i >= CS_TABLE_SIZE)
    378 		return NULL;
    379 
    380 	return &cipher_suite_tbl[i];
    381 }
    382 
    383 
    384 /**
    385  * ieee802_1x_kay_get_peer_sci
    386  */
    387 static struct ieee802_1x_kay_peer *
    388 ieee802_1x_kay_get_peer_sci(struct ieee802_1x_mka_participant *participant,
    389 			    const struct ieee802_1x_mka_sci *sci)
    390 {
    391 	struct ieee802_1x_kay_peer *peer;
    392 
    393 	dl_list_for_each(peer, &participant->live_peers,
    394 			 struct ieee802_1x_kay_peer, list) {
    395 		if (os_memcmp(&peer->sci, sci, sizeof(peer->sci)) == 0)
    396 			return peer;
    397 	}
    398 
    399 	dl_list_for_each(peer, &participant->potential_peers,
    400 			 struct ieee802_1x_kay_peer, list) {
    401 		if (os_memcmp(&peer->sci, sci, sizeof(peer->sci)) == 0)
    402 			return peer;
    403 	}
    404 
    405 	return NULL;
    406 }
    407 
    408 
    409 /**
    410  * ieee802_1x_kay_init_receive_sa -
    411  */
    412 static struct receive_sa *
    413 ieee802_1x_kay_init_receive_sa(struct receive_sc *psc, u8 an, u32 lowest_pn,
    414 			       struct data_key *key)
    415 {
    416 	struct receive_sa *psa;
    417 
    418 	if (!psc || !key)
    419 		return NULL;
    420 
    421 	psa = os_zalloc(sizeof(*psa));
    422 	if (!psa) {
    423 		wpa_printf(MSG_ERROR, "%s: out of memory", __func__);
    424 		return NULL;
    425 	}
    426 
    427 	psa->pkey = key;
    428 	psa->lowest_pn = lowest_pn;
    429 	psa->next_pn = lowest_pn;
    430 	psa->an = an;
    431 	psa->sc = psc;
    432 
    433 	os_get_time(&psa->created_time);
    434 	psa->in_use = FALSE;
    435 
    436 	dl_list_add(&psc->sa_list, &psa->list);
    437 	wpa_printf(MSG_DEBUG,
    438 		   "KaY: Create receive SA(AN: %d lowest_pn: %u of SC(channel: %d)",
    439 		   (int) an, lowest_pn, psc->channel);
    440 
    441 	return psa;
    442 }
    443 
    444 
    445 /**
    446  * ieee802_1x_kay_deinit_receive_sa -
    447  */
    448 static void ieee802_1x_kay_deinit_receive_sa(struct receive_sa *psa)
    449 {
    450 	psa->pkey = NULL;
    451 	wpa_printf(MSG_DEBUG,
    452 		   "KaY: Delete receive SA(an: %d) of SC(channel: %d)",
    453 		   psa->an, psa->sc->channel);
    454 	dl_list_del(&psa->list);
    455 	os_free(psa);
    456 }
    457 
    458 
    459 /**
    460  * ieee802_1x_kay_init_receive_sc -
    461  */
    462 static struct receive_sc *
    463 ieee802_1x_kay_init_receive_sc(const struct ieee802_1x_mka_sci *psci,
    464 			       int channel)
    465 {
    466 	struct receive_sc *psc;
    467 
    468 	if (!psci)
    469 		return NULL;
    470 
    471 	psc = os_zalloc(sizeof(*psc));
    472 	if (!psc) {
    473 		wpa_printf(MSG_ERROR, "%s: out of memory", __func__);
    474 		return NULL;
    475 	}
    476 
    477 	os_memcpy(&psc->sci, psci, sizeof(psc->sci));
    478 	psc->channel = channel;
    479 
    480 	os_get_time(&psc->created_time);
    481 	psc->receiving = FALSE;
    482 
    483 	dl_list_init(&psc->sa_list);
    484 	wpa_printf(MSG_DEBUG, "KaY: Create receive SC(channel: %d)", channel);
    485 	wpa_hexdump(MSG_DEBUG, "SCI: ", (u8 *)psci, sizeof(*psci));
    486 
    487 	return psc;
    488 }
    489 
    490 
    491 /**
    492  * ieee802_1x_kay_deinit_receive_sc -
    493  **/
    494 static void
    495 ieee802_1x_kay_deinit_receive_sc(
    496 	struct ieee802_1x_mka_participant *participant, struct receive_sc *psc)
    497 {
    498 	struct receive_sa *psa, *pre_sa;
    499 
    500 	wpa_printf(MSG_DEBUG, "KaY: Delete receive SC(channel: %d)",
    501 		   psc->channel);
    502 	dl_list_for_each_safe(psa, pre_sa, &psc->sa_list, struct receive_sa,
    503 			      list)  {
    504 		secy_disable_receive_sa(participant->kay, psa);
    505 		ieee802_1x_kay_deinit_receive_sa(psa);
    506 	}
    507 	dl_list_del(&psc->list);
    508 	os_free(psc);
    509 }
    510 
    511 
    512 /**
    513  * ieee802_1x_kay_create_live_peer
    514  */
    515 static struct ieee802_1x_kay_peer *
    516 ieee802_1x_kay_create_live_peer(struct ieee802_1x_mka_participant *participant,
    517 				u8 *mi, u32 mn)
    518 {
    519 	struct ieee802_1x_kay_peer *peer;
    520 	struct receive_sc *rxsc;
    521 	u32 sc_ch = 0;
    522 
    523 	peer = os_zalloc(sizeof(*peer));
    524 	if (peer == NULL) {
    525 		wpa_printf(MSG_ERROR, "KaY-%s: out of memory", __func__);
    526 		return NULL;
    527 	}
    528 
    529 	os_memcpy(peer->mi, mi, MI_LEN);
    530 	peer->mn = mn;
    531 	peer->expire = time(NULL) + MKA_LIFE_TIME / 1000;
    532 	peer->sak_used = FALSE;
    533 	os_memcpy(&peer->sci, &participant->current_peer_sci,
    534 		  sizeof(peer->sci));
    535 	dl_list_add(&participant->live_peers, &peer->list);
    536 
    537 	secy_get_available_receive_sc(participant->kay, &sc_ch);
    538 
    539 	rxsc = ieee802_1x_kay_init_receive_sc(&peer->sci, sc_ch);
    540 	if (!rxsc)
    541 		return NULL;
    542 
    543 	dl_list_add(&participant->rxsc_list, &rxsc->list);
    544 	secy_create_receive_sc(participant->kay, rxsc);
    545 
    546 	wpa_printf(MSG_DEBUG, "KaY: Live peer created");
    547 	wpa_hexdump(MSG_DEBUG, "\tMI: ", peer->mi, sizeof(peer->mi));
    548 	wpa_printf(MSG_DEBUG, "\tMN: %d", peer->mn);
    549 	wpa_hexdump(MSG_DEBUG, "\tSCI Addr: ", peer->sci.addr, ETH_ALEN);
    550 	wpa_printf(MSG_DEBUG, "\tPort: %d", peer->sci.port);
    551 
    552 	return peer;
    553 }
    554 
    555 
    556 /**
    557  * ieee802_1x_kay_create_potential_peer
    558  */
    559 static struct ieee802_1x_kay_peer *
    560 ieee802_1x_kay_create_potential_peer(
    561 	struct ieee802_1x_mka_participant *participant, const u8 *mi, u32 mn)
    562 {
    563 	struct ieee802_1x_kay_peer *peer;
    564 
    565 	peer = os_zalloc(sizeof(*peer));
    566 	if (peer == NULL) {
    567 		wpa_printf(MSG_ERROR, "KaY-%s: out of memory", __func__);
    568 		return NULL;
    569 	}
    570 
    571 	os_memcpy(peer->mi, mi, MI_LEN);
    572 	peer->mn = mn;
    573 	peer->expire = time(NULL) + MKA_LIFE_TIME / 1000;
    574 	peer->sak_used = FALSE;
    575 
    576 	dl_list_add(&participant->potential_peers, &peer->list);
    577 
    578 	wpa_printf(MSG_DEBUG, "KaY: potential peer created");
    579 	wpa_hexdump(MSG_DEBUG, "\tMI: ", peer->mi, sizeof(peer->mi));
    580 	wpa_printf(MSG_DEBUG, "\tMN: %d", peer->mn);
    581 	wpa_hexdump(MSG_DEBUG, "\tSCI Addr: ", peer->sci.addr, ETH_ALEN);
    582 	wpa_printf(MSG_DEBUG, "\tPort: %d", peer->sci.port);
    583 
    584 	return peer;
    585 }
    586 
    587 
    588 /**
    589  * ieee802_1x_kay_move_live_peer
    590  */
    591 static struct ieee802_1x_kay_peer *
    592 ieee802_1x_kay_move_live_peer(struct ieee802_1x_mka_participant *participant,
    593 			      u8 *mi, u32 mn)
    594 {
    595 	struct ieee802_1x_kay_peer *peer;
    596 	struct receive_sc *rxsc;
    597 	u32 sc_ch = 0;
    598 
    599 	dl_list_for_each(peer, &participant->potential_peers,
    600 			 struct ieee802_1x_kay_peer, list) {
    601 		if (os_memcmp(peer->mi, mi, MI_LEN) == 0)
    602 			break;
    603 	}
    604 
    605 	os_memcpy(&peer->sci, &participant->current_peer_sci,
    606 		  sizeof(peer->sci));
    607 	peer->mn = mn;
    608 	peer->expire = time(NULL) + MKA_LIFE_TIME / 1000;
    609 
    610 	wpa_printf(MSG_DEBUG, "KaY: move potential peer to live peer");
    611 	wpa_hexdump(MSG_DEBUG, "\tMI: ", peer->mi, sizeof(peer->mi));
    612 	wpa_printf(MSG_DEBUG, "\tMN: %d", peer->mn);
    613 	wpa_hexdump(MSG_DEBUG, "\tSCI Addr: ", peer->sci.addr, ETH_ALEN);
    614 	wpa_printf(MSG_DEBUG, "\tPort: %d", peer->sci.port);
    615 
    616 	dl_list_del(&peer->list);
    617 	dl_list_add_tail(&participant->live_peers, &peer->list);
    618 
    619 	secy_get_available_receive_sc(participant->kay, &sc_ch);
    620 
    621 	rxsc = ieee802_1x_kay_init_receive_sc(&peer->sci, sc_ch);
    622 	if (!rxsc)
    623 		return NULL;
    624 
    625 	dl_list_add(&participant->rxsc_list, &rxsc->list);
    626 	secy_create_receive_sc(participant->kay, rxsc);
    627 
    628 	return peer;
    629 }
    630 
    631 
    632 
    633 /**
    634  *  ieee802_1x_mka_basic_body_present -
    635  */
    636 static Boolean
    637 ieee802_1x_mka_basic_body_present(
    638 	struct ieee802_1x_mka_participant *participant)
    639 {
    640 	return TRUE;
    641 }
    642 
    643 
    644 /**
    645  * ieee802_1x_mka_basic_body_length -
    646  */
    647 static int
    648 ieee802_1x_mka_basic_body_length(struct ieee802_1x_mka_participant *participant)
    649 {
    650 	int length;
    651 
    652 	length = sizeof(struct ieee802_1x_mka_basic_body);
    653 	length += participant->ckn.len;
    654 	return (length + 0x3) & ~0x3;
    655 }
    656 
    657 
    658 /**
    659  * ieee802_1x_mka_encode_basic_body
    660  */
    661 static int
    662 ieee802_1x_mka_encode_basic_body(
    663 	struct ieee802_1x_mka_participant *participant,
    664 	struct wpabuf *buf)
    665 {
    666 	struct ieee802_1x_mka_basic_body *body;
    667 	struct ieee802_1x_kay *kay = participant->kay;
    668 	unsigned int length = ieee802_1x_mka_basic_body_length(participant);
    669 
    670 	body = wpabuf_put(buf, length);
    671 
    672 	body->version = kay->mka_version;
    673 	body->priority = kay->actor_priority;
    674 	if (participant->is_elected)
    675 		body->key_server = participant->is_key_server;
    676 	else
    677 		body->key_server = participant->can_be_key_server;
    678 
    679 	body->macsec_desired = kay->macsec_desired;
    680 	body->macsec_capbility = kay->macsec_capable;
    681 	set_mka_param_body_len(body, length - MKA_HDR_LEN);
    682 
    683 	os_memcpy(body->actor_sci.addr, kay->actor_sci.addr,
    684 		  sizeof(kay->actor_sci.addr));
    685 	body->actor_sci.port = host_to_be16(kay->actor_sci.port);
    686 
    687 	os_memcpy(body->actor_mi, participant->mi, sizeof(body->actor_mi));
    688 	participant->mn = participant->mn + 1;
    689 	body->actor_mn = host_to_be32(participant->mn);
    690 	os_memcpy(body->algo_agility, participant->kay->algo_agility,
    691 		  sizeof(body->algo_agility));
    692 
    693 	os_memcpy(body->ckn, participant->ckn.name, participant->ckn.len);
    694 
    695 	ieee802_1x_mka_dump_basic_body(body);
    696 
    697 	return 0;
    698 }
    699 
    700 
    701 /**
    702  * ieee802_1x_mka_decode_basic_body -
    703  */
    704 static struct ieee802_1x_mka_participant *
    705 ieee802_1x_mka_decode_basic_body(struct ieee802_1x_kay *kay, const u8 *mka_msg,
    706 				 size_t msg_len)
    707 {
    708 	struct ieee802_1x_mka_participant *participant;
    709 	const struct ieee802_1x_mka_basic_body *body;
    710 	struct ieee802_1x_kay_peer *peer;
    711 
    712 	body = (const struct ieee802_1x_mka_basic_body *) mka_msg;
    713 
    714 	if (body->version > MKA_VERSION_ID) {
    715 		wpa_printf(MSG_DEBUG,
    716 			   "KaY: peer's version(%d) greater than mka current version(%d)",
    717 			   body->version, MKA_VERSION_ID);
    718 	}
    719 	if (kay->is_obliged_key_server && body->key_server) {
    720 		wpa_printf(MSG_DEBUG, "I must be as key server");
    721 		return NULL;
    722 	}
    723 
    724 	participant = ieee802_1x_kay_get_participant(kay, body->ckn);
    725 	if (!participant) {
    726 		wpa_printf(MSG_DEBUG, "Peer is not included in my CA");
    727 		return NULL;
    728 	}
    729 
    730 	/* If the peer's MI is my MI, I will choose new MI */
    731 	if (os_memcmp(body->actor_mi, participant->mi, MI_LEN) == 0) {
    732 		os_get_random(participant->mi, sizeof(participant->mi));
    733 		participant->mn = 0;
    734 	}
    735 
    736 	os_memcpy(participant->current_peer_id.mi, body->actor_mi, MI_LEN);
    737 	participant->current_peer_id.mn =  be_to_host32(body->actor_mn);
    738 	os_memcpy(participant->current_peer_sci.addr, body->actor_sci.addr,
    739 		  sizeof(participant->current_peer_sci.addr));
    740 	participant->current_peer_sci.port = be_to_host16(body->actor_sci.port);
    741 
    742 	/* handler peer */
    743 	peer = ieee802_1x_kay_get_peer(participant, body->actor_mi);
    744 	if (!peer) {
    745 		/* Check duplicated SCI */
    746 		/* TODO: What policy should be applied to detect duplicated SCI
    747 		 * is active attacker or a valid peer whose MI is be changed?
    748 		 */
    749 		peer = ieee802_1x_kay_get_peer_sci(participant,
    750 						   &body->actor_sci);
    751 		if (peer) {
    752 			wpa_printf(MSG_WARNING,
    753 				   "KaY: duplicated SCI detected, Maybe active attacker");
    754 			dl_list_del(&peer->list);
    755 			os_free(peer);
    756 		}
    757 
    758 		peer = ieee802_1x_kay_create_potential_peer(
    759 			participant, body->actor_mi,
    760 			be_to_host32(body->actor_mn));
    761 		if (!peer)
    762 			return NULL;
    763 
    764 		peer->macsec_desired = body->macsec_desired;
    765 		peer->macsec_capbility = body->macsec_capbility;
    766 		peer->is_key_server = (Boolean) body->key_server;
    767 		peer->key_server_priority = body->priority;
    768 	} else if (peer->mn < be_to_host32(body->actor_mn)) {
    769 		peer->mn = be_to_host32(body->actor_mn);
    770 		peer->expire = time(NULL) + MKA_LIFE_TIME / 1000;
    771 		peer->macsec_desired = body->macsec_desired;
    772 		peer->macsec_capbility = body->macsec_capbility;
    773 		peer->is_key_server = (Boolean) body->key_server;
    774 		peer->key_server_priority = body->priority;
    775 	} else {
    776 		wpa_printf(MSG_WARNING, "KaY: The peer MN have received");
    777 		return NULL;
    778 	}
    779 
    780 	return participant;
    781 }
    782 
    783 
    784 /**
    785  * ieee802_1x_mka_live_peer_body_present
    786  */
    787 static Boolean
    788 ieee802_1x_mka_live_peer_body_present(
    789 	struct ieee802_1x_mka_participant *participant)
    790 {
    791 	return !dl_list_empty(&participant->live_peers);
    792 }
    793 
    794 
    795 /**
    796  * ieee802_1x_kay_get_live_peer_length
    797  */
    798 static int
    799 ieee802_1x_mka_get_live_peer_length(
    800 	struct ieee802_1x_mka_participant *participant)
    801 {
    802 	int len = MKA_HDR_LEN;
    803 	struct ieee802_1x_kay_peer *peer;
    804 
    805 	dl_list_for_each(peer, &participant->live_peers,
    806 			 struct ieee802_1x_kay_peer, list)
    807 		len += sizeof(struct ieee802_1x_mka_peer_id);
    808 
    809 	return (len + 0x3) & ~0x3;
    810 }
    811 
    812 
    813 /**
    814  * ieee802_1x_mka_encode_live_peer_body -
    815  */
    816 static int
    817 ieee802_1x_mka_encode_live_peer_body(
    818 	struct ieee802_1x_mka_participant *participant,
    819 	struct wpabuf *buf)
    820 {
    821 	struct ieee802_1x_mka_peer_body *body;
    822 	struct ieee802_1x_kay_peer *peer;
    823 	unsigned int length;
    824 	struct ieee802_1x_mka_peer_id *body_peer;
    825 
    826 	length = ieee802_1x_mka_get_live_peer_length(participant);
    827 	body = wpabuf_put(buf, sizeof(struct ieee802_1x_mka_peer_body));
    828 
    829 	body->type = MKA_LIVE_PEER_LIST;
    830 	set_mka_param_body_len(body, length - MKA_HDR_LEN);
    831 
    832 	dl_list_for_each(peer, &participant->live_peers,
    833 			 struct ieee802_1x_kay_peer, list) {
    834 		body_peer = wpabuf_put(buf,
    835 				       sizeof(struct ieee802_1x_mka_peer_id));
    836 		os_memcpy(body_peer->mi, peer->mi, MI_LEN);
    837 		body_peer->mn = host_to_be32(peer->mn);
    838 		body_peer++;
    839 	}
    840 
    841 	ieee802_1x_mka_dump_peer_body(body);
    842 	return 0;
    843 }
    844 
    845 /**
    846  * ieee802_1x_mka_potential_peer_body_present
    847  */
    848 static Boolean
    849 ieee802_1x_mka_potential_peer_body_present(
    850 	struct ieee802_1x_mka_participant *participant)
    851 {
    852 	return !dl_list_empty(&participant->potential_peers);
    853 }
    854 
    855 
    856 /**
    857  * ieee802_1x_kay_get_potential_peer_length
    858  */
    859 static int
    860 ieee802_1x_mka_get_potential_peer_length(
    861 	struct ieee802_1x_mka_participant *participant)
    862 {
    863 	int len = MKA_HDR_LEN;
    864 	struct ieee802_1x_kay_peer *peer;
    865 
    866 	dl_list_for_each(peer, &participant->potential_peers,
    867 			 struct ieee802_1x_kay_peer, list)
    868 		len += sizeof(struct ieee802_1x_mka_peer_id);
    869 
    870 	return (len + 0x3) & ~0x3;
    871 }
    872 
    873 
    874 /**
    875  * ieee802_1x_mka_encode_potential_peer_body -
    876  */
    877 static int
    878 ieee802_1x_mka_encode_potential_peer_body(
    879 	struct ieee802_1x_mka_participant *participant,
    880 	struct wpabuf *buf)
    881 {
    882 	struct ieee802_1x_mka_peer_body *body;
    883 	struct ieee802_1x_kay_peer *peer;
    884 	unsigned int length;
    885 	struct ieee802_1x_mka_peer_id *body_peer;
    886 
    887 	length = ieee802_1x_mka_get_potential_peer_length(participant);
    888 	body = wpabuf_put(buf, sizeof(struct ieee802_1x_mka_peer_body));
    889 
    890 	body->type = MKA_POTENTIAL_PEER_LIST;
    891 	set_mka_param_body_len(body, length - MKA_HDR_LEN);
    892 
    893 	dl_list_for_each(peer, &participant->potential_peers,
    894 			 struct ieee802_1x_kay_peer, list) {
    895 		body_peer = wpabuf_put(buf,
    896 				       sizeof(struct ieee802_1x_mka_peer_id));
    897 		os_memcpy(body_peer->mi, peer->mi, MI_LEN);
    898 		body_peer->mn = host_to_be32(peer->mn);
    899 		body_peer++;
    900 	}
    901 
    902 	ieee802_1x_mka_dump_peer_body(body);
    903 	return 0;
    904 }
    905 
    906 
    907 /**
    908  * ieee802_1x_mka_i_in_peerlist -
    909  */
    910 static Boolean
    911 ieee802_1x_mka_i_in_peerlist(struct ieee802_1x_mka_participant *participant,
    912 			     const u8 *mka_msg, size_t msg_len)
    913 {
    914 	Boolean included = FALSE;
    915 	struct ieee802_1x_mka_hdr *hdr;
    916 	size_t body_len;
    917 	size_t left_len;
    918 	int body_type;
    919 	u32 peer_mn;
    920 	const u8 *peer_mi;
    921 	const u8 *pos;
    922 	size_t i;
    923 
    924 	pos = mka_msg;
    925 	left_len = msg_len;
    926 	while (left_len > (MKA_HDR_LEN + DEFAULT_ICV_LEN)) {
    927 		hdr = (struct ieee802_1x_mka_hdr *) pos;
    928 		body_len = get_mka_param_body_len(hdr);
    929 		body_type = get_mka_param_body_type(hdr);
    930 
    931 		if (body_type != MKA_LIVE_PEER_LIST &&
    932 		    body_type != MKA_POTENTIAL_PEER_LIST)
    933 			goto SKIP_PEER;
    934 
    935 		ieee802_1x_mka_dump_peer_body(
    936 			(struct ieee802_1x_mka_peer_body *)pos);
    937 
    938 		if (left_len < (MKA_HDR_LEN + body_len + DEFAULT_ICV_LEN)) {
    939 			wpa_printf(MSG_ERROR,
    940 				   "KaY: MKA Peer Packet Body Length (%d bytes) is less than the Parameter Set Header Length (%d bytes) + the Parameter Set Body Length (%d bytes) + %d bytes of ICV",
    941 				   (int) left_len, (int) MKA_HDR_LEN,
    942 				   (int) body_len, DEFAULT_ICV_LEN);
    943 			goto SKIP_PEER;
    944 		}
    945 
    946 		if ((body_len % 16) != 0) {
    947 			wpa_printf(MSG_ERROR,
    948 				   "KaY: MKA Peer Packet Body Length (%d bytes) should multiple of 16 octets",
    949 				   (int) body_len);
    950 			goto SKIP_PEER;
    951 		}
    952 
    953 		for (i = 0; i < body_len; i += MI_LEN + sizeof(peer_mn)) {
    954 			peer_mi = MKA_HDR_LEN + pos + i;
    955 			os_memcpy(&peer_mn, peer_mi + MI_LEN, sizeof(peer_mn));
    956 			peer_mn = be_to_host32(peer_mn);
    957 			if (os_memcmp(peer_mi, participant->mi, MI_LEN) == 0 &&
    958 			    peer_mn == participant->mn) {
    959 				included = TRUE;
    960 				break;
    961 			}
    962 		}
    963 
    964 		if (included)
    965 			return TRUE;
    966 
    967 SKIP_PEER:
    968 		left_len -= body_len + MKA_HDR_LEN;
    969 		pos += body_len + MKA_HDR_LEN;
    970 	}
    971 
    972 	return FALSE;
    973 }
    974 
    975 
    976 /**
    977  * ieee802_1x_mka_decode_live_peer_body -
    978  */
    979 static int ieee802_1x_mka_decode_live_peer_body(
    980 	struct ieee802_1x_mka_participant *participant,
    981 	const u8 *peer_msg, size_t msg_len)
    982 {
    983 	const struct ieee802_1x_mka_hdr *hdr;
    984 	struct ieee802_1x_kay_peer *peer;
    985 	size_t body_len;
    986 	u32 peer_mn;
    987 	const u8 *peer_mi;
    988 	size_t i;
    989 	Boolean is_included;
    990 
    991 	is_included = ieee802_1x_kay_is_in_live_peer(
    992 		participant, participant->current_peer_id.mi);
    993 
    994 	hdr = (const struct ieee802_1x_mka_hdr *) peer_msg;
    995 	body_len = get_mka_param_body_len(hdr);
    996 
    997 	for (i = 0; i < body_len; i += MI_LEN + sizeof(peer_mn)) {
    998 		peer_mi = MKA_HDR_LEN + peer_msg + i;
    999 		os_memcpy(&peer_mn, peer_mi + MI_LEN, sizeof(peer_mn));
   1000 		peer_mn = be_to_host32(peer_mn);
   1001 
   1002 		/* it is myself */
   1003 		if (os_memcmp(peer_mi, participant->mi, MI_LEN) == 0) {
   1004 			/* My message id is used by other participant */
   1005 			if (peer_mn > participant->mn) {
   1006 				os_get_random(participant->mi,
   1007 					      sizeof(participant->mi));
   1008 				participant->mn = 0;
   1009 			}
   1010 			continue;
   1011 		}
   1012 		if (!is_included)
   1013 			continue;
   1014 
   1015 		peer = ieee802_1x_kay_get_peer(participant, peer_mi);
   1016 		if (NULL != peer) {
   1017 			peer->mn = peer_mn;
   1018 			peer->expire = time(NULL) + MKA_LIFE_TIME / 1000;
   1019 		} else {
   1020 			if (!ieee802_1x_kay_create_potential_peer(
   1021 				participant, peer_mi, peer_mn)) {
   1022 				return -1;
   1023 			}
   1024 		}
   1025 	}
   1026 
   1027 	return 0;
   1028 }
   1029 
   1030 
   1031 /**
   1032  * ieee802_1x_mka_decode_potential_peer_body -
   1033  */
   1034 static int
   1035 ieee802_1x_mka_decode_potential_peer_body(
   1036 	struct ieee802_1x_mka_participant *participant,
   1037 	const u8 *peer_msg, size_t msg_len)
   1038 {
   1039 	struct ieee802_1x_mka_hdr *hdr;
   1040 	size_t body_len;
   1041 	u32 peer_mn;
   1042 	const u8 *peer_mi;
   1043 	size_t i;
   1044 
   1045 	hdr = (struct ieee802_1x_mka_hdr *) peer_msg;
   1046 	body_len = get_mka_param_body_len(hdr);
   1047 
   1048 	for (i = 0; i < body_len; i += MI_LEN + sizeof(peer_mn)) {
   1049 		peer_mi = MKA_HDR_LEN + peer_msg + i;
   1050 		os_memcpy(&peer_mn, peer_mi + MI_LEN, sizeof(peer_mn));
   1051 		peer_mn = be_to_host32(peer_mn);
   1052 
   1053 		/* it is myself */
   1054 		if (os_memcmp(peer_mi, participant->mi, MI_LEN) == 0) {
   1055 			/* My message id is used by other participant */
   1056 			if (peer_mn > participant->mn) {
   1057 				os_get_random(participant->mi,
   1058 					      sizeof(participant->mi));
   1059 				participant->mn = 0;
   1060 			}
   1061 			continue;
   1062 		}
   1063 	}
   1064 
   1065 	return 0;
   1066 }
   1067 
   1068 
   1069 /**
   1070  * ieee802_1x_mka_sak_use_body_present
   1071  */
   1072 static Boolean
   1073 ieee802_1x_mka_sak_use_body_present(
   1074 	struct ieee802_1x_mka_participant *participant)
   1075 {
   1076 	if (participant->to_use_sak)
   1077 		return TRUE;
   1078 	else
   1079 		return FALSE;
   1080 }
   1081 
   1082 
   1083 /**
   1084  * ieee802_1x_mka_get_sak_use_length
   1085  */
   1086 static int
   1087 ieee802_1x_mka_get_sak_use_length(
   1088 	struct ieee802_1x_mka_participant *participant)
   1089 {
   1090 	int length = MKA_HDR_LEN;
   1091 
   1092 	if (participant->kay->macsec_desired && participant->advised_desired)
   1093 		length = sizeof(struct ieee802_1x_mka_sak_use_body);
   1094 	else
   1095 		length = MKA_HDR_LEN;
   1096 
   1097 	length = (length + 0x3) & ~0x3;
   1098 
   1099 	return length;
   1100 }
   1101 
   1102 
   1103 /**
   1104  *
   1105  */
   1106 static u32
   1107 ieee802_1x_mka_get_lpn(struct ieee802_1x_mka_participant *principal,
   1108 		       struct ieee802_1x_mka_ki *ki)
   1109 {
   1110 	struct receive_sa *rxsa;
   1111 	struct receive_sc *rxsc;
   1112 	u32 lpn = 0;
   1113 
   1114 	dl_list_for_each(rxsc, &principal->rxsc_list, struct receive_sc, list) {
   1115 		dl_list_for_each(rxsa, &rxsc->sa_list, struct receive_sa, list)
   1116 		{
   1117 			if (is_ki_equal(&rxsa->pkey->key_identifier, ki)) {
   1118 				secy_get_receive_lowest_pn(principal->kay,
   1119 							   rxsa);
   1120 
   1121 				lpn = lpn > rxsa->lowest_pn ?
   1122 					lpn : rxsa->lowest_pn;
   1123 				break;
   1124 			}
   1125 		}
   1126 	}
   1127 
   1128 	if (lpn == 0)
   1129 		lpn = 1;
   1130 
   1131 	return lpn;
   1132 }
   1133 
   1134 
   1135 /**
   1136  * ieee802_1x_mka_encode_sak_use_body -
   1137  */
   1138 static int
   1139 ieee802_1x_mka_encode_sak_use_body(
   1140 	struct ieee802_1x_mka_participant *participant,
   1141 	struct wpabuf *buf)
   1142 {
   1143 	struct ieee802_1x_mka_sak_use_body *body;
   1144 	unsigned int length;
   1145 	u32 pn = 1;
   1146 
   1147 	length = ieee802_1x_mka_get_sak_use_length(participant);
   1148 	body = wpabuf_put(buf, sizeof(struct ieee802_1x_mka_sak_use_body));
   1149 
   1150 	body->type = MKA_SAK_USE;
   1151 	set_mka_param_body_len(body, length - MKA_HDR_LEN);
   1152 
   1153 	if (length == MKA_HDR_LEN) {
   1154 		body->ptx = TRUE;
   1155 		body->prx = TRUE;
   1156 		body->lan = 0;
   1157 		body->lrx = FALSE;
   1158 		body->ltx = FALSE;
   1159 		body->delay_protect = FALSE;
   1160 		return 0;
   1161 	}
   1162 
   1163 	/* data protect, lowest accept packet number */
   1164 	body->delay_protect = participant->kay->macsec_replay_protect;
   1165 	pn = ieee802_1x_mka_get_lpn(participant, &participant->lki);
   1166 	if (pn > participant->kay->pn_exhaustion) {
   1167 		wpa_printf(MSG_WARNING, "KaY: My LPN exhaustion");
   1168 		if (participant->is_key_server)
   1169 			participant->new_sak = TRUE;
   1170 	}
   1171 
   1172 	body->llpn = host_to_be32(pn);
   1173 	pn = ieee802_1x_mka_get_lpn(participant, &participant->oki);
   1174 	body->olpn = host_to_be32(pn);
   1175 
   1176 	/* plain tx, plain rx */
   1177 	if (participant->kay->macsec_protect)
   1178 		body->ptx = FALSE;
   1179 	else
   1180 		body->ptx = TRUE;
   1181 
   1182 	if (participant->kay->macsec_validate == Strict)
   1183 		body->prx = FALSE;
   1184 	else
   1185 		body->prx = TRUE;
   1186 
   1187 	/* latest key: rx, tx, key server member identifier key number */
   1188 	body->lan = participant->lan;
   1189 	os_memcpy(body->lsrv_mi, participant->lki.mi,
   1190 		  sizeof(body->lsrv_mi));
   1191 	body->lkn = host_to_be32(participant->lki.kn);
   1192 	body->lrx = participant->lrx;
   1193 	body->ltx = participant->ltx;
   1194 
   1195 	/* old key: rx, tx, key server member identifier key number */
   1196 	body->oan = participant->oan;
   1197 	if (participant->oki.kn != participant->lki.kn &&
   1198 	    participant->oki.kn != 0) {
   1199 		body->otx = TRUE;
   1200 		body->orx = TRUE;
   1201 		os_memcpy(body->osrv_mi, participant->oki.mi,
   1202 			  sizeof(body->osrv_mi));
   1203 		body->okn = host_to_be32(participant->oki.kn);
   1204 	} else {
   1205 		body->otx = FALSE;
   1206 		body->orx = FALSE;
   1207 	}
   1208 
   1209 	/* set CP's variable */
   1210 	if (body->ltx) {
   1211 		if (!participant->kay->tx_enable)
   1212 			participant->kay->tx_enable = TRUE;
   1213 
   1214 		if (!participant->kay->port_enable)
   1215 			participant->kay->port_enable = TRUE;
   1216 	}
   1217 	if (body->lrx) {
   1218 		if (!participant->kay->rx_enable)
   1219 			participant->kay->rx_enable = TRUE;
   1220 	}
   1221 
   1222 	ieee802_1x_mka_dump_sak_use_body(body);
   1223 	return 0;
   1224 }
   1225 
   1226 
   1227 /**
   1228  * ieee802_1x_mka_decode_sak_use_body -
   1229  */
   1230 static int
   1231 ieee802_1x_mka_decode_sak_use_body(
   1232 	struct ieee802_1x_mka_participant *participant,
   1233 	const u8 *mka_msg, size_t msg_len)
   1234 {
   1235 	struct ieee802_1x_mka_hdr *hdr;
   1236 	struct ieee802_1x_mka_sak_use_body *body;
   1237 	struct ieee802_1x_kay_peer *peer;
   1238 	struct transmit_sa *txsa;
   1239 	struct data_key *sa_key = NULL;
   1240 	size_t body_len;
   1241 	struct ieee802_1x_mka_ki ki;
   1242 	u32 lpn;
   1243 	Boolean all_receiving;
   1244 	Boolean founded;
   1245 
   1246 	if (!participant->principal) {
   1247 		wpa_printf(MSG_WARNING, "KaY: Participant is not principal");
   1248 		return -1;
   1249 	}
   1250 	peer = ieee802_1x_kay_get_live_peer(participant,
   1251 					    participant->current_peer_id.mi);
   1252 	if (!peer) {
   1253 		wpa_printf(MSG_WARNING, "KaY: the peer is not my live peer");
   1254 		return -1;
   1255 	}
   1256 
   1257 	hdr = (struct ieee802_1x_mka_hdr *) mka_msg;
   1258 	body_len = get_mka_param_body_len(hdr);
   1259 	body = (struct ieee802_1x_mka_sak_use_body *) mka_msg;
   1260 	ieee802_1x_mka_dump_sak_use_body(body);
   1261 
   1262 	if ((body_len != 0) && (body_len < 40)) {
   1263 		wpa_printf(MSG_ERROR,
   1264 			   "KaY: MKA Use SAK Packet Body Length (%d bytes) should be 0, 40, or more octets",
   1265 			   (int) body_len);
   1266 		return -1;
   1267 	}
   1268 
   1269 	/* TODO: what action should I take when peer does not support MACsec */
   1270 	if (body_len == 0) {
   1271 		wpa_printf(MSG_WARNING, "KaY: Peer does not support MACsec");
   1272 		return 0;
   1273 	}
   1274 
   1275 	/* TODO: when the plain tx or rx of peer is true, should I change
   1276 	 * the attribute of controlled port
   1277 	 */
   1278 	if (body->prx)
   1279 		wpa_printf(MSG_WARNING, "KaY: peer's plain rx are TRUE");
   1280 
   1281 	if (body->ptx)
   1282 		wpa_printf(MSG_WARNING, "KaY: peer's plain tx are TRUE");
   1283 
   1284 	/* check latest key is valid */
   1285 	if (body->ltx || body->lrx) {
   1286 		founded = FALSE;
   1287 		os_memcpy(ki.mi, body->lsrv_mi, sizeof(ki.mi));
   1288 		ki.kn = ntohl(body->lkn);
   1289 		dl_list_for_each(sa_key, &participant->sak_list,
   1290 				 struct data_key, list) {
   1291 			if (is_ki_equal(&sa_key->key_identifier, &ki)) {
   1292 				founded = TRUE;
   1293 				break;
   1294 			}
   1295 		}
   1296 		if (!founded) {
   1297 			wpa_printf(MSG_WARNING, "KaY: Latest key is invalid");
   1298 			return -1;
   1299 		}
   1300 		if (os_memcmp(participant->lki.mi, body->lsrv_mi,
   1301 			      sizeof(participant->lki.mi)) == 0 &&
   1302 		    ntohl(body->lkn) == participant->lki.kn &&
   1303 		    body->lan == participant->lan) {
   1304 			peer->sak_used = TRUE;
   1305 		}
   1306 		if (body->ltx && peer->is_key_server) {
   1307 			ieee802_1x_cp_set_servertransmitting(
   1308 				participant->kay->cp, TRUE);
   1309 			ieee802_1x_cp_sm_step(participant->kay->cp);
   1310 		}
   1311 	}
   1312 
   1313 	/* check old key is valid */
   1314 	if (body->otx || body->orx) {
   1315 		if (os_memcmp(participant->oki.mi, body->osrv_mi,
   1316 			      sizeof(participant->oki.mi)) != 0 ||
   1317 		    ntohl(body->okn) != participant->oki.kn ||
   1318 		    body->oan != participant->oan) {
   1319 			wpa_printf(MSG_WARNING, "KaY: Old key is invalid");
   1320 			return -1;
   1321 		}
   1322 	}
   1323 
   1324 	/* TODO: how to set the MACsec hardware when delay_protect is true */
   1325 	if (body->delay_protect && (!ntohl(body->llpn) || !ntohl(body->olpn))) {
   1326 		wpa_printf(MSG_WARNING,
   1327 			   "KaY: Lowest packet number should greater than 0 when delay_protect is TRUE");
   1328 		return -1;
   1329 	}
   1330 
   1331 	/* check all live peer have used the sak for receiving sa */
   1332 	all_receiving = TRUE;
   1333 	dl_list_for_each(peer, &participant->live_peers,
   1334 			 struct ieee802_1x_kay_peer, list) {
   1335 		if (!peer->sak_used) {
   1336 			all_receiving = FALSE;
   1337 			break;
   1338 		}
   1339 	}
   1340 	if (all_receiving) {
   1341 		participant->to_dist_sak = FALSE;
   1342 		ieee802_1x_cp_set_allreceiving(participant->kay->cp, TRUE);
   1343 		ieee802_1x_cp_sm_step(participant->kay->cp);
   1344 	}
   1345 
   1346 	/* if i'm key server, and detects peer member pn exhaustion, rekey.*/
   1347 	lpn = ntohl(body->llpn);
   1348 	if (lpn > participant->kay->pn_exhaustion) {
   1349 		if (participant->is_key_server) {
   1350 			participant->new_sak = TRUE;
   1351 			wpa_printf(MSG_WARNING, "KaY: Peer LPN exhaustion");
   1352 		}
   1353 	}
   1354 
   1355 	founded = FALSE;
   1356 	dl_list_for_each(txsa, &participant->txsc->sa_list,
   1357 			 struct transmit_sa, list) {
   1358 		if (sa_key != NULL && txsa->pkey == sa_key) {
   1359 			founded = TRUE;
   1360 			break;
   1361 		}
   1362 	}
   1363 	if (!founded) {
   1364 		wpa_printf(MSG_WARNING, "KaY: Can't find txsa");
   1365 		return -1;
   1366 	}
   1367 
   1368 	/* FIXME: Secy creates txsa with default npn. If MKA detected Latest Key
   1369 	 * npn is larger than txsa's npn, set it to txsa.
   1370 	 */
   1371 	secy_get_transmit_next_pn(participant->kay, txsa);
   1372 	if (lpn > txsa->next_pn) {
   1373 		secy_set_transmit_next_pn(participant->kay, txsa);
   1374 		wpa_printf(MSG_INFO, "KaY: update lpn =0x%x", lpn);
   1375 	}
   1376 
   1377 	return 0;
   1378 }
   1379 
   1380 
   1381 /**
   1382  * ieee802_1x_mka_dist_sak_body_present
   1383  */
   1384 static Boolean
   1385 ieee802_1x_mka_dist_sak_body_present(
   1386 	struct ieee802_1x_mka_participant *participant)
   1387 {
   1388 	if (!participant->to_dist_sak || !participant->new_key)
   1389 		return FALSE;
   1390 
   1391 	return TRUE;
   1392 }
   1393 
   1394 
   1395 /**
   1396  * ieee802_1x_kay_get_dist_sak_length
   1397  */
   1398 static int
   1399 ieee802_1x_mka_get_dist_sak_length(
   1400 	struct ieee802_1x_mka_participant *participant)
   1401 {
   1402 	int length;
   1403 	int cs_index = participant->kay->macsec_csindex;
   1404 
   1405 	if (participant->advised_desired) {
   1406 		length = sizeof(struct ieee802_1x_mka_dist_sak_body);
   1407 		if (cs_index != DEFAULT_CS_INDEX)
   1408 			length += CS_ID_LEN;
   1409 
   1410 		length += cipher_suite_tbl[cs_index].sak_len + 8;
   1411 	} else {
   1412 		length = MKA_HDR_LEN;
   1413 	}
   1414 	length = (length + 0x3) & ~0x3;
   1415 
   1416 	return length;
   1417 }
   1418 
   1419 
   1420 /**
   1421  * ieee802_1x_mka_encode_dist_sak_body -
   1422  */
   1423 static int
   1424 ieee802_1x_mka_encode_dist_sak_body(
   1425 	struct ieee802_1x_mka_participant *participant,
   1426 	struct wpabuf *buf)
   1427 {
   1428 	struct ieee802_1x_mka_dist_sak_body *body;
   1429 	struct data_key *sak;
   1430 	unsigned int length;
   1431 	int cs_index;
   1432 	int sak_pos;
   1433 
   1434 	length = ieee802_1x_mka_get_dist_sak_length(participant);
   1435 	body = wpabuf_put(buf, length);
   1436 	body->type = MKA_DISTRIBUTED_SAK;
   1437 	set_mka_param_body_len(body, length - MKA_HDR_LEN);
   1438 	if (length == MKA_HDR_LEN) {
   1439 		body->confid_offset = 0;
   1440 		body->dan = 0;
   1441 		return 0;
   1442 	}
   1443 
   1444 	sak = participant->new_key;
   1445 	body->confid_offset = sak->confidentiality_offset;
   1446 	body->dan = sak->an;
   1447 	body->kn = host_to_be32(sak->key_identifier.kn);
   1448 	cs_index = participant->kay->macsec_csindex;
   1449 	sak_pos = 0;
   1450 	if (cs_index != DEFAULT_CS_INDEX) {
   1451 		os_memcpy(body->sak, cipher_suite_tbl[cs_index].id, CS_ID_LEN);
   1452 		sak_pos = CS_ID_LEN;
   1453 	}
   1454 	if (aes_wrap(participant->kek.key, 16,
   1455 		     cipher_suite_tbl[cs_index].sak_len / 8,
   1456 		     sak->key, body->sak + sak_pos)) {
   1457 		wpa_printf(MSG_ERROR, "KaY: AES wrap failed");
   1458 		return -1;
   1459 	}
   1460 
   1461 	ieee802_1x_mka_dump_dist_sak_body(body);
   1462 
   1463 	return 0;
   1464 }
   1465 
   1466 
   1467 /**
   1468  * ieee802_1x_kay_init_data_key -
   1469  */
   1470 static struct data_key *
   1471 ieee802_1x_kay_init_data_key(const struct key_conf *conf)
   1472 {
   1473 	struct data_key *pkey;
   1474 
   1475 	if (!conf)
   1476 		return NULL;
   1477 
   1478 	pkey = os_zalloc(sizeof(*pkey));
   1479 	if (pkey == NULL) {
   1480 		wpa_printf(MSG_ERROR, "%s: out of memory", __func__);
   1481 		return NULL;
   1482 	}
   1483 
   1484 	pkey->key = os_zalloc(conf->key_len);
   1485 	if (pkey->key == NULL) {
   1486 		wpa_printf(MSG_ERROR, "%s: out of memory", __func__);
   1487 		os_free(pkey);
   1488 		return NULL;
   1489 	}
   1490 
   1491 	os_memcpy(pkey->key, conf->key, conf->key_len);
   1492 	os_memcpy(&pkey->key_identifier, &conf->ki,
   1493 		  sizeof(pkey->key_identifier));
   1494 	pkey->confidentiality_offset = conf->offset;
   1495 	pkey->an = conf->an;
   1496 	pkey->transmits = conf->tx;
   1497 	pkey->receives = conf->rx;
   1498 	os_get_time(&pkey->created_time);
   1499 
   1500 	pkey->user = 1;
   1501 
   1502 	return pkey;
   1503 }
   1504 
   1505 
   1506 /**
   1507  * ieee802_1x_kay_decode_dist_sak_body -
   1508  */
   1509 static int
   1510 ieee802_1x_mka_decode_dist_sak_body(
   1511 	struct ieee802_1x_mka_participant *participant,
   1512 	const u8 *mka_msg, size_t msg_len)
   1513 {
   1514 	struct ieee802_1x_mka_hdr *hdr;
   1515 	struct ieee802_1x_mka_dist_sak_body *body;
   1516 	struct ieee802_1x_kay_peer *peer;
   1517 	struct macsec_ciphersuite *cs;
   1518 	size_t body_len;
   1519 	struct key_conf *conf;
   1520 	struct data_key *sa_key = NULL;
   1521 	struct ieee802_1x_mka_ki sak_ki;
   1522 	int sak_len;
   1523 	u8 *wrap_sak;
   1524 	u8 *unwrap_sak;
   1525 
   1526 	hdr = (struct ieee802_1x_mka_hdr *) mka_msg;
   1527 	body_len = get_mka_param_body_len(hdr);
   1528 	if ((body_len != 0) && (body_len != 28) && (body_len < 36)) {
   1529 		wpa_printf(MSG_ERROR,
   1530 			   "KaY: MKA Use SAK Packet Body Length (%d bytes) should be 0, 28, 36, or more octets",
   1531 			   (int) body_len);
   1532 		return -1;
   1533 	}
   1534 
   1535 	if (!participant->principal) {
   1536 		wpa_printf(MSG_ERROR,
   1537 			   "KaY: I can't accept the distributed SAK as I am not principal");
   1538 		return -1;
   1539 	}
   1540 	if (participant->is_key_server) {
   1541 		wpa_printf(MSG_ERROR,
   1542 			   "KaY: I can't accept the distributed SAK as myself is key server ");
   1543 		return -1;
   1544 	}
   1545 	if (!participant->kay->macsec_desired ||
   1546 	    participant->kay->macsec_capable == MACSEC_CAP_NOT_IMPLEMENTED) {
   1547 		wpa_printf(MSG_ERROR,
   1548 			   "KaY: I am not MACsec-desired or without MACsec capable");
   1549 		return -1;
   1550 	}
   1551 
   1552 	peer = ieee802_1x_kay_get_live_peer(participant,
   1553 					    participant->current_peer_id.mi);
   1554 	if (!peer) {
   1555 		wpa_printf(MSG_ERROR,
   1556 			   "KaY: The key server is not in my live peers list");
   1557 		return -1;
   1558 	}
   1559 	if (os_memcmp(&participant->kay->key_server_sci,
   1560 		      &peer->sci, sizeof(struct ieee802_1x_mka_sci)) != 0) {
   1561 		wpa_printf(MSG_ERROR, "KaY: The key server is not elected");
   1562 		return -1;
   1563 	}
   1564 	if (body_len == 0) {
   1565 		participant->kay->authenticated = TRUE;
   1566 		participant->kay->secured = FALSE;
   1567 		participant->kay->failed = FALSE;
   1568 		participant->advised_desired = FALSE;
   1569 		ieee802_1x_cp_connect_authenticated(participant->kay->cp);
   1570 		ieee802_1x_cp_sm_step(participant->kay->cp);
   1571 		wpa_printf(MSG_WARNING, "KaY:The Key server advise no MACsec");
   1572 		participant->to_use_sak = TRUE;
   1573 		return 0;
   1574 	}
   1575 	participant->advised_desired = TRUE;
   1576 	participant->kay->authenticated = FALSE;
   1577 	participant->kay->secured = TRUE;
   1578 	participant->kay->failed = FALSE;
   1579 	ieee802_1x_cp_connect_secure(participant->kay->cp);
   1580 	ieee802_1x_cp_sm_step(participant->kay->cp);
   1581 
   1582 	body = (struct ieee802_1x_mka_dist_sak_body *)mka_msg;
   1583 	ieee802_1x_mka_dump_dist_sak_body(body);
   1584 	dl_list_for_each(sa_key, &participant->sak_list, struct data_key, list)
   1585 	{
   1586 		if (os_memcmp(sa_key->key_identifier.mi,
   1587 			      participant->current_peer_id.mi, MI_LEN) == 0 &&
   1588 		    sa_key->key_identifier.kn == be_to_host32(body->kn)) {
   1589 			wpa_printf(MSG_WARNING, "KaY:The Key has installed");
   1590 			return 0;
   1591 		}
   1592 	}
   1593 	if (body_len == 28) {
   1594 		sak_len = DEFAULT_SA_KEY_LEN;
   1595 		wrap_sak =  body->sak;
   1596 		participant->kay->macsec_csindex = DEFAULT_CS_INDEX;
   1597 	} else {
   1598 		cs = ieee802_1x_kay_get_cipher_suite(participant, body->sak);
   1599 		if (!cs) {
   1600 			wpa_printf(MSG_ERROR,
   1601 				   "KaY: I can't support the Cipher Suite advised by key server");
   1602 			return -1;
   1603 		}
   1604 		sak_len = cs->sak_len;
   1605 		wrap_sak = body->sak + CS_ID_LEN;
   1606 		participant->kay->macsec_csindex = cs->index;
   1607 	}
   1608 
   1609 	unwrap_sak = os_zalloc(sak_len);
   1610 	if (!unwrap_sak) {
   1611 		wpa_printf(MSG_ERROR, "KaY-%s: Out of memory", __func__);
   1612 		return -1;
   1613 	}
   1614 	if (aes_unwrap(participant->kek.key, 16, sak_len >> 3, wrap_sak,
   1615 		       unwrap_sak)) {
   1616 		wpa_printf(MSG_ERROR, "KaY: AES unwrap failed");
   1617 		os_free(unwrap_sak);
   1618 		return -1;
   1619 	}
   1620 	wpa_hexdump(MSG_DEBUG, "\tAES Key Unwrap of SAK:", unwrap_sak, sak_len);
   1621 
   1622 	conf = os_zalloc(sizeof(*conf));
   1623 	if (!conf) {
   1624 		wpa_printf(MSG_ERROR, "KaY-%s: Out of memory", __func__);
   1625 		os_free(unwrap_sak);
   1626 		return -1;
   1627 	}
   1628 	conf->key_len = sak_len;
   1629 
   1630 	conf->key = os_zalloc(conf->key_len);
   1631 	if (!conf->key) {
   1632 		wpa_printf(MSG_ERROR, "KaY-%s: Out of memory", __func__);
   1633 		os_free(unwrap_sak);
   1634 		os_free(conf);
   1635 		return -1;
   1636 	}
   1637 
   1638 	os_memcpy(conf->key, unwrap_sak, conf->key_len);
   1639 
   1640 	os_memcpy(&sak_ki.mi, &participant->current_peer_id.mi,
   1641 		  sizeof(sak_ki.mi));
   1642 	sak_ki.kn = be_to_host32(body->kn);
   1643 
   1644 	os_memcpy(conf->ki.mi, sak_ki.mi, MI_LEN);
   1645 	conf->ki.kn = sak_ki.kn;
   1646 	conf->an = body->dan;
   1647 	conf->offset = body->confid_offset;
   1648 	conf->rx = TRUE;
   1649 	conf->tx = TRUE;
   1650 
   1651 	sa_key = ieee802_1x_kay_init_data_key(conf);
   1652 	if (!sa_key) {
   1653 		os_free(unwrap_sak);
   1654 		os_free(conf->key);
   1655 		os_free(conf);
   1656 		return -1;
   1657 	}
   1658 
   1659 	dl_list_add(&participant->sak_list, &sa_key->list);
   1660 
   1661 	ieee802_1x_cp_set_ciphersuite(
   1662 		participant->kay->cp,
   1663 		cipher_suite_tbl[participant->kay->macsec_csindex].id);
   1664 	ieee802_1x_cp_sm_step(participant->kay->cp);
   1665 	ieee802_1x_cp_set_offset(participant->kay->cp, body->confid_offset);
   1666 	ieee802_1x_cp_sm_step(participant->kay->cp);
   1667 	ieee802_1x_cp_set_distributedki(participant->kay->cp, &sak_ki);
   1668 	ieee802_1x_cp_set_distributedan(participant->kay->cp, body->dan);
   1669 	ieee802_1x_cp_signal_newsak(participant->kay->cp);
   1670 	ieee802_1x_cp_sm_step(participant->kay->cp);
   1671 
   1672 	participant->to_use_sak = TRUE;
   1673 
   1674 	os_free(unwrap_sak);
   1675 	os_free(conf->key);
   1676 	os_free(conf);
   1677 
   1678 	return 0;
   1679 }
   1680 
   1681 
   1682 /**
   1683  * ieee802_1x_mka_icv_body_present
   1684  */
   1685 static Boolean
   1686 ieee802_1x_mka_icv_body_present(struct ieee802_1x_mka_participant *participant)
   1687 {
   1688 	return TRUE;
   1689 }
   1690 
   1691 
   1692 /**
   1693  * ieee802_1x_kay_get_icv_length
   1694  */
   1695 static int
   1696 ieee802_1x_mka_get_icv_length(struct ieee802_1x_mka_participant *participant)
   1697 {
   1698 	int length;
   1699 
   1700 	length = sizeof(struct ieee802_1x_mka_icv_body);
   1701 	length += mka_alg_tbl[participant->kay->mka_algindex].icv_len;
   1702 
   1703 	return (length + 0x3) & ~0x3;
   1704 }
   1705 
   1706 
   1707 /**
   1708  * ieee802_1x_mka_encode_icv_body -
   1709  */
   1710 static int
   1711 ieee802_1x_mka_encode_icv_body(struct ieee802_1x_mka_participant *participant,
   1712 			       struct wpabuf *buf)
   1713 {
   1714 	struct ieee802_1x_mka_icv_body *body;
   1715 	unsigned int length;
   1716 	u8 cmac[MAX_ICV_LEN];
   1717 
   1718 	length = ieee802_1x_mka_get_icv_length(participant);
   1719 	if (length != DEFAULT_ICV_LEN)  {
   1720 		body = wpabuf_put(buf, MKA_HDR_LEN);
   1721 		body->type = MKA_ICV_INDICATOR;
   1722 		set_mka_param_body_len(body, length - MKA_HDR_LEN);
   1723 	}
   1724 
   1725 	if (mka_alg_tbl[participant->kay->mka_algindex].icv_hash(
   1726 		    participant->ick.key, wpabuf_head(buf), buf->used, cmac)) {
   1727 		wpa_printf(MSG_ERROR, "KaY, omac1_aes_128 failed");
   1728 		return -1;
   1729 	}
   1730 
   1731 	if (length != DEFAULT_ICV_LEN)  {
   1732 		os_memcpy(wpabuf_put(buf, length - MKA_HDR_LEN), cmac,
   1733 			  length - MKA_HDR_LEN);
   1734 	} else {
   1735 		os_memcpy(wpabuf_put(buf, length), cmac, length);
   1736 	}
   1737 
   1738 	return 0;
   1739 }
   1740 
   1741 /**
   1742  * ieee802_1x_mka_decode_icv_body -
   1743  */
   1744 static u8 *
   1745 ieee802_1x_mka_decode_icv_body(struct ieee802_1x_mka_participant *participant,
   1746 			       const u8 *mka_msg, size_t msg_len)
   1747 {
   1748 	struct ieee802_1x_mka_hdr *hdr;
   1749 	struct ieee802_1x_mka_icv_body *body;
   1750 	size_t body_len;
   1751 	size_t left_len;
   1752 	int body_type;
   1753 	const u8 *pos;
   1754 
   1755 	pos = mka_msg;
   1756 	left_len = msg_len;
   1757 	while (left_len > (MKA_HDR_LEN + DEFAULT_ICV_LEN)) {
   1758 		hdr = (struct ieee802_1x_mka_hdr *) pos;
   1759 		body_len = get_mka_param_body_len(hdr);
   1760 		body_type = get_mka_param_body_type(hdr);
   1761 
   1762 		if (left_len < (body_len + MKA_HDR_LEN))
   1763 			break;
   1764 
   1765 		if (body_type != MKA_ICV_INDICATOR) {
   1766 			left_len -= MKA_HDR_LEN + body_len;
   1767 			pos += MKA_HDR_LEN + body_len;
   1768 			continue;
   1769 		}
   1770 
   1771 		body = (struct ieee802_1x_mka_icv_body *)pos;
   1772 		if (body_len
   1773 			< mka_alg_tbl[participant->kay->mka_algindex].icv_len) {
   1774 			return NULL;
   1775 		}
   1776 
   1777 		return body->icv;
   1778 	}
   1779 
   1780 	return (u8 *) (mka_msg + msg_len - DEFAULT_ICV_LEN);
   1781 }
   1782 
   1783 
   1784 /**
   1785  * ieee802_1x_mka_decode_dist_cak_body-
   1786  */
   1787 static int
   1788 ieee802_1x_mka_decode_dist_cak_body(
   1789 	struct ieee802_1x_mka_participant *participant,
   1790 	const u8 *mka_msg, size_t msg_len)
   1791 {
   1792 	struct ieee802_1x_mka_hdr *hdr;
   1793 	size_t body_len;
   1794 
   1795 	hdr = (struct ieee802_1x_mka_hdr *) mka_msg;
   1796 	body_len = get_mka_param_body_len(hdr);
   1797 	if (body_len < 28) {
   1798 		wpa_printf(MSG_ERROR,
   1799 			   "KaY: MKA Use SAK Packet Body Length (%d bytes) should be 28 or more octets",
   1800 			   (int) body_len);
   1801 		return -1;
   1802 	}
   1803 
   1804 	return 0;
   1805 }
   1806 
   1807 
   1808 /**
   1809  * ieee802_1x_mka_decode_kmd_body -
   1810  */
   1811 static int
   1812 ieee802_1x_mka_decode_kmd_body(
   1813 	struct ieee802_1x_mka_participant *participant,
   1814 	const u8 *mka_msg, size_t msg_len)
   1815 {
   1816 	struct ieee802_1x_mka_hdr *hdr;
   1817 	size_t body_len;
   1818 
   1819 	hdr = (struct ieee802_1x_mka_hdr *) mka_msg;
   1820 	body_len = get_mka_param_body_len(hdr);
   1821 	if (body_len < 5) {
   1822 		wpa_printf(MSG_ERROR,
   1823 			   "KaY: MKA Use SAK Packet Body Length (%d bytes) should be 5 or more octets",
   1824 			   (int) body_len);
   1825 		return -1;
   1826 	}
   1827 
   1828 	return 0;
   1829 }
   1830 
   1831 
   1832 /**
   1833  * ieee802_1x_mka_decode_announce_body -
   1834  */
   1835 static int ieee802_1x_mka_decode_announce_body(
   1836 	struct ieee802_1x_mka_participant *participant,
   1837 	const u8 *mka_msg, size_t msg_len)
   1838 {
   1839 	return 0;
   1840 }
   1841 
   1842 
   1843 static struct mka_param_body_handler mak_body_handler[] = {
   1844 	/* basic parameter set */
   1845 	{
   1846 		ieee802_1x_mka_encode_basic_body,
   1847 		NULL,
   1848 		ieee802_1x_mka_basic_body_length,
   1849 		ieee802_1x_mka_basic_body_present
   1850 	},
   1851 
   1852 	/* live peer list parameter set */
   1853 	{
   1854 		ieee802_1x_mka_encode_live_peer_body,
   1855 		ieee802_1x_mka_decode_live_peer_body,
   1856 		ieee802_1x_mka_get_live_peer_length,
   1857 		ieee802_1x_mka_live_peer_body_present
   1858 	},
   1859 
   1860 	/* potential peer list parameter set */
   1861 	{
   1862 		ieee802_1x_mka_encode_potential_peer_body,
   1863 		ieee802_1x_mka_decode_potential_peer_body,
   1864 		ieee802_1x_mka_get_potential_peer_length,
   1865 		ieee802_1x_mka_potential_peer_body_present
   1866 	},
   1867 
   1868 	/* sak use parameter set */
   1869 	{
   1870 		ieee802_1x_mka_encode_sak_use_body,
   1871 		ieee802_1x_mka_decode_sak_use_body,
   1872 		ieee802_1x_mka_get_sak_use_length,
   1873 		ieee802_1x_mka_sak_use_body_present
   1874 	},
   1875 
   1876 	/* distribute sak parameter set */
   1877 	{
   1878 		ieee802_1x_mka_encode_dist_sak_body,
   1879 		ieee802_1x_mka_decode_dist_sak_body,
   1880 		ieee802_1x_mka_get_dist_sak_length,
   1881 		ieee802_1x_mka_dist_sak_body_present
   1882 	},
   1883 
   1884 	/* distribute cak parameter set */
   1885 	{
   1886 		NULL,
   1887 		ieee802_1x_mka_decode_dist_cak_body,
   1888 		NULL,
   1889 		NULL
   1890 	},
   1891 
   1892 	/* kmd parameter set */
   1893 	{
   1894 		NULL,
   1895 		ieee802_1x_mka_decode_kmd_body,
   1896 		NULL,
   1897 		NULL
   1898 	},
   1899 
   1900 	/* announce parameter set */
   1901 	{
   1902 		NULL,
   1903 		ieee802_1x_mka_decode_announce_body,
   1904 		NULL,
   1905 		NULL
   1906 	},
   1907 
   1908 	/* icv parameter set */
   1909 	{
   1910 		ieee802_1x_mka_encode_icv_body,
   1911 		NULL,
   1912 		ieee802_1x_mka_get_icv_length,
   1913 		ieee802_1x_mka_icv_body_present
   1914 	},
   1915 };
   1916 
   1917 
   1918 /**
   1919  * ieee802_1x_kay_deinit_data_key -
   1920  */
   1921 void ieee802_1x_kay_deinit_data_key(struct data_key *pkey)
   1922 {
   1923 	if (!pkey)
   1924 		return;
   1925 
   1926 	pkey->user--;
   1927 	if (pkey->user > 1)
   1928 		return;
   1929 
   1930 	dl_list_del(&pkey->list);
   1931 	os_free(pkey->key);
   1932 	os_free(pkey);
   1933 }
   1934 
   1935 
   1936 /**
   1937  * ieee802_1x_kay_generate_new_sak -
   1938  */
   1939 static int
   1940 ieee802_1x_kay_generate_new_sak(struct ieee802_1x_mka_participant *participant)
   1941 {
   1942 	struct data_key *sa_key = NULL;
   1943 	struct key_conf *conf;
   1944 	struct ieee802_1x_kay_peer *peer;
   1945 	struct ieee802_1x_kay *kay = participant->kay;
   1946 	int ctx_len, ctx_offset;
   1947 	u8 *context;
   1948 
   1949 	/* check condition for generating a fresh SAK:
   1950 	 * must have one live peer
   1951 	 * and MKA life time elapse since last distribution
   1952 	 * or potential peer is empty
   1953 	 */
   1954 	if (dl_list_empty(&participant->live_peers)) {
   1955 		wpa_printf(MSG_ERROR,
   1956 			   "KaY: Live peers list must not empty when generating fresh SAK");
   1957 		return -1;
   1958 	}
   1959 
   1960 	/* FIXME: A fresh SAK not generated until
   1961 	 * the live peer list contains at least one peer and
   1962 	 * MKA life time has elapsed since the prior SAK was first distributed,
   1963 	 * or the Key server's potential peer is empty
   1964 	 * but I can't understand the second item, so
   1965 	 * here only check first item and ingore
   1966 	 *   && (!dl_list_empty(&participant->potential_peers))) {
   1967 	 */
   1968 	if ((time(NULL) - kay->dist_time) < MKA_LIFE_TIME / 1000) {
   1969 		wpa_printf(MSG_ERROR,
   1970 			   "KaY: Life time have not elapsed since prior SAK distributed");
   1971 		return -1;
   1972 	}
   1973 
   1974 	conf = os_zalloc(sizeof(*conf));
   1975 	if (!conf) {
   1976 		wpa_printf(MSG_ERROR, "KaY-%s: Out of memory", __func__);
   1977 		return -1;
   1978 	}
   1979 	conf->key_len = cipher_suite_tbl[kay->macsec_csindex].sak_len;
   1980 
   1981 	conf->key = os_zalloc(conf->key_len);
   1982 	if (!conf->key) {
   1983 		os_free(conf);
   1984 		wpa_printf(MSG_ERROR, "KaY-%s: Out of memory", __func__);
   1985 		return -1;
   1986 	}
   1987 
   1988 	ctx_len = conf->key_len + sizeof(kay->dist_kn);
   1989 	dl_list_for_each(peer, &participant->live_peers,
   1990 			 struct ieee802_1x_kay_peer, list)
   1991 		ctx_len += sizeof(peer->mi);
   1992 	ctx_len += sizeof(participant->mi);
   1993 
   1994 	context = os_zalloc(ctx_len);
   1995 	if (!context) {
   1996 		os_free(conf->key);
   1997 		os_free(conf);
   1998 		return -1;
   1999 	}
   2000 	ctx_offset = 0;
   2001 	os_get_random(context + ctx_offset, conf->key_len);
   2002 	ctx_offset += conf->key_len;
   2003 	dl_list_for_each(peer, &participant->live_peers,
   2004 			 struct ieee802_1x_kay_peer, list) {
   2005 		os_memcpy(context + ctx_offset, peer->mi, sizeof(peer->mi));
   2006 		ctx_offset += sizeof(peer->mi);
   2007 	}
   2008 	os_memcpy(context + ctx_offset, participant->mi,
   2009 		  sizeof(participant->mi));
   2010 	ctx_offset += sizeof(participant->mi);
   2011 	os_memcpy(context + ctx_offset, &kay->dist_kn, sizeof(kay->dist_kn));
   2012 
   2013 	if (conf->key_len == 16) {
   2014 		ieee802_1x_sak_128bits_aes_cmac(participant->cak.key,
   2015 						context, ctx_len, conf->key);
   2016 	} else if (conf->key_len == 32) {
   2017 		ieee802_1x_sak_128bits_aes_cmac(participant->cak.key,
   2018 						context, ctx_len, conf->key);
   2019 	} else {
   2020 		wpa_printf(MSG_ERROR, "KaY: SAK Length not support");
   2021 		os_free(conf->key);
   2022 		os_free(conf);
   2023 		os_free(context);
   2024 		return -1;
   2025 	}
   2026 	wpa_hexdump(MSG_DEBUG, "KaY: generated new SAK",
   2027 		    conf->key, conf->key_len);
   2028 
   2029 	os_memcpy(conf->ki.mi, participant->mi, MI_LEN);
   2030 	conf->ki.kn = participant->kay->dist_kn;
   2031 	conf->an = participant->kay->dist_an;
   2032 	conf->offset = kay->macsec_confidentiality;
   2033 	conf->rx = TRUE;
   2034 	conf->tx = TRUE;
   2035 
   2036 	sa_key = ieee802_1x_kay_init_data_key(conf);
   2037 	if (!sa_key) {
   2038 		os_free(conf->key);
   2039 		os_free(conf);
   2040 		os_free(context);
   2041 		return -1;
   2042 	}
   2043 	participant->new_key = sa_key;
   2044 
   2045 	dl_list_add(&participant->sak_list, &sa_key->list);
   2046 	ieee802_1x_cp_set_ciphersuite(participant->kay->cp,
   2047 				      cipher_suite_tbl[kay->macsec_csindex].id);
   2048 	ieee802_1x_cp_sm_step(kay->cp);
   2049 	ieee802_1x_cp_set_offset(kay->cp, conf->offset);
   2050 	ieee802_1x_cp_sm_step(kay->cp);
   2051 	ieee802_1x_cp_set_distributedki(kay->cp, &conf->ki);
   2052 	ieee802_1x_cp_set_distributedan(kay->cp, conf->an);
   2053 	ieee802_1x_cp_signal_newsak(kay->cp);
   2054 	ieee802_1x_cp_sm_step(kay->cp);
   2055 
   2056 	dl_list_for_each(peer, &participant->live_peers,
   2057 			 struct ieee802_1x_kay_peer, list)
   2058 		peer->sak_used = FALSE;
   2059 
   2060 	participant->kay->dist_kn++;
   2061 	participant->kay->dist_an++;
   2062 	if (participant->kay->dist_an > 3)
   2063 		participant->kay->dist_an = 0;
   2064 
   2065 	participant->kay->dist_time = time(NULL);
   2066 
   2067 	os_free(conf->key);
   2068 	os_free(conf);
   2069 	os_free(context);
   2070 	return 0;
   2071 }
   2072 
   2073 
   2074 /**
   2075  * ieee802_1x_kay_elect_key_server - elect the key server
   2076  * when to elect: whenever the live peers list changes
   2077  */
   2078 static int
   2079 ieee802_1x_kay_elect_key_server(struct ieee802_1x_mka_participant *participant)
   2080 {
   2081 	struct ieee802_1x_kay_peer *peer;
   2082 	struct ieee802_1x_kay_peer *key_server = NULL;
   2083 	struct ieee802_1x_kay *kay = participant->kay;
   2084 	Boolean i_is_key_server;
   2085 	int i;
   2086 
   2087 	if (participant->is_obliged_key_server) {
   2088 		participant->new_sak = TRUE;
   2089 		participant->to_dist_sak = FALSE;
   2090 		ieee802_1x_cp_set_electedself(kay->cp, TRUE);
   2091 		return 0;
   2092 	}
   2093 
   2094 	/* elect the key server among the peers */
   2095 	dl_list_for_each(peer, &participant->live_peers,
   2096 			 struct ieee802_1x_kay_peer, list) {
   2097 		if (!peer->is_key_server)
   2098 			continue;
   2099 
   2100 		if (!key_server) {
   2101 			key_server = peer;
   2102 			continue;
   2103 		}
   2104 
   2105 		if (peer->key_server_priority <
   2106 		    key_server->key_server_priority) {
   2107 			key_server = peer;
   2108 		} else if (peer->key_server_priority ==
   2109 			   key_server->key_server_priority) {
   2110 			for (i = 0; i < 6; i++) {
   2111 				if (peer->sci.addr[i] <
   2112 				    key_server->sci.addr[i])
   2113 					key_server = peer;
   2114 			}
   2115 		}
   2116 	}
   2117 
   2118 	/* elect the key server between me and the above elected peer */
   2119 	i_is_key_server = FALSE;
   2120 	if (key_server && participant->can_be_key_server) {
   2121 		if (kay->actor_priority
   2122 			   < key_server->key_server_priority) {
   2123 			i_is_key_server = TRUE;
   2124 		} else if (kay->actor_priority
   2125 					== key_server->key_server_priority) {
   2126 			for (i = 0; i < 6; i++) {
   2127 				if (kay->actor_sci.addr[i]
   2128 					< key_server->sci.addr[i]) {
   2129 					i_is_key_server = TRUE;
   2130 				}
   2131 			}
   2132 		}
   2133 	}
   2134 
   2135 	if (!key_server && !i_is_key_server) {
   2136 		participant->principal = FALSE;
   2137 		participant->is_key_server = FALSE;
   2138 		participant->is_elected = FALSE;
   2139 		return 0;
   2140 	}
   2141 
   2142 	if (i_is_key_server) {
   2143 		ieee802_1x_cp_set_electedself(kay->cp, TRUE);
   2144 		if (os_memcmp(&kay->key_server_sci, &kay->actor_sci,
   2145 			      sizeof(kay->key_server_sci))) {
   2146 			ieee802_1x_cp_signal_chgdserver(kay->cp);
   2147 			ieee802_1x_cp_sm_step(kay->cp);
   2148 		}
   2149 
   2150 		participant->is_key_server = TRUE;
   2151 		participant->principal = TRUE;
   2152 		participant->new_sak = TRUE;
   2153 		wpa_printf(MSG_DEBUG, "KaY: I is elected as key server");
   2154 		participant->to_dist_sak = FALSE;
   2155 		participant->is_elected = TRUE;
   2156 
   2157 		os_memcpy(&kay->key_server_sci, &kay->actor_sci,
   2158 			  sizeof(kay->key_server_sci));
   2159 		kay->key_server_priority = kay->actor_priority;
   2160 	}
   2161 
   2162 	if (key_server) {
   2163 		ieee802_1x_cp_set_electedself(kay->cp, FALSE);
   2164 		if (os_memcmp(&kay->key_server_sci, &key_server->sci,
   2165 			      sizeof(kay->key_server_sci))) {
   2166 			ieee802_1x_cp_signal_chgdserver(kay->cp);
   2167 			ieee802_1x_cp_sm_step(kay->cp);
   2168 		}
   2169 
   2170 		participant->is_key_server = FALSE;
   2171 		participant->principal = TRUE;
   2172 		participant->is_elected = TRUE;
   2173 
   2174 		os_memcpy(&kay->key_server_sci, &key_server->sci,
   2175 			  sizeof(kay->key_server_sci));
   2176 		kay->key_server_priority = key_server->key_server_priority;
   2177 	}
   2178 
   2179 	return 0;
   2180 }
   2181 
   2182 
   2183 /**
   2184  * ieee802_1x_kay_decide_macsec_use - the key server determinate
   2185  *		 how to use MACsec: whether use MACsec and its capability
   2186  * protectFrames will be advised if the key server and one of its live peers are
   2187  * MACsec capable and one of those request MACsec protection
   2188  */
   2189 static int
   2190 ieee802_1x_kay_decide_macsec_use(
   2191 	struct ieee802_1x_mka_participant *participant)
   2192 {
   2193 	struct ieee802_1x_kay *kay = participant->kay;
   2194 	struct ieee802_1x_kay_peer *peer;
   2195 	enum macsec_cap less_capability;
   2196 	Boolean has_peer;
   2197 
   2198 	if (!participant->is_key_server)
   2199 		return -1;
   2200 
   2201 	/* key server self is MACsec-desired and requesting MACsec */
   2202 	if (!kay->macsec_desired) {
   2203 		participant->advised_desired = FALSE;
   2204 		return -1;
   2205 	}
   2206 	if (kay->macsec_capable == MACSEC_CAP_NOT_IMPLEMENTED) {
   2207 		participant->advised_desired = FALSE;
   2208 		return -1;
   2209 	}
   2210 	less_capability = kay->macsec_capable;
   2211 
   2212 	/* at least one of peers is MACsec-desired and requesting MACsec */
   2213 	has_peer = FALSE;
   2214 	dl_list_for_each(peer, &participant->live_peers,
   2215 			 struct ieee802_1x_kay_peer, list) {
   2216 		if (!peer->macsec_desired)
   2217 			continue;
   2218 
   2219 		if (peer->macsec_capbility == MACSEC_CAP_NOT_IMPLEMENTED)
   2220 			continue;
   2221 
   2222 		less_capability = (less_capability < peer->macsec_capbility) ?
   2223 			less_capability : peer->macsec_capbility;
   2224 		has_peer = TRUE;
   2225 	}
   2226 
   2227 	if (has_peer) {
   2228 		participant->advised_desired = TRUE;
   2229 		participant->advised_capability = less_capability;
   2230 		kay->authenticated = FALSE;
   2231 		kay->secured = TRUE;
   2232 		kay->failed = FALSE;
   2233 		ieee802_1x_cp_connect_secure(kay->cp);
   2234 		ieee802_1x_cp_sm_step(kay->cp);
   2235 	} else {
   2236 		participant->advised_desired = FALSE;
   2237 		participant->advised_capability = MACSEC_CAP_NOT_IMPLEMENTED;
   2238 		participant->to_use_sak = FALSE;
   2239 		kay->authenticated = TRUE;
   2240 		kay->secured = FALSE;
   2241 		kay->failed = FALSE;
   2242 		kay->ltx_kn = 0;
   2243 		kay->ltx_an = 0;
   2244 		kay->lrx_kn = 0;
   2245 		kay->lrx_an = 0;
   2246 		kay->otx_kn = 0;
   2247 		kay->otx_an = 0;
   2248 		kay->orx_kn = 0;
   2249 		kay->orx_an = 0;
   2250 		ieee802_1x_cp_connect_authenticated(kay->cp);
   2251 		ieee802_1x_cp_sm_step(kay->cp);
   2252 	}
   2253 
   2254 	return 0;
   2255 }
   2256 
   2257 static const u8 pae_group_addr[ETH_ALEN] = {
   2258 	0x01, 0x80, 0xc2, 0x00, 0x00, 0x03
   2259 };
   2260 
   2261 
   2262 /**
   2263  * ieee802_1x_kay_encode_mkpdu -
   2264  */
   2265 static int
   2266 ieee802_1x_kay_encode_mkpdu(struct ieee802_1x_mka_participant *participant,
   2267 			    struct wpabuf *pbuf)
   2268 {
   2269 	unsigned int i;
   2270 	struct ieee8023_hdr *ether_hdr;
   2271 	struct ieee802_1x_hdr *eapol_hdr;
   2272 
   2273 	ether_hdr = wpabuf_put(pbuf, sizeof(*ether_hdr));
   2274 	os_memcpy(ether_hdr->dest, pae_group_addr, sizeof(ether_hdr->dest));
   2275 	os_memcpy(ether_hdr->src, participant->kay->actor_sci.addr,
   2276 		  sizeof(ether_hdr->dest));
   2277 	ether_hdr->ethertype = host_to_be16(ETH_P_EAPOL);
   2278 
   2279 	eapol_hdr = wpabuf_put(pbuf, sizeof(*eapol_hdr));
   2280 	eapol_hdr->version = EAPOL_VERSION;
   2281 	eapol_hdr->type = IEEE802_1X_TYPE_EAPOL_MKA;
   2282 	eapol_hdr->length = host_to_be16(pbuf->size - pbuf->used);
   2283 
   2284 	for (i = 0; i < ARRAY_SIZE(mak_body_handler); i++) {
   2285 		if (mak_body_handler[i].body_present &&
   2286 		    mak_body_handler[i].body_present(participant)) {
   2287 			if (mak_body_handler[i].body_tx(participant, pbuf))
   2288 				return -1;
   2289 		}
   2290 	}
   2291 
   2292 	return 0;
   2293 }
   2294 
   2295 /**
   2296  * ieee802_1x_participant_send_mkpdu -
   2297  */
   2298 static int
   2299 ieee802_1x_participant_send_mkpdu(
   2300 	struct ieee802_1x_mka_participant *participant)
   2301 {
   2302 	struct wpabuf *buf;
   2303 	struct ieee802_1x_kay *kay = participant->kay;
   2304 	size_t length = 0;
   2305 	unsigned int i;
   2306 
   2307 	wpa_printf(MSG_DEBUG, "KaY: to enpacket and send the MKPDU");
   2308 	length += sizeof(struct ieee802_1x_hdr) + sizeof(struct ieee8023_hdr);
   2309 	for (i = 0; i < ARRAY_SIZE(mak_body_handler); i++) {
   2310 		if (mak_body_handler[i].body_present &&
   2311 		    mak_body_handler[i].body_present(participant))
   2312 			length += mak_body_handler[i].body_length(participant);
   2313 	}
   2314 
   2315 	buf = wpabuf_alloc(length);
   2316 	if (!buf) {
   2317 		wpa_printf(MSG_ERROR, "KaY: out of memory");
   2318 		return -1;
   2319 	}
   2320 
   2321 	if (ieee802_1x_kay_encode_mkpdu(participant, buf)) {
   2322 		wpa_printf(MSG_ERROR, "KaY: encode mkpdu fail!");
   2323 		return -1;
   2324 	}
   2325 
   2326 	l2_packet_send(kay->l2_mka, NULL, 0, wpabuf_head(buf), wpabuf_len(buf));
   2327 	wpabuf_free(buf);
   2328 
   2329 	kay->active = TRUE;
   2330 	participant->active = TRUE;
   2331 
   2332 	return 0;
   2333 }
   2334 
   2335 
   2336 static void ieee802_1x_kay_deinit_transmit_sa(struct transmit_sa *psa);
   2337 /**
   2338  * ieee802_1x_participant_timer -
   2339  */
   2340 static void ieee802_1x_participant_timer(void *eloop_ctx, void *timeout_ctx)
   2341 {
   2342 	struct ieee802_1x_mka_participant *participant;
   2343 	struct ieee802_1x_kay *kay;
   2344 	struct ieee802_1x_kay_peer *peer, *pre_peer;
   2345 	time_t now = time(NULL);
   2346 	Boolean lp_changed;
   2347 	struct receive_sc *rxsc, *pre_rxsc;
   2348 	struct transmit_sa *txsa, *pre_txsa;
   2349 
   2350 	participant = (struct ieee802_1x_mka_participant *)eloop_ctx;
   2351 	kay = participant->kay;
   2352 	if (participant->cak_life) {
   2353 		if (now > participant->cak_life) {
   2354 			kay->authenticated = FALSE;
   2355 			kay->secured = FALSE;
   2356 			kay->failed = TRUE;
   2357 			ieee802_1x_kay_delete_mka(kay, &participant->ckn);
   2358 			return;
   2359 		}
   2360 	}
   2361 
   2362 	/* should delete MKA instance if there are not live peers
   2363 	 * when the MKA life elapsed since its creating */
   2364 	if (participant->mka_life) {
   2365 		if (dl_list_empty(&participant->live_peers)) {
   2366 			if (now > participant->mka_life) {
   2367 				kay->authenticated = FALSE;
   2368 				kay->secured = FALSE;
   2369 				kay->failed = TRUE;
   2370 				ieee802_1x_kay_delete_mka(kay,
   2371 							  &participant->ckn);
   2372 				return;
   2373 			}
   2374 		} else {
   2375 			participant->mka_life = 0;
   2376 		}
   2377 	}
   2378 
   2379 	lp_changed = FALSE;
   2380 	dl_list_for_each_safe(peer, pre_peer, &participant->live_peers,
   2381 			      struct ieee802_1x_kay_peer, list) {
   2382 		if (now > peer->expire) {
   2383 			wpa_printf(MSG_DEBUG, "KaY: Live peer removed");
   2384 			wpa_hexdump(MSG_DEBUG, "\tMI: ", peer->mi,
   2385 				    sizeof(peer->mi));
   2386 			wpa_printf(MSG_DEBUG, "\tMN: %d", peer->mn);
   2387 			dl_list_for_each_safe(rxsc, pre_rxsc,
   2388 					      &participant->rxsc_list,
   2389 					      struct receive_sc, list) {
   2390 				if (os_memcmp(&rxsc->sci, &peer->sci,
   2391 					      sizeof(rxsc->sci)) == 0) {
   2392 					secy_delete_receive_sc(kay, rxsc);
   2393 					ieee802_1x_kay_deinit_receive_sc(
   2394 						participant, rxsc);
   2395 				}
   2396 			}
   2397 			dl_list_del(&peer->list);
   2398 			os_free(peer);
   2399 			lp_changed = TRUE;
   2400 		}
   2401 	}
   2402 
   2403 	if (lp_changed) {
   2404 		if (dl_list_empty(&participant->live_peers)) {
   2405 			participant->advised_desired = FALSE;
   2406 			participant->advised_capability =
   2407 				MACSEC_CAP_NOT_IMPLEMENTED;
   2408 			participant->to_use_sak = FALSE;
   2409 			kay->authenticated = TRUE;
   2410 			kay->secured = FALSE;
   2411 			kay->failed = FALSE;
   2412 			kay->ltx_kn = 0;
   2413 			kay->ltx_an = 0;
   2414 			kay->lrx_kn = 0;
   2415 			kay->lrx_an = 0;
   2416 			kay->otx_kn = 0;
   2417 			kay->otx_an = 0;
   2418 			kay->orx_kn = 0;
   2419 			kay->orx_an = 0;
   2420 			dl_list_for_each_safe(txsa, pre_txsa,
   2421 					      &participant->txsc->sa_list,
   2422 					      struct transmit_sa, list) {
   2423 				secy_disable_transmit_sa(kay, txsa);
   2424 				ieee802_1x_kay_deinit_transmit_sa(txsa);
   2425 			}
   2426 
   2427 			ieee802_1x_cp_connect_authenticated(kay->cp);
   2428 			ieee802_1x_cp_sm_step(kay->cp);
   2429 		} else {
   2430 			ieee802_1x_kay_elect_key_server(participant);
   2431 			ieee802_1x_kay_decide_macsec_use(participant);
   2432 		}
   2433 	}
   2434 
   2435 	dl_list_for_each_safe(peer, pre_peer, &participant->potential_peers,
   2436 			      struct ieee802_1x_kay_peer, list) {
   2437 		if (now > peer->expire) {
   2438 			wpa_printf(MSG_DEBUG, "KaY: Potential peer removed");
   2439 			wpa_hexdump(MSG_DEBUG, "\tMI: ", peer->mi,
   2440 				    sizeof(peer->mi));
   2441 			wpa_printf(MSG_DEBUG, "\tMN: %d", peer->mn);
   2442 			dl_list_del(&peer->list);
   2443 			os_free(peer);
   2444 		}
   2445 	}
   2446 
   2447 	if (participant->new_sak) {
   2448 		if (!ieee802_1x_kay_generate_new_sak(participant))
   2449 			participant->to_dist_sak = TRUE;
   2450 
   2451 		participant->new_sak = FALSE;
   2452 	}
   2453 
   2454 	if (participant->retry_count < MAX_RETRY_CNT) {
   2455 		ieee802_1x_participant_send_mkpdu(participant);
   2456 		participant->retry_count++;
   2457 	}
   2458 
   2459 	eloop_register_timeout(MKA_HELLO_TIME / 1000, 0,
   2460 			       ieee802_1x_participant_timer,
   2461 			       participant, NULL);
   2462 }
   2463 
   2464 
   2465 /**
   2466  * ieee802_1x_kay_init_transmit_sa -
   2467  */
   2468 static struct transmit_sa *
   2469 ieee802_1x_kay_init_transmit_sa(struct transmit_sc *psc, u8 an, u32 next_PN,
   2470 				struct data_key *key)
   2471 {
   2472 	struct transmit_sa *psa;
   2473 
   2474 	key->tx_latest = TRUE;
   2475 	key->rx_latest = TRUE;
   2476 
   2477 	psa = os_zalloc(sizeof(*psa));
   2478 	if (!psa) {
   2479 		wpa_printf(MSG_ERROR, "%s: out of memory", __func__);
   2480 		return NULL;
   2481 	}
   2482 
   2483 	if (key->confidentiality_offset >= CONFIDENTIALITY_OFFSET_0 &&
   2484 	    key->confidentiality_offset <= CONFIDENTIALITY_OFFSET_50)
   2485 		psa->confidentiality = TRUE;
   2486 	else
   2487 		psa->confidentiality = FALSE;
   2488 
   2489 	psa->an = an;
   2490 	psa->pkey = key;
   2491 	psa->next_pn = next_PN;
   2492 	psa->sc = psc;
   2493 
   2494 	os_get_time(&psa->created_time);
   2495 	psa->in_use = FALSE;
   2496 
   2497 	dl_list_add(&psc->sa_list, &psa->list);
   2498 	wpa_printf(MSG_DEBUG,
   2499 		   "KaY: Create transmit SA(an: %d, next_PN: %u) of SC(channel: %d)",
   2500 		   (int) an, next_PN, psc->channel);
   2501 
   2502 	return psa;
   2503 }
   2504 
   2505 
   2506 /**
   2507  * ieee802_1x_kay_deinit_transmit_sa -
   2508  */
   2509 static void ieee802_1x_kay_deinit_transmit_sa(struct transmit_sa *psa)
   2510 {
   2511 	psa->pkey = NULL;
   2512 	wpa_printf(MSG_DEBUG,
   2513 		   "KaY: Delete transmit SA(an: %d) of SC(channel: %d)",
   2514 		   psa->an, psa->sc->channel);
   2515 	dl_list_del(&psa->list);
   2516 	os_free(psa);
   2517 }
   2518 
   2519 
   2520 /**
   2521  * init_transmit_sc -
   2522  */
   2523 static struct transmit_sc *
   2524 ieee802_1x_kay_init_transmit_sc(const struct ieee802_1x_mka_sci *sci,
   2525 				int channel)
   2526 {
   2527 	struct transmit_sc *psc;
   2528 
   2529 	psc = os_zalloc(sizeof(*psc));
   2530 	if (!psc) {
   2531 		wpa_printf(MSG_ERROR, "%s: out of memory", __func__);
   2532 		return NULL;
   2533 	}
   2534 	os_memcpy(&psc->sci, sci, sizeof(psc->sci));
   2535 	psc->channel = channel;
   2536 
   2537 	os_get_time(&psc->created_time);
   2538 	psc->transmitting = FALSE;
   2539 	psc->encoding_sa = FALSE;
   2540 	psc->enciphering_sa = FALSE;
   2541 
   2542 	dl_list_init(&psc->sa_list);
   2543 	wpa_printf(MSG_DEBUG, "KaY: Create transmit SC(channel: %d)", channel);
   2544 	wpa_hexdump(MSG_DEBUG, "SCI: ", (u8 *)sci , sizeof(*sci));
   2545 
   2546 	return psc;
   2547 }
   2548 
   2549 
   2550 /**
   2551  * ieee802_1x_kay_deinit_transmit_sc -
   2552  */
   2553 static void
   2554 ieee802_1x_kay_deinit_transmit_sc(
   2555 	struct ieee802_1x_mka_participant *participant, struct transmit_sc *psc)
   2556 {
   2557 	struct transmit_sa *psa, *tmp;
   2558 
   2559 	wpa_printf(MSG_DEBUG, "KaY: Delete transmit SC(channel: %d)",
   2560 		   psc->channel);
   2561 	dl_list_for_each_safe(psa, tmp, &psc->sa_list, struct transmit_sa,
   2562 			      list) {
   2563 		secy_disable_transmit_sa(participant->kay, psa);
   2564 		ieee802_1x_kay_deinit_transmit_sa(psa);
   2565 	}
   2566 
   2567 	os_free(psc);
   2568 }
   2569 
   2570 
   2571 /****************** Interface between CP and KAY *********************/
   2572 /**
   2573  * ieee802_1x_kay_set_latest_sa_attr -
   2574  */
   2575 int ieee802_1x_kay_set_latest_sa_attr(struct ieee802_1x_kay *kay,
   2576 				      struct ieee802_1x_mka_ki *lki, u8 lan,
   2577 				      Boolean ltx, Boolean lrx)
   2578 {
   2579 	struct ieee802_1x_mka_participant *principal;
   2580 
   2581 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2582 	if (!principal)
   2583 		return -1;
   2584 
   2585 	if (!lki)
   2586 		os_memset(&principal->lki, 0, sizeof(principal->lki));
   2587 	else
   2588 		os_memcpy(&principal->lki, lki, sizeof(principal->lki));
   2589 
   2590 	principal->lan = lan;
   2591 	principal->ltx = ltx;
   2592 	principal->lrx = lrx;
   2593 	if (!lki) {
   2594 		kay->ltx_kn = 0;
   2595 		kay->lrx_kn = 0;
   2596 	} else {
   2597 		kay->ltx_kn = lki->kn;
   2598 		kay->lrx_kn = lki->kn;
   2599 	}
   2600 	kay->ltx_an = lan;
   2601 	kay->lrx_an = lan;
   2602 
   2603 	return 0;
   2604 }
   2605 
   2606 
   2607 /**
   2608  * ieee802_1x_kay_set_old_sa_attr -
   2609  */
   2610 int ieee802_1x_kay_set_old_sa_attr(struct ieee802_1x_kay *kay,
   2611 				   struct ieee802_1x_mka_ki *oki,
   2612 				   u8 oan, Boolean otx, Boolean orx)
   2613 {
   2614 	struct ieee802_1x_mka_participant *principal;
   2615 
   2616 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2617 	if (!principal)
   2618 		return -1;
   2619 
   2620 	if (!oki)
   2621 		os_memset(&principal->oki, 0, sizeof(principal->oki));
   2622 	else
   2623 		os_memcpy(&principal->oki, oki, sizeof(principal->oki));
   2624 
   2625 	principal->oan = oan;
   2626 	principal->otx = otx;
   2627 	principal->orx = orx;
   2628 
   2629 	if (!oki) {
   2630 		kay->otx_kn = 0;
   2631 		kay->orx_kn = 0;
   2632 	} else {
   2633 		kay->otx_kn = oki->kn;
   2634 		kay->orx_kn = oki->kn;
   2635 	}
   2636 	kay->otx_an = oan;
   2637 	kay->orx_an = oan;
   2638 
   2639 	return 0;
   2640 }
   2641 
   2642 
   2643 /**
   2644  * ieee802_1x_kay_create_sas -
   2645  */
   2646 int ieee802_1x_kay_create_sas(struct ieee802_1x_kay *kay,
   2647 			      struct ieee802_1x_mka_ki *lki)
   2648 {
   2649 	struct data_key *sa_key, *latest_sak;
   2650 	struct ieee802_1x_mka_participant *principal;
   2651 	struct receive_sc *rxsc;
   2652 	struct receive_sa *rxsa;
   2653 	struct transmit_sa *txsa;
   2654 
   2655 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2656 	if (!principal)
   2657 		return -1;
   2658 
   2659 	latest_sak = NULL;
   2660 	dl_list_for_each(sa_key, &principal->sak_list, struct data_key, list) {
   2661 		if (is_ki_equal(&sa_key->key_identifier, lki)) {
   2662 			sa_key->rx_latest = TRUE;
   2663 			sa_key->tx_latest = TRUE;
   2664 			latest_sak = sa_key;
   2665 			principal->to_use_sak = TRUE;
   2666 		} else {
   2667 			sa_key->rx_latest = FALSE;
   2668 			sa_key->tx_latest = FALSE;
   2669 		}
   2670 	}
   2671 	if (!latest_sak) {
   2672 		wpa_printf(MSG_ERROR, "lki related sak not found");
   2673 		return -1;
   2674 	}
   2675 
   2676 	dl_list_for_each(rxsc, &principal->rxsc_list, struct receive_sc, list) {
   2677 		rxsa = ieee802_1x_kay_init_receive_sa(rxsc, latest_sak->an, 1,
   2678 						      latest_sak);
   2679 		if (!rxsa)
   2680 			return -1;
   2681 
   2682 		secy_create_receive_sa(kay, rxsa);
   2683 	}
   2684 
   2685 	txsa = ieee802_1x_kay_init_transmit_sa(principal->txsc, latest_sak->an,
   2686 					       1, latest_sak);
   2687 	if (!txsa)
   2688 		return -1;
   2689 
   2690 	secy_create_transmit_sa(kay, txsa);
   2691 
   2692 
   2693 
   2694 	return 0;
   2695 }
   2696 
   2697 
   2698 /**
   2699  * ieee802_1x_kay_delete_sas -
   2700  */
   2701 int ieee802_1x_kay_delete_sas(struct ieee802_1x_kay *kay,
   2702 			      struct ieee802_1x_mka_ki *ki)
   2703 {
   2704 	struct data_key *sa_key, *pre_key;
   2705 	struct transmit_sa *txsa, *pre_txsa;
   2706 	struct receive_sa *rxsa, *pre_rxsa;
   2707 	struct receive_sc *rxsc;
   2708 	struct ieee802_1x_mka_participant *principal;
   2709 
   2710 	wpa_printf(MSG_DEBUG, "KaY: Entry into %s", __func__);
   2711 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2712 	if (!principal)
   2713 		return -1;
   2714 
   2715 	/* remove the transmit sa */
   2716 	dl_list_for_each_safe(txsa, pre_txsa, &principal->txsc->sa_list,
   2717 			      struct transmit_sa, list) {
   2718 		if (is_ki_equal(&txsa->pkey->key_identifier, ki)) {
   2719 			secy_disable_transmit_sa(kay, txsa);
   2720 			ieee802_1x_kay_deinit_transmit_sa(txsa);
   2721 		}
   2722 	}
   2723 
   2724 	/* remove the receive sa */
   2725 	dl_list_for_each(rxsc, &principal->rxsc_list, struct receive_sc, list) {
   2726 		dl_list_for_each_safe(rxsa, pre_rxsa, &rxsc->sa_list,
   2727 				      struct receive_sa, list) {
   2728 			if (is_ki_equal(&rxsa->pkey->key_identifier, ki)) {
   2729 				secy_disable_receive_sa(kay, rxsa);
   2730 				ieee802_1x_kay_deinit_receive_sa(rxsa);
   2731 			}
   2732 		}
   2733 	}
   2734 
   2735 	/* remove the sak */
   2736 	dl_list_for_each_safe(sa_key, pre_key, &principal->sak_list,
   2737 			      struct data_key, list) {
   2738 		if (is_ki_equal(&sa_key->key_identifier, ki)) {
   2739 			ieee802_1x_kay_deinit_data_key(sa_key);
   2740 			break;
   2741 		}
   2742 		if (principal->new_key == sa_key)
   2743 			principal->new_key = NULL;
   2744 	}
   2745 
   2746 	return 0;
   2747 }
   2748 
   2749 
   2750 /**
   2751  * ieee802_1x_kay_enable_tx_sas -
   2752  */
   2753 int ieee802_1x_kay_enable_tx_sas(struct ieee802_1x_kay *kay,
   2754 				 struct ieee802_1x_mka_ki *lki)
   2755 {
   2756 	struct ieee802_1x_mka_participant *principal;
   2757 	struct transmit_sa *txsa;
   2758 
   2759 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2760 	if (!principal)
   2761 		return -1;
   2762 
   2763 	dl_list_for_each(txsa, &principal->txsc->sa_list, struct transmit_sa,
   2764 			 list) {
   2765 		if (is_ki_equal(&txsa->pkey->key_identifier, lki)) {
   2766 			txsa->in_use = TRUE;
   2767 			secy_enable_transmit_sa(kay, txsa);
   2768 			ieee802_1x_cp_set_usingtransmitas(
   2769 				principal->kay->cp, TRUE);
   2770 			ieee802_1x_cp_sm_step(principal->kay->cp);
   2771 		}
   2772 	}
   2773 
   2774 	return 0;
   2775 }
   2776 
   2777 
   2778 /**
   2779  * ieee802_1x_kay_enable_rx_sas -
   2780  */
   2781 int ieee802_1x_kay_enable_rx_sas(struct ieee802_1x_kay *kay,
   2782 				 struct ieee802_1x_mka_ki *lki)
   2783 {
   2784 	struct ieee802_1x_mka_participant *principal;
   2785 	struct receive_sa *rxsa;
   2786 	struct receive_sc *rxsc;
   2787 
   2788 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2789 	if (!principal)
   2790 		return -1;
   2791 
   2792 	dl_list_for_each(rxsc, &principal->rxsc_list, struct receive_sc, list) {
   2793 		dl_list_for_each(rxsa, &rxsc->sa_list, struct receive_sa, list)
   2794 		{
   2795 			if (is_ki_equal(&rxsa->pkey->key_identifier, lki)) {
   2796 				rxsa->in_use = TRUE;
   2797 				secy_enable_receive_sa(kay, rxsa);
   2798 				ieee802_1x_cp_set_usingreceivesas(
   2799 					principal->kay->cp, TRUE);
   2800 				ieee802_1x_cp_sm_step(principal->kay->cp);
   2801 			}
   2802 		}
   2803 	}
   2804 
   2805 	return 0;
   2806 }
   2807 
   2808 
   2809 /**
   2810  * ieee802_1x_kay_enable_new_info -
   2811  */
   2812 int ieee802_1x_kay_enable_new_info(struct ieee802_1x_kay *kay)
   2813 {
   2814 	struct ieee802_1x_mka_participant *principal;
   2815 
   2816 	principal = ieee802_1x_kay_get_principal_participant(kay);
   2817 	if (!principal)
   2818 		return -1;
   2819 
   2820 	if (principal->retry_count < MAX_RETRY_CNT) {
   2821 		ieee802_1x_participant_send_mkpdu(principal);
   2822 		principal->retry_count++;
   2823 	}
   2824 
   2825 	return 0;
   2826 }
   2827 
   2828 
   2829 /**
   2830  * ieee802_1x_kay_cp_conf -
   2831  */
   2832 int ieee802_1x_kay_cp_conf(struct ieee802_1x_kay *kay,
   2833 			   struct ieee802_1x_cp_conf *pconf)
   2834 {
   2835 	pconf->protect = kay->macsec_protect;
   2836 	pconf->replay_protect = kay->macsec_replay_protect;
   2837 	pconf->validate = kay->macsec_validate;
   2838 
   2839 	return 0;
   2840 }
   2841 
   2842 
   2843 /**
   2844  * ieee802_1x_kay_alloc_cp_sm -
   2845  */
   2846 static struct ieee802_1x_cp_sm *
   2847 ieee802_1x_kay_alloc_cp_sm(struct ieee802_1x_kay *kay)
   2848 {
   2849 	struct ieee802_1x_cp_conf conf;
   2850 
   2851 	os_memset(&conf, 0, sizeof(conf));
   2852 	conf.protect = kay->macsec_protect;
   2853 	conf.replay_protect = kay->macsec_replay_protect;
   2854 	conf.validate = kay->macsec_validate;
   2855 	conf.replay_window = kay->macsec_replay_window;
   2856 
   2857 	return ieee802_1x_cp_sm_init(kay, &conf);
   2858 }
   2859 
   2860 
   2861 /**
   2862  * ieee802_1x_kay_mkpdu_sanity_check -
   2863  *     sanity check specified in clause 11.11.2 of IEEE802.1X-2010
   2864  */
   2865 static int ieee802_1x_kay_mkpdu_sanity_check(struct ieee802_1x_kay *kay,
   2866 					     const u8 *buf, size_t len)
   2867 {
   2868 	struct ieee8023_hdr *eth_hdr;
   2869 	struct ieee802_1x_hdr *eapol_hdr;
   2870 	struct ieee802_1x_mka_hdr *mka_hdr;
   2871 	struct ieee802_1x_mka_basic_body *body;
   2872 	size_t mka_msg_len;
   2873 	struct ieee802_1x_mka_participant *participant;
   2874 	size_t body_len;
   2875 	u8 icv[MAX_ICV_LEN];
   2876 	u8 *msg_icv;
   2877 
   2878 	eth_hdr = (struct ieee8023_hdr *) buf;
   2879 	eapol_hdr = (struct ieee802_1x_hdr *) (eth_hdr + 1);
   2880 	mka_hdr = (struct ieee802_1x_mka_hdr *) (eapol_hdr + 1);
   2881 
   2882 	/* destination address should be not individual address */
   2883 	if (os_memcmp(eth_hdr->dest, pae_group_addr, ETH_ALEN) != 0) {
   2884 		wpa_printf(MSG_MSGDUMP,
   2885 			   "KaY: ethernet destination address is not PAE group address");
   2886 		return -1;
   2887 	}
   2888 
   2889 	/* MKPDU should not less than 32 octets */
   2890 	mka_msg_len = be_to_host16(eapol_hdr->length);
   2891 	if (mka_msg_len < 32) {
   2892 		wpa_printf(MSG_MSGDUMP, "KaY: MKPDU is less than 32 octets");
   2893 		return -1;
   2894 	}
   2895 	/* MKPDU should multiple 4 octets */
   2896 	if ((mka_msg_len % 4) != 0) {
   2897 		wpa_printf(MSG_MSGDUMP,
   2898 			   "KaY: MKPDU is not multiple of 4 octets");
   2899 		return -1;
   2900 	}
   2901 
   2902 	body = (struct ieee802_1x_mka_basic_body *) mka_hdr;
   2903 	ieee802_1x_mka_dump_basic_body(body);
   2904 	body_len = get_mka_param_body_len(body);
   2905 	/* EAPOL-MKA body should comprise basic parameter set and ICV */
   2906 	if (mka_msg_len < MKA_HDR_LEN + body_len + DEFAULT_ICV_LEN) {
   2907 		wpa_printf(MSG_ERROR,
   2908 			   "KaY: Received EAPOL-MKA Packet Body Length (%d bytes) is less than the Basic Parameter Set Header Length (%d bytes) + the Basic Parameter Set Body Length (%d bytes) + %d bytes of ICV",
   2909 			   (int) mka_msg_len, (int) MKA_HDR_LEN,
   2910 			   (int) body_len, DEFAULT_ICV_LEN);
   2911 		return -1;
   2912 	}
   2913 
   2914 	/* CKN should be owned by I */
   2915 	participant = ieee802_1x_kay_get_participant(kay, body->ckn);
   2916 	if (!participant) {
   2917 		wpa_printf(MSG_DEBUG, "CKN is not included in my CA");
   2918 		return -1;
   2919 	}
   2920 
   2921 	/* algorithm agility check */
   2922 	if (os_memcmp(body->algo_agility, mka_algo_agility,
   2923 		      sizeof(body->algo_agility)) != 0) {
   2924 		wpa_printf(MSG_ERROR,
   2925 			   "KaY: peer's algorithm agility not supported for me");
   2926 		return -1;
   2927 	}
   2928 
   2929 	/* ICV check */
   2930 	/*
   2931 	 * The ICV will comprise the final octets of the packet body, whatever
   2932 	 * its size, not the fixed length 16 octets, indicated by the EAPOL
   2933 	 * packet body length.
   2934 	 */
   2935 	if (mka_alg_tbl[kay->mka_algindex].icv_hash(
   2936 		    participant->ick.key,
   2937 		    buf, len - mka_alg_tbl[kay->mka_algindex].icv_len, icv)) {
   2938 		wpa_printf(MSG_ERROR, "KaY: omac1_aes_128 failed");
   2939 		return -1;
   2940 	}
   2941 	msg_icv = ieee802_1x_mka_decode_icv_body(participant, (u8 *) mka_hdr,
   2942 						 mka_msg_len);
   2943 
   2944 	if (msg_icv) {
   2945 		if (os_memcmp_const(msg_icv, icv,
   2946 				    mka_alg_tbl[kay->mka_algindex].icv_len) !=
   2947 		    0) {
   2948 			wpa_printf(MSG_ERROR,
   2949 				   "KaY: Computed ICV is not equal to Received ICV");
   2950 		return -1;
   2951 		}
   2952 	} else {
   2953 		wpa_printf(MSG_ERROR, "KaY: No ICV");
   2954 		return -1;
   2955 	}
   2956 
   2957 	return 0;
   2958 }
   2959 
   2960 
   2961 /**
   2962  * ieee802_1x_kay_decode_mkpdu -
   2963  */
   2964 static int ieee802_1x_kay_decode_mkpdu(struct ieee802_1x_kay *kay,
   2965 				       const u8 *buf, size_t len)
   2966 {
   2967 	struct ieee802_1x_mka_participant *participant;
   2968 	struct ieee802_1x_mka_hdr *hdr;
   2969 	size_t body_len;
   2970 	size_t left_len;
   2971 	int body_type;
   2972 	int i;
   2973 	const u8 *pos;
   2974 	Boolean my_included;
   2975 	Boolean handled[256];
   2976 
   2977 	if (ieee802_1x_kay_mkpdu_sanity_check(kay, buf, len))
   2978 		return -1;
   2979 
   2980 	/* handle basic parameter set */
   2981 	pos = buf + sizeof(struct ieee8023_hdr) + sizeof(struct ieee802_1x_hdr);
   2982 	left_len = len - sizeof(struct ieee8023_hdr) -
   2983 		sizeof(struct ieee802_1x_hdr);
   2984 	participant = ieee802_1x_mka_decode_basic_body(kay, pos, left_len);
   2985 	if (!participant)
   2986 		return -1;
   2987 
   2988 	/* to skip basic parameter set */
   2989 	hdr = (struct ieee802_1x_mka_hdr *) pos;
   2990 	body_len = get_mka_param_body_len(hdr);
   2991 	pos += body_len + MKA_HDR_LEN;
   2992 	left_len -= body_len + MKA_HDR_LEN;
   2993 
   2994 	/* check i am in the peer's peer list */
   2995 	my_included = ieee802_1x_mka_i_in_peerlist(participant, pos, left_len);
   2996 	if (my_included) {
   2997 		/* accept the peer as live peer */
   2998 		if (!ieee802_1x_kay_is_in_peer(
   2999 			    participant,
   3000 			    participant->current_peer_id.mi)) {
   3001 			if (!ieee802_1x_kay_create_live_peer(
   3002 				    participant,
   3003 				    participant->current_peer_id.mi,
   3004 				    participant->current_peer_id.mn))
   3005 				return -1;
   3006 			ieee802_1x_kay_elect_key_server(participant);
   3007 			ieee802_1x_kay_decide_macsec_use(participant);
   3008 		}
   3009 		if (ieee802_1x_kay_is_in_potential_peer(
   3010 			    participant, participant->current_peer_id.mi)) {
   3011 			ieee802_1x_kay_move_live_peer(
   3012 				participant, participant->current_peer_id.mi,
   3013 				participant->current_peer_id.mn);
   3014 			ieee802_1x_kay_elect_key_server(participant);
   3015 			ieee802_1x_kay_decide_macsec_use(participant);
   3016 		}
   3017 	}
   3018 
   3019 	/*
   3020 	 * Handle other parameter set than basic parameter set.
   3021 	 * Each parameter set should be present only once.
   3022 	 */
   3023 	for (i = 0; i < 256; i++)
   3024 		handled[i] = FALSE;
   3025 
   3026 	handled[0] = TRUE;
   3027 	while (left_len > MKA_HDR_LEN + DEFAULT_ICV_LEN) {
   3028 		hdr = (struct ieee802_1x_mka_hdr *) pos;
   3029 		body_len = get_mka_param_body_len(hdr);
   3030 		body_type = get_mka_param_body_type(hdr);
   3031 
   3032 		if (body_type == MKA_ICV_INDICATOR)
   3033 			return 0;
   3034 
   3035 		if (left_len < (MKA_HDR_LEN + body_len + DEFAULT_ICV_LEN)) {
   3036 			wpa_printf(MSG_ERROR,
   3037 				   "KaY: MKA Peer Packet Body Length (%d bytes) is less than the Parameter Set Header Length (%d bytes) + the Parameter Set Body Length (%d bytes) + %d bytes of ICV",
   3038 				   (int) left_len, (int) MKA_HDR_LEN,
   3039 				   (int) body_len, DEFAULT_ICV_LEN);
   3040 			goto next_para_set;
   3041 		}
   3042 
   3043 		if (handled[body_type])
   3044 			goto next_para_set;
   3045 
   3046 		handled[body_type] = TRUE;
   3047 		if (mak_body_handler[body_type].body_rx) {
   3048 			mak_body_handler[body_type].body_rx
   3049 				(participant, pos, left_len);
   3050 		} else {
   3051 			wpa_printf(MSG_ERROR,
   3052 				   "The type %d not supported in this MKA version %d",
   3053 				   body_type, MKA_VERSION_ID);
   3054 		}
   3055 
   3056 next_para_set:
   3057 		pos += body_len + MKA_HDR_LEN;
   3058 		left_len -= body_len + MKA_HDR_LEN;
   3059 	}
   3060 
   3061 	kay->active = TRUE;
   3062 	participant->retry_count = 0;
   3063 	participant->active = TRUE;
   3064 
   3065 	return 0;
   3066 }
   3067 
   3068 
   3069 
   3070 static void kay_l2_receive(void *ctx, const u8 *src_addr, const u8 *buf,
   3071 			   size_t len)
   3072 {
   3073 	struct ieee802_1x_kay *kay = ctx;
   3074 	struct ieee8023_hdr *eth_hdr;
   3075 	struct ieee802_1x_hdr *eapol_hdr;
   3076 
   3077 	/* must contain at least ieee8023_hdr + ieee802_1x_hdr */
   3078 	if (len < sizeof(*eth_hdr) + sizeof(*eapol_hdr)) {
   3079 		wpa_printf(MSG_MSGDUMP, "KaY: EAPOL frame too short (%lu)",
   3080 			   (unsigned long) len);
   3081 		return;
   3082 	}
   3083 
   3084 	eth_hdr = (struct ieee8023_hdr *) buf;
   3085 	eapol_hdr = (struct ieee802_1x_hdr *) (eth_hdr + 1);
   3086 	if (len != sizeof(*eth_hdr) + sizeof(*eapol_hdr) +
   3087 	    ntohs(eapol_hdr->length)) {
   3088 		wpa_printf(MSG_MSGDUMP, "KAY: EAPOL MPDU is invalid: (%lu-%lu)",
   3089 			   (unsigned long) len,
   3090 			   (unsigned long) ntohs(eapol_hdr->length));
   3091 		return;
   3092 	}
   3093 
   3094 	if (eapol_hdr->version < EAPOL_VERSION) {
   3095 		wpa_printf(MSG_MSGDUMP, "KaY: version %d does not support MKA",
   3096 			   eapol_hdr->version);
   3097 		return;
   3098 	}
   3099 	if (ntohs(eth_hdr->ethertype) != ETH_P_PAE ||
   3100 	    eapol_hdr->type != IEEE802_1X_TYPE_EAPOL_MKA)
   3101 		return;
   3102 
   3103 	wpa_hexdump(MSG_DEBUG, "RX EAPOL-MKA: ", buf, len);
   3104 	if (dl_list_empty(&kay->participant_list)) {
   3105 		wpa_printf(MSG_ERROR, "KaY: no MKA participant instance");
   3106 		return;
   3107 	}
   3108 
   3109 	ieee802_1x_kay_decode_mkpdu(kay, buf, len);
   3110 }
   3111 
   3112 
   3113 /**
   3114  * ieee802_1x_kay_init -
   3115  */
   3116 struct ieee802_1x_kay *
   3117 ieee802_1x_kay_init(struct ieee802_1x_kay_ctx *ctx, enum macsec_policy policy,
   3118 		    const char *ifname, const u8 *addr)
   3119 {
   3120 	struct ieee802_1x_kay *kay;
   3121 
   3122 	kay = os_zalloc(sizeof(*kay));
   3123 	if (!kay) {
   3124 		wpa_printf(MSG_ERROR, "KaY-%s: out of memory", __func__);
   3125 		return NULL;
   3126 	}
   3127 
   3128 	kay->ctx = ctx;
   3129 
   3130 	kay->enable = TRUE;
   3131 	kay->active = FALSE;
   3132 
   3133 	kay->authenticated = FALSE;
   3134 	kay->secured = FALSE;
   3135 	kay->failed = FALSE;
   3136 	kay->policy = policy;
   3137 
   3138 	os_strlcpy(kay->if_name, ifname, IFNAMSIZ);
   3139 	os_memcpy(kay->actor_sci.addr, addr, ETH_ALEN);
   3140 	kay->actor_sci.port = 0x0001;
   3141 	kay->actor_priority = DEFAULT_PRIO_NOT_KEY_SERVER;
   3142 
   3143 	/* While actor acts as a key server, shall distribute sakey */
   3144 	kay->dist_kn = 1;
   3145 	kay->dist_an = 0;
   3146 	kay->dist_time = 0;
   3147 
   3148 	kay->pn_exhaustion = PENDING_PN_EXHAUSTION;
   3149 	kay->macsec_csindex = DEFAULT_CS_INDEX;
   3150 	kay->mka_algindex = DEFAULT_MKA_ALG_INDEX;
   3151 	kay->mka_version = MKA_VERSION_ID;
   3152 
   3153 	os_memcpy(kay->algo_agility, mka_algo_agility,
   3154 		  sizeof(kay->algo_agility));
   3155 
   3156 	dl_list_init(&kay->participant_list);
   3157 
   3158 	if (policy == DO_NOT_SECURE) {
   3159 		kay->macsec_capable = MACSEC_CAP_NOT_IMPLEMENTED;
   3160 		kay->macsec_desired = FALSE;
   3161 		kay->macsec_protect = FALSE;
   3162 		kay->macsec_validate = FALSE;
   3163 		kay->macsec_replay_protect = FALSE;
   3164 		kay->macsec_replay_window = 0;
   3165 		kay->macsec_confidentiality = CONFIDENTIALITY_NONE;
   3166 	} else {
   3167 		kay->macsec_capable = MACSEC_CAP_INTEG_AND_CONF_0_30_50;
   3168 		kay->macsec_desired = TRUE;
   3169 		kay->macsec_protect = TRUE;
   3170 		kay->macsec_validate = TRUE;
   3171 		kay->macsec_replay_protect = FALSE;
   3172 		kay->macsec_replay_window = 0;
   3173 		kay->macsec_confidentiality = CONFIDENTIALITY_OFFSET_0;
   3174 	}
   3175 
   3176 	wpa_printf(MSG_DEBUG, "KaY: state machine created");
   3177 
   3178 	/* Initialize the SecY must be prio to CP, as CP will control SecY */
   3179 	secy_init_macsec(kay);
   3180 	secy_get_available_transmit_sc(kay, &kay->sc_ch);
   3181 
   3182 	wpa_printf(MSG_DEBUG, "KaY: secy init macsec done");
   3183 
   3184 	/* init CP */
   3185 	kay->cp = ieee802_1x_kay_alloc_cp_sm(kay);
   3186 	if (kay->cp == NULL) {
   3187 		ieee802_1x_kay_deinit(kay);
   3188 		return NULL;
   3189 	}
   3190 
   3191 	if (policy == DO_NOT_SECURE) {
   3192 		ieee802_1x_cp_connect_authenticated(kay->cp);
   3193 		ieee802_1x_cp_sm_step(kay->cp);
   3194 	} else {
   3195 		kay->l2_mka = l2_packet_init(kay->if_name, NULL, ETH_P_PAE,
   3196 					     kay_l2_receive, kay, 1);
   3197 		if (kay->l2_mka == NULL) {
   3198 			wpa_printf(MSG_WARNING,
   3199 				   "KaY: Failed to initialize L2 packet processing for MKA packet");
   3200 			ieee802_1x_kay_deinit(kay);
   3201 			return NULL;
   3202 		}
   3203 	}
   3204 
   3205 	return kay;
   3206 }
   3207 
   3208 
   3209 /**
   3210  * ieee802_1x_kay_deinit -
   3211  */
   3212 void
   3213 ieee802_1x_kay_deinit(struct ieee802_1x_kay *kay)
   3214 {
   3215 	struct ieee802_1x_mka_participant *participant;
   3216 
   3217 	if (!kay)
   3218 		return;
   3219 
   3220 	wpa_printf(MSG_DEBUG, "KaY: state machine removed");
   3221 
   3222 	while (!dl_list_empty(&kay->participant_list)) {
   3223 		participant = dl_list_entry(kay->participant_list.next,
   3224 					    struct ieee802_1x_mka_participant,
   3225 					    list);
   3226 		ieee802_1x_kay_delete_mka(kay, &participant->ckn);
   3227 	}
   3228 
   3229 	ieee802_1x_cp_sm_deinit(kay->cp);
   3230 	secy_deinit_macsec(kay);
   3231 
   3232 	if (kay->l2_mka) {
   3233 		l2_packet_deinit(kay->l2_mka);
   3234 		kay->l2_mka = NULL;
   3235 	}
   3236 
   3237 	os_free(kay->ctx);
   3238 	os_free(kay);
   3239 }
   3240 
   3241 
   3242 /**
   3243  * ieee802_1x_kay_create_mka -
   3244  */
   3245 struct ieee802_1x_mka_participant *
   3246 ieee802_1x_kay_create_mka(struct ieee802_1x_kay *kay, struct mka_key_name *ckn,
   3247 			  struct mka_key *cak, u32 life,
   3248 			  enum mka_created_mode mode, Boolean is_authenticator)
   3249 {
   3250 	struct ieee802_1x_mka_participant *participant;
   3251 	unsigned int usecs;
   3252 
   3253 	if (!kay || !ckn || !cak) {
   3254 		wpa_printf(MSG_ERROR, "KaY: ckn or cak is null");
   3255 		return NULL;
   3256 	}
   3257 
   3258 	if (cak->len != mka_alg_tbl[kay->mka_algindex].cak_len) {
   3259 		wpa_printf(MSG_ERROR, "KaY: CAK length not follow key schema");
   3260 		return NULL;
   3261 	}
   3262 	if (ckn->len > MAX_CKN_LEN) {
   3263 		wpa_printf(MSG_ERROR, "KaY: CKN is out of range(<=32 bytes)");
   3264 		return NULL;
   3265 	}
   3266 	if (!kay->enable) {
   3267 		wpa_printf(MSG_ERROR, "KaY: Now is at disable state");
   3268 		return NULL;
   3269 	}
   3270 
   3271 	participant = os_zalloc(sizeof(*participant));
   3272 	if (!participant) {
   3273 		wpa_printf(MSG_ERROR, "KaY-%s: out of memory", __func__);
   3274 		return NULL;
   3275 	}
   3276 
   3277 	participant->ckn.len = ckn->len;
   3278 	os_memcpy(participant->ckn.name, ckn->name, ckn->len);
   3279 	participant->cak.len = cak->len;
   3280 	os_memcpy(participant->cak.key, cak->key, cak->len);
   3281 	if (life)
   3282 		participant->cak_life = life + time(NULL);
   3283 
   3284 	switch (mode) {
   3285 	case EAP_EXCHANGE:
   3286 		if (is_authenticator) {
   3287 			participant->is_obliged_key_server = TRUE;
   3288 			participant->can_be_key_server = TRUE;
   3289 			participant->is_key_server = TRUE;
   3290 			participant->principal = TRUE;
   3291 
   3292 			os_memcpy(&kay->key_server_sci, &kay->actor_sci,
   3293 				  sizeof(kay->key_server_sci));
   3294 			kay->key_server_priority = kay->actor_priority;
   3295 			participant->is_elected = TRUE;
   3296 		} else {
   3297 			participant->is_obliged_key_server = FALSE;
   3298 			participant->can_be_key_server = FALSE;
   3299 			participant->is_key_server = FALSE;
   3300 			participant->is_elected = TRUE;
   3301 		}
   3302 		break;
   3303 
   3304 	default:
   3305 		participant->is_obliged_key_server = FALSE;
   3306 		participant->can_be_key_server = TRUE;
   3307 		participant->is_key_server = FALSE;
   3308 		participant->is_elected = FALSE;
   3309 		break;
   3310 	}
   3311 
   3312 	participant->cached = FALSE;
   3313 
   3314 	participant->active = FALSE;
   3315 	participant->participant = FALSE;
   3316 	participant->retain = FALSE;
   3317 	participant->activate = DEFAULT;
   3318 
   3319 	if (participant->is_key_server)
   3320 		participant->principal = TRUE;
   3321 
   3322 	dl_list_init(&participant->live_peers);
   3323 	dl_list_init(&participant->potential_peers);
   3324 
   3325 	participant->retry_count = 0;
   3326 	participant->kay = kay;
   3327 
   3328 	os_get_random(participant->mi, sizeof(participant->mi));
   3329 	participant->mn = 0;
   3330 
   3331 	participant->lrx = FALSE;
   3332 	participant->ltx = FALSE;
   3333 	participant->orx = FALSE;
   3334 	participant->otx = FALSE;
   3335 	participant->to_dist_sak = FALSE;
   3336 	participant->to_use_sak = FALSE;
   3337 	participant->new_sak = FALSE;
   3338 	dl_list_init(&participant->sak_list);
   3339 	participant->new_key = NULL;
   3340 	dl_list_init(&participant->rxsc_list);
   3341 	participant->txsc = ieee802_1x_kay_init_transmit_sc(&kay->actor_sci,
   3342 							    kay->sc_ch);
   3343 	secy_create_transmit_sc(kay, participant->txsc);
   3344 
   3345 	/* to derive KEK from CAK and CKN */
   3346 	participant->kek.len = mka_alg_tbl[kay->mka_algindex].kek_len;
   3347 	if (mka_alg_tbl[kay->mka_algindex].kek_trfm(participant->cak.key,
   3348 						    participant->ckn.name,
   3349 						    participant->ckn.len,
   3350 						    participant->kek.key)) {
   3351 		wpa_printf(MSG_ERROR, "KaY: Derived KEK failed");
   3352 		goto fail;
   3353 	}
   3354 	wpa_hexdump_key(MSG_DEBUG, "KaY: Derived KEK",
   3355 			participant->kek.key, participant->kek.len);
   3356 
   3357 	/* to derive ICK from CAK and CKN */
   3358 	participant->ick.len = mka_alg_tbl[kay->mka_algindex].ick_len;
   3359 	if (mka_alg_tbl[kay->mka_algindex].ick_trfm(participant->cak.key,
   3360 						    participant->ckn.name,
   3361 						    participant->ckn.len,
   3362 						    participant->ick.key)) {
   3363 		wpa_printf(MSG_ERROR, "KaY: Derived ICK failed");
   3364 		goto fail;
   3365 	}
   3366 	wpa_hexdump_key(MSG_DEBUG, "KaY: Derived ICK",
   3367 			participant->ick.key, participant->ick.len);
   3368 
   3369 	dl_list_add(&kay->participant_list, &participant->list);
   3370 	wpa_hexdump(MSG_DEBUG, "KaY: Participant created:",
   3371 		    ckn->name, ckn->len);
   3372 
   3373 	usecs = os_random() % (MKA_HELLO_TIME * 1000);
   3374 	eloop_register_timeout(0, usecs, ieee802_1x_participant_timer,
   3375 			       participant, NULL);
   3376 	participant->mka_life = MKA_LIFE_TIME / 1000 + time(NULL) +
   3377 		usecs / 1000000;
   3378 
   3379 	return participant;
   3380 
   3381 fail:
   3382 	os_free(participant);
   3383 	return NULL;
   3384 }
   3385 
   3386 
   3387 /**
   3388  * ieee802_1x_kay_delete_mka -
   3389  */
   3390 void
   3391 ieee802_1x_kay_delete_mka(struct ieee802_1x_kay *kay, struct mka_key_name *ckn)
   3392 {
   3393 	struct ieee802_1x_mka_participant *participant;
   3394 	struct ieee802_1x_kay_peer *peer;
   3395 	struct data_key *sak;
   3396 	struct receive_sc *rxsc;
   3397 
   3398 	if (!kay || !ckn)
   3399 		return;
   3400 
   3401 	wpa_printf(MSG_DEBUG, "KaY: participant removed");
   3402 
   3403 	/* get the participant */
   3404 	participant = ieee802_1x_kay_get_participant(kay, ckn->name);
   3405 	if (!participant) {
   3406 		wpa_hexdump(MSG_DEBUG, "KaY: participant is not found",
   3407 			    ckn->name, ckn->len);
   3408 		return;
   3409 	}
   3410 
   3411 	dl_list_del(&participant->list);
   3412 
   3413 	/* remove live peer */
   3414 	while (!dl_list_empty(&participant->live_peers)) {
   3415 		peer = dl_list_entry(participant->live_peers.next,
   3416 				     struct ieee802_1x_kay_peer, list);
   3417 		dl_list_del(&peer->list);
   3418 		os_free(peer);
   3419 	}
   3420 
   3421 	/* remove potential peer */
   3422 	while (!dl_list_empty(&participant->potential_peers)) {
   3423 		peer = dl_list_entry(participant->potential_peers.next,
   3424 				     struct ieee802_1x_kay_peer, list);
   3425 		dl_list_del(&peer->list);
   3426 		os_free(peer);
   3427 	}
   3428 
   3429 	/* remove sak */
   3430 	while (!dl_list_empty(&participant->sak_list)) {
   3431 		sak = dl_list_entry(participant->sak_list.next,
   3432 				    struct data_key, list);
   3433 		dl_list_del(&sak->list);
   3434 		os_free(sak->key);
   3435 		os_free(sak);
   3436 	}
   3437 	while (!dl_list_empty(&participant->rxsc_list)) {
   3438 		rxsc = dl_list_entry(participant->rxsc_list.next,
   3439 				     struct receive_sc, list);
   3440 		secy_delete_receive_sc(kay, rxsc);
   3441 		ieee802_1x_kay_deinit_receive_sc(participant, rxsc);
   3442 	}
   3443 	secy_delete_transmit_sc(kay, participant->txsc);
   3444 	ieee802_1x_kay_deinit_transmit_sc(participant, participant->txsc);
   3445 
   3446 	os_memset(&participant->cak, 0, sizeof(participant->cak));
   3447 	os_memset(&participant->kek, 0, sizeof(participant->kek));
   3448 	os_memset(&participant->ick, 0, sizeof(participant->ick));
   3449 	os_free(participant);
   3450 }
   3451 
   3452 
   3453 /**
   3454  * ieee802_1x_kay_mka_participate -
   3455  */
   3456 void ieee802_1x_kay_mka_participate(struct ieee802_1x_kay *kay,
   3457 				    struct mka_key_name *ckn,
   3458 				    Boolean status)
   3459 {
   3460 	struct ieee802_1x_mka_participant *participant;
   3461 
   3462 	if (!kay || !ckn)
   3463 		return;
   3464 
   3465 	participant = ieee802_1x_kay_get_participant(kay, ckn->name);
   3466 	if (!participant)
   3467 		return;
   3468 
   3469 	participant->active = status;
   3470 }
   3471 
   3472 
   3473 /**
   3474  * ieee802_1x_kay_new_sak -
   3475  */
   3476 int
   3477 ieee802_1x_kay_new_sak(struct ieee802_1x_kay *kay)
   3478 {
   3479 	struct ieee802_1x_mka_participant *participant;
   3480 
   3481 	if (!kay)
   3482 		return -1;
   3483 
   3484 	participant = ieee802_1x_kay_get_principal_participant(kay);
   3485 	if (!participant)
   3486 		return -1;
   3487 
   3488 	participant->new_sak = TRUE;
   3489 	wpa_printf(MSG_DEBUG, "KaY: new SAK signal");
   3490 
   3491 	return 0;
   3492 }
   3493 
   3494 
   3495 /**
   3496  * ieee802_1x_kay_change_cipher_suite -
   3497  */
   3498 int
   3499 ieee802_1x_kay_change_cipher_suite(struct ieee802_1x_kay *kay, int cs_index)
   3500 {
   3501 	struct ieee802_1x_mka_participant *participant;
   3502 
   3503 	if (!kay)
   3504 		return -1;
   3505 
   3506 	if ((unsigned int) cs_index >= CS_TABLE_SIZE) {
   3507 		wpa_printf(MSG_ERROR,
   3508 			   "KaY: Configured cipher suite index is out of range");
   3509 		return -1;
   3510 	}
   3511 	if (kay->macsec_csindex == cs_index)
   3512 		return -2;
   3513 
   3514 	if (cs_index == 0)
   3515 		kay->macsec_desired = FALSE;
   3516 
   3517 	kay->macsec_csindex = cs_index;
   3518 	kay->macsec_capable = cipher_suite_tbl[kay->macsec_csindex].capable;
   3519 
   3520 	participant = ieee802_1x_kay_get_principal_participant(kay);
   3521 	if (participant) {
   3522 		wpa_printf(MSG_INFO, "KaY: Cipher Suite changed");
   3523 		participant->new_sak = TRUE;
   3524 	}
   3525 
   3526 	return 0;
   3527 }
   3528