• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * EAP server/peer: EAP-GPSK shared routines
3  * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8 
9 #include "includes.h"
10 
11 #include "common.h"
12 #include "crypto/aes_wrap.h"
13 #include "crypto/sha256.h"
14 #include "eap_defs.h"
15 #include "eap_gpsk_common.h"
16 
17 
18 /**
19  * eap_gpsk_supported_ciphersuite - Check whether ciphersuite is supported
20  * @vendor: CSuite/Vendor
21  * @specifier: CSuite/Specifier
22  * Returns: 1 if ciphersuite is support, or 0 if not
23  */
eap_gpsk_supported_ciphersuite(int vendor,int specifier)24 int eap_gpsk_supported_ciphersuite(int vendor, int specifier)
25 {
26 	if (vendor == EAP_GPSK_VENDOR_IETF &&
27 	    specifier == EAP_GPSK_CIPHER_AES)
28 		return 1;
29 #ifdef EAP_GPSK_SHA256
30 	if (vendor == EAP_GPSK_VENDOR_IETF &&
31 	    specifier == EAP_GPSK_CIPHER_SHA256)
32 		return 1;
33 #endif /* EAP_GPSK_SHA256 */
34 	return 0;
35 }
36 
37 
eap_gpsk_gkdf_cmac(const u8 * psk,const u8 * data,size_t data_len,u8 * buf,size_t len)38 static int eap_gpsk_gkdf_cmac(const u8 *psk /* Y */,
39 			      const u8 *data /* Z */, size_t data_len,
40 			      u8 *buf, size_t len /* X */)
41 {
42 	u8 *opos;
43 	size_t i, n, hashlen, left, clen;
44 	u8 ibuf[2], hash[16];
45 	const u8 *addr[2];
46 	size_t vlen[2];
47 
48 	hashlen = sizeof(hash);
49 	/* M_i = MAC_Y (i || Z); (MAC = AES-CMAC-128) */
50 	addr[0] = ibuf;
51 	vlen[0] = sizeof(ibuf);
52 	addr[1] = data;
53 	vlen[1] = data_len;
54 
55 	opos = buf;
56 	left = len;
57 	n = (len + hashlen - 1) / hashlen;
58 	for (i = 1; i <= n; i++) {
59 		WPA_PUT_BE16(ibuf, i);
60 		if (omac1_aes_128_vector(psk, 2, addr, vlen, hash))
61 			return -1;
62 		clen = left > hashlen ? hashlen : left;
63 		os_memcpy(opos, hash, clen);
64 		opos += clen;
65 		left -= clen;
66 	}
67 
68 	return 0;
69 }
70 
71 
72 #ifdef EAP_GPSK_SHA256
eap_gpsk_gkdf_sha256(const u8 * psk,const u8 * data,size_t data_len,u8 * buf,size_t len)73 static int eap_gpsk_gkdf_sha256(const u8 *psk /* Y */,
74 				const u8 *data /* Z */, size_t data_len,
75 				u8 *buf, size_t len /* X */)
76 {
77 	u8 *opos;
78 	size_t i, n, hashlen, left, clen;
79 	u8 ibuf[2], hash[SHA256_MAC_LEN];
80 	const u8 *addr[2];
81 	size_t vlen[2];
82 
83 	hashlen = SHA256_MAC_LEN;
84 	/* M_i = MAC_Y (i || Z); (MAC = HMAC-SHA256) */
85 	addr[0] = ibuf;
86 	vlen[0] = sizeof(ibuf);
87 	addr[1] = data;
88 	vlen[1] = data_len;
89 
90 	opos = buf;
91 	left = len;
92 	n = (len + hashlen - 1) / hashlen;
93 	for (i = 1; i <= n; i++) {
94 		WPA_PUT_BE16(ibuf, i);
95 		if (hmac_sha256_vector(psk, 32, 2, addr, vlen, hash))
96 			return -1;
97 		clen = left > hashlen ? hashlen : left;
98 		os_memcpy(opos, hash, clen);
99 		opos += clen;
100 		left -= clen;
101 	}
102 
103 	return 0;
104 }
105 #endif /* EAP_GPSK_SHA256 */
106 
107 
eap_gpsk_derive_keys_helper(u32 csuite_specifier,u8 * kdf_out,size_t kdf_out_len,const u8 * psk,size_t psk_len,const u8 * seed,size_t seed_len,u8 * msk,u8 * emsk,u8 * sk,size_t sk_len,u8 * pk,size_t pk_len)108 static int eap_gpsk_derive_keys_helper(u32 csuite_specifier,
109 				       u8 *kdf_out, size_t kdf_out_len,
110 				       const u8 *psk, size_t psk_len,
111 				       const u8 *seed, size_t seed_len,
112 				       u8 *msk, u8 *emsk,
113 				       u8 *sk, size_t sk_len,
114 				       u8 *pk, size_t pk_len)
115 {
116 	u8 mk[32], *pos, *data;
117 	size_t data_len, mk_len;
118 	int (*gkdf)(const u8 *_psk, const u8 *_data, size_t _data_len,
119 		    u8 *buf, size_t len);
120 
121 	gkdf = NULL;
122 	switch (csuite_specifier) {
123 	case EAP_GPSK_CIPHER_AES:
124 		gkdf = eap_gpsk_gkdf_cmac;
125 		mk_len = 16;
126 		break;
127 #ifdef EAP_GPSK_SHA256
128 	case EAP_GPSK_CIPHER_SHA256:
129 		gkdf = eap_gpsk_gkdf_sha256;
130 		mk_len = SHA256_MAC_LEN;
131 		break;
132 #endif /* EAP_GPSK_SHA256 */
133 	default:
134 		return -1;
135 	}
136 
137 	if (psk_len < mk_len)
138 		return -1;
139 
140 	data_len = 2 + psk_len + 6 + seed_len;
141 	data = os_malloc(data_len);
142 	if (data == NULL)
143 		return -1;
144 	pos = data;
145 	WPA_PUT_BE16(pos, psk_len);
146 	pos += 2;
147 	os_memcpy(pos, psk, psk_len);
148 	pos += psk_len;
149 	WPA_PUT_BE32(pos, EAP_GPSK_VENDOR_IETF); /* CSuite/Vendor = IETF */
150 	pos += 4;
151 	WPA_PUT_BE16(pos, csuite_specifier); /* CSuite/Specifier */
152 	pos += 2;
153 	os_memcpy(pos, seed, seed_len); /* inputString */
154 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: Data to MK derivation",
155 			data, data_len);
156 
157 	if (gkdf(psk, data, data_len, mk, mk_len) < 0) {
158 		os_free(data);
159 		return -1;
160 	}
161 	os_free(data);
162 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: MK", mk, mk_len);
163 
164 	if (gkdf(mk, seed, seed_len, kdf_out, kdf_out_len) < 0)
165 		return -1;
166 
167 	pos = kdf_out;
168 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: MSK", pos, EAP_MSK_LEN);
169 	os_memcpy(msk, pos, EAP_MSK_LEN);
170 	pos += EAP_MSK_LEN;
171 
172 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: EMSK", pos, EAP_EMSK_LEN);
173 	os_memcpy(emsk, pos, EAP_EMSK_LEN);
174 	pos += EAP_EMSK_LEN;
175 
176 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: SK", pos, sk_len);
177 	os_memcpy(sk, pos, sk_len);
178 	pos += sk_len;
179 
180 	if (pk) {
181 		wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: PK", pos, pk_len);
182 		os_memcpy(pk, pos, pk_len);
183 	}
184 
185 	return 0;
186 }
187 
188 
eap_gpsk_derive_keys_aes(const u8 * psk,size_t psk_len,const u8 * seed,size_t seed_len,u8 * msk,u8 * emsk,u8 * sk,size_t * sk_len,u8 * pk,size_t * pk_len)189 static int eap_gpsk_derive_keys_aes(const u8 *psk, size_t psk_len,
190 				    const u8 *seed, size_t seed_len,
191 				    u8 *msk, u8 *emsk, u8 *sk, size_t *sk_len,
192 				    u8 *pk, size_t *pk_len)
193 {
194 #define EAP_GPSK_SK_LEN_AES 16
195 #define EAP_GPSK_PK_LEN_AES 16
196 	u8 kdf_out[EAP_MSK_LEN + EAP_EMSK_LEN + EAP_GPSK_SK_LEN_AES +
197 		   EAP_GPSK_PK_LEN_AES];
198 
199 	/*
200 	 * inputString = RAND_Peer || ID_Peer || RAND_Server || ID_Server
201 	 *            (= seed)
202 	 * KS = 16, PL = psk_len, CSuite_Sel = 0x00000000 0x0001
203 	 * MK = GKDF-16 (PSK[0..15], PL || PSK || CSuite_Sel || inputString)
204 	 * MSK = GKDF-160 (MK, inputString)[0..63]
205 	 * EMSK = GKDF-160 (MK, inputString)[64..127]
206 	 * SK = GKDF-160 (MK, inputString)[128..143]
207 	 * PK = GKDF-160 (MK, inputString)[144..159]
208 	 * zero = 0x00 || 0x00 || ... || 0x00 (16 times)
209 	 * Method-ID = GKDF-16 (zero, "Method ID" || EAP_Method_Type ||
210 	 *                      CSuite_Sel || inputString)
211 	 */
212 
213 	*sk_len = EAP_GPSK_SK_LEN_AES;
214 	*pk_len = EAP_GPSK_PK_LEN_AES;
215 
216 	return eap_gpsk_derive_keys_helper(EAP_GPSK_CIPHER_AES,
217 					   kdf_out, sizeof(kdf_out),
218 					   psk, psk_len, seed, seed_len,
219 					   msk, emsk, sk, *sk_len,
220 					   pk, *pk_len);
221 }
222 
223 
224 #ifdef EAP_GPSK_SHA256
eap_gpsk_derive_keys_sha256(const u8 * psk,size_t psk_len,const u8 * seed,size_t seed_len,u8 * msk,u8 * emsk,u8 * sk,size_t * sk_len)225 static int eap_gpsk_derive_keys_sha256(const u8 *psk, size_t psk_len,
226 				       const u8 *seed, size_t seed_len,
227 				       u8 *msk, u8 *emsk,
228 				       u8 *sk, size_t *sk_len)
229 {
230 #define EAP_GPSK_SK_LEN_SHA256 SHA256_MAC_LEN
231 #define EAP_GPSK_PK_LEN_SHA256 SHA256_MAC_LEN
232 	u8 kdf_out[EAP_MSK_LEN + EAP_EMSK_LEN + EAP_GPSK_SK_LEN_SHA256 +
233 		   EAP_GPSK_PK_LEN_SHA256];
234 
235 	/*
236 	 * inputString = RAND_Peer || ID_Peer || RAND_Server || ID_Server
237 	 *            (= seed)
238 	 * KS = 32, PL = psk_len, CSuite_Sel = 0x00000000 0x0002
239 	 * MK = GKDF-32 (PSK[0..31], PL || PSK || CSuite_Sel || inputString)
240 	 * MSK = GKDF-160 (MK, inputString)[0..63]
241 	 * EMSK = GKDF-160 (MK, inputString)[64..127]
242 	 * SK = GKDF-160 (MK, inputString)[128..159]
243 	 * zero = 0x00 || 0x00 || ... || 0x00 (32 times)
244 	 * Method-ID = GKDF-16 (zero, "Method ID" || EAP_Method_Type ||
245 	 *                      CSuite_Sel || inputString)
246 	 */
247 
248 	*sk_len = EAP_GPSK_SK_LEN_SHA256;
249 
250 	return eap_gpsk_derive_keys_helper(EAP_GPSK_CIPHER_SHA256,
251 					   kdf_out, sizeof(kdf_out),
252 					   psk, psk_len, seed, seed_len,
253 					   msk, emsk, sk, *sk_len,
254 					   NULL, 0);
255 }
256 #endif /* EAP_GPSK_SHA256 */
257 
258 
259 /**
260  * eap_gpsk_derive_keys - Derive EAP-GPSK keys
261  * @psk: Pre-shared key
262  * @psk_len: Length of psk in bytes
263  * @vendor: CSuite/Vendor
264  * @specifier: CSuite/Specifier
265  * @rand_peer: 32-byte RAND_Peer
266  * @rand_server: 32-byte RAND_Server
267  * @id_peer: ID_Peer
268  * @id_peer_len: Length of ID_Peer
269  * @id_server: ID_Server
270  * @id_server_len: Length of ID_Server
271  * @msk: Buffer for 64-byte MSK
272  * @emsk: Buffer for 64-byte EMSK
273  * @sk: Buffer for SK (at least EAP_GPSK_MAX_SK_LEN bytes)
274  * @sk_len: Buffer for returning length of SK
275  * @pk: Buffer for PK (at least EAP_GPSK_MAX_PK_LEN bytes)
276  * @pk_len: Buffer for returning length of PK
277  * Returns: 0 on success, -1 on failure
278  */
eap_gpsk_derive_keys(const u8 * psk,size_t psk_len,int vendor,int specifier,const u8 * rand_peer,const u8 * rand_server,const u8 * id_peer,size_t id_peer_len,const u8 * id_server,size_t id_server_len,u8 * msk,u8 * emsk,u8 * sk,size_t * sk_len,u8 * pk,size_t * pk_len)279 int eap_gpsk_derive_keys(const u8 *psk, size_t psk_len, int vendor,
280 			 int specifier,
281 			 const u8 *rand_peer, const u8 *rand_server,
282 			 const u8 *id_peer, size_t id_peer_len,
283 			 const u8 *id_server, size_t id_server_len,
284 			 u8 *msk, u8 *emsk, u8 *sk, size_t *sk_len,
285 			 u8 *pk, size_t *pk_len)
286 {
287 	u8 *seed, *pos;
288 	int ret;
289 
290 	wpa_printf(MSG_DEBUG, "EAP-GPSK: Deriving keys (%d:%d)",
291 		   vendor, specifier);
292 
293 	if (vendor != EAP_GPSK_VENDOR_IETF)
294 		return -1;
295 
296 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: PSK", psk, psk_len);
297 
298 	/* Seed = RAND_Peer || ID_Peer || RAND_Server || ID_Server */
299 	seed = os_malloc(2 * EAP_GPSK_RAND_LEN + id_server_len + id_peer_len);
300 	if (seed == NULL) {
301 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to allocate memory "
302 			   "for key derivation");
303 		return -1;
304 	}
305 
306 	pos = seed;
307 	os_memcpy(pos, rand_peer, EAP_GPSK_RAND_LEN);
308 	pos += EAP_GPSK_RAND_LEN;
309 	os_memcpy(pos, id_peer, id_peer_len);
310 	pos += id_peer_len;
311 	os_memcpy(pos, rand_server, EAP_GPSK_RAND_LEN);
312 	pos += EAP_GPSK_RAND_LEN;
313 	os_memcpy(pos, id_server, id_server_len);
314 	pos += id_server_len;
315 	wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Seed", seed, pos - seed);
316 
317 	switch (specifier) {
318 	case EAP_GPSK_CIPHER_AES:
319 		ret = eap_gpsk_derive_keys_aes(psk, psk_len, seed, pos - seed,
320 					       msk, emsk, sk, sk_len,
321 					       pk, pk_len);
322 		break;
323 #ifdef EAP_GPSK_SHA256
324 	case EAP_GPSK_CIPHER_SHA256:
325 		ret = eap_gpsk_derive_keys_sha256(psk, psk_len, seed,
326 						  pos - seed,
327 						  msk, emsk, sk, sk_len);
328 		break;
329 #endif /* EAP_GPSK_SHA256 */
330 	default:
331 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown cipher %d:%d used in "
332 			   "key derivation", vendor, specifier);
333 		ret = -1;
334 		break;
335 	}
336 
337 	os_free(seed);
338 
339 	return ret;
340 }
341 
342 
eap_gpsk_derive_mid_helper(u32 csuite_specifier,u8 * kdf_out,size_t kdf_out_len,const u8 * psk,const u8 * seed,size_t seed_len,u8 method_type)343 static int eap_gpsk_derive_mid_helper(u32 csuite_specifier,
344 				      u8 *kdf_out, size_t kdf_out_len,
345 				      const u8 *psk, const u8 *seed,
346 				      size_t seed_len, u8 method_type)
347 {
348 	u8 *pos, *data;
349 	size_t data_len;
350 	int (*gkdf)(const u8 *_psk, const u8 *_data, size_t _data_len,
351 		    u8 *buf, size_t len);
352 
353 	gkdf = NULL;
354 	switch (csuite_specifier) {
355 	case EAP_GPSK_CIPHER_AES:
356 		gkdf = eap_gpsk_gkdf_cmac;
357 		break;
358 #ifdef EAP_GPSK_SHA256
359 	case EAP_GPSK_CIPHER_SHA256:
360 		gkdf = eap_gpsk_gkdf_sha256;
361 		break;
362 #endif /* EAP_GPSK_SHA256 */
363 	default:
364 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown cipher %d used in "
365 			   "Session-Id derivation", csuite_specifier);
366 		return -1;
367 	}
368 
369 #define SID_LABEL "Method ID"
370 	/* "Method ID" || EAP_Method_Type || CSuite_Sel || inputString */
371 	data_len = strlen(SID_LABEL) + 1 + 6 + seed_len;
372 	data = os_malloc(data_len);
373 	if (data == NULL)
374 		return -1;
375 	pos = data;
376 	os_memcpy(pos, SID_LABEL, strlen(SID_LABEL));
377 	pos += strlen(SID_LABEL);
378 #undef SID_LABEL
379 	os_memcpy(pos, &method_type, 1);
380 	pos += 1;
381 	WPA_PUT_BE32(pos, EAP_GPSK_VENDOR_IETF); /* CSuite/Vendor = IETF */
382 	pos += 4;
383 	WPA_PUT_BE16(pos, csuite_specifier); /* CSuite/Specifier */
384 	pos += 2;
385 	os_memcpy(pos, seed, seed_len); /* inputString */
386 	wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Data to Method ID derivation",
387 		    data, data_len);
388 
389 	if (gkdf(psk, data, data_len, kdf_out, kdf_out_len) < 0) {
390 		os_free(data);
391 		return -1;
392 	}
393 	os_free(data);
394 	wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Method ID", kdf_out, kdf_out_len);
395 
396 	return 0;
397 }
398 
399 
400 /**
401  * eap_gpsk_session_id - Derive EAP-GPSK Session ID
402  * @psk: Pre-shared key
403  * @psk_len: Length of psk in bytes
404  * @vendor: CSuite/Vendor
405  * @specifier: CSuite/Specifier
406  * @rand_peer: 32-byte RAND_Peer
407  * @rand_server: 32-byte RAND_Server
408  * @id_peer: ID_Peer
409  * @id_peer_len: Length of ID_Peer
410  * @id_server: ID_Server
411  * @id_server_len: Length of ID_Server
412  * @method_type: EAP Authentication Method Type
413  * @sid: Buffer for 17-byte Session ID
414  * @sid_len: Buffer for returning length of Session ID
415  * Returns: 0 on success, -1 on failure
416  */
eap_gpsk_derive_session_id(const u8 * psk,size_t psk_len,int vendor,int specifier,const u8 * rand_peer,const u8 * rand_server,const u8 * id_peer,size_t id_peer_len,const u8 * id_server,size_t id_server_len,u8 method_type,u8 * sid,size_t * sid_len)417 int eap_gpsk_derive_session_id(const u8 *psk, size_t psk_len, int vendor,
418 			       int specifier,
419 			       const u8 *rand_peer, const u8 *rand_server,
420 			       const u8 *id_peer, size_t id_peer_len,
421 			       const u8 *id_server, size_t id_server_len,
422 			       u8 method_type, u8 *sid, size_t *sid_len)
423 {
424 	u8 *seed, *pos;
425 	u8 kdf_out[16];
426 	int ret;
427 
428 	wpa_printf(MSG_DEBUG, "EAP-GPSK: Deriving Session ID(%d:%d)",
429 		   vendor, specifier);
430 
431 	if (vendor != EAP_GPSK_VENDOR_IETF)
432 		return -1;
433 
434 	wpa_hexdump_key(MSG_DEBUG, "EAP-GPSK: PSK", psk, psk_len);
435 
436 	/*
437 	 * inputString = RAND_Peer || ID_Peer || RAND_Server || ID_Server
438 	 *            (= seed)
439 	 * KS = 16, CSuite_Sel = 0x00000000 0x0001
440 	 * Method-ID = GKDF-16 (zero, "Method ID" || EAP_Method_Type ||
441 	 *                      CSuite_Sel || inputString)
442 	 */
443 	seed = os_malloc(2 * EAP_GPSK_RAND_LEN + id_server_len + id_peer_len);
444 	if (seed == NULL) {
445 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Failed to allocate memory "
446 			   "for Session-Id derivation");
447 		return -1;
448 	}
449 
450 	pos = seed;
451 	os_memcpy(pos, rand_peer, EAP_GPSK_RAND_LEN);
452 	pos += EAP_GPSK_RAND_LEN;
453 	os_memcpy(pos, id_peer, id_peer_len);
454 	pos += id_peer_len;
455 	os_memcpy(pos, rand_server, EAP_GPSK_RAND_LEN);
456 	pos += EAP_GPSK_RAND_LEN;
457 	os_memcpy(pos, id_server, id_server_len);
458 	pos += id_server_len;
459 	wpa_hexdump(MSG_DEBUG, "EAP-GPSK: Seed", seed, pos - seed);
460 
461 	ret = eap_gpsk_derive_mid_helper(specifier,
462 					 kdf_out, sizeof(kdf_out),
463 					 psk, seed, pos - seed,
464 					 method_type);
465 
466 	sid[0] = method_type;
467 	os_memcpy(sid + 1, kdf_out, sizeof(kdf_out));
468 	*sid_len = 1 + sizeof(kdf_out);
469 
470 	os_free(seed);
471 
472 	return ret;
473 }
474 
475 
476 /**
477  * eap_gpsk_mic_len - Get the length of the MIC
478  * @vendor: CSuite/Vendor
479  * @specifier: CSuite/Specifier
480  * Returns: MIC length in bytes
481  */
eap_gpsk_mic_len(int vendor,int specifier)482 size_t eap_gpsk_mic_len(int vendor, int specifier)
483 {
484 	if (vendor != EAP_GPSK_VENDOR_IETF)
485 		return 0;
486 
487 	switch (specifier) {
488 	case EAP_GPSK_CIPHER_AES:
489 		return 16;
490 #ifdef EAP_GPSK_SHA256
491 	case EAP_GPSK_CIPHER_SHA256:
492 		return 32;
493 #endif /* EAP_GPSK_SHA256 */
494 	default:
495 		return 0;
496 	}
497 }
498 
499 
eap_gpsk_compute_mic_aes(const u8 * sk,size_t sk_len,const u8 * data,size_t len,u8 * mic)500 static int eap_gpsk_compute_mic_aes(const u8 *sk, size_t sk_len,
501 				    const u8 *data, size_t len, u8 *mic)
502 {
503 	if (sk_len != 16) {
504 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Invalid SK length %lu for "
505 			   "AES-CMAC MIC", (unsigned long) sk_len);
506 		return -1;
507 	}
508 
509 	return omac1_aes_128(sk, data, len, mic);
510 }
511 
512 
513 /**
514  * eap_gpsk_compute_mic - Compute EAP-GPSK MIC for an EAP packet
515  * @sk: Session key SK from eap_gpsk_derive_keys()
516  * @sk_len: SK length in bytes from eap_gpsk_derive_keys()
517  * @vendor: CSuite/Vendor
518  * @specifier: CSuite/Specifier
519  * @data: Input data to MIC
520  * @len: Input data length in bytes
521  * @mic: Buffer for the computed MIC, eap_gpsk_mic_len(cipher) bytes
522  * Returns: 0 on success, -1 on failure
523  */
eap_gpsk_compute_mic(const u8 * sk,size_t sk_len,int vendor,int specifier,const u8 * data,size_t len,u8 * mic)524 int eap_gpsk_compute_mic(const u8 *sk, size_t sk_len, int vendor,
525 			 int specifier, const u8 *data, size_t len, u8 *mic)
526 {
527 	int ret;
528 
529 	if (vendor != EAP_GPSK_VENDOR_IETF)
530 		return -1;
531 
532 	switch (specifier) {
533 	case EAP_GPSK_CIPHER_AES:
534 		ret = eap_gpsk_compute_mic_aes(sk, sk_len, data, len, mic);
535 		break;
536 #ifdef EAP_GPSK_SHA256
537 	case EAP_GPSK_CIPHER_SHA256:
538 		ret = hmac_sha256(sk, sk_len, data, len, mic);
539 		break;
540 #endif /* EAP_GPSK_SHA256 */
541 	default:
542 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Unknown cipher %d:%d used in "
543 			   "MIC computation", vendor, specifier);
544 		ret = -1;
545 		break;
546 	}
547 
548 	if (ret)
549 		wpa_printf(MSG_DEBUG, "EAP-GPSK: Could not compute MIC");
550 
551 	return ret;
552 }
553