Branch data Line data Source code
1 : : /*
2 : : * IKEv2 initiator (RFC 4306) for EAP-IKEV2
3 : : * Copyright (c) 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/dh_groups.h"
13 : : #include "crypto/random.h"
14 : : #include "ikev2.h"
15 : :
16 : :
17 : : static int ikev2_process_idr(struct ikev2_initiator_data *data,
18 : : const u8 *idr, size_t idr_len);
19 : :
20 : :
21 : 2 : void ikev2_initiator_deinit(struct ikev2_initiator_data *data)
22 : : {
23 : 2 : ikev2_free_keys(&data->keys);
24 : 2 : wpabuf_free(data->r_dh_public);
25 : 2 : wpabuf_free(data->i_dh_private);
26 : 2 : os_free(data->IDi);
27 : 2 : os_free(data->IDr);
28 : 2 : os_free(data->shared_secret);
29 : 2 : wpabuf_free(data->i_sign_msg);
30 : 2 : wpabuf_free(data->r_sign_msg);
31 : 2 : os_free(data->key_pad);
32 : 2 : }
33 : :
34 : :
35 : 2 : static int ikev2_derive_keys(struct ikev2_initiator_data *data)
36 : : {
37 : : u8 *buf, *pos, *pad, skeyseed[IKEV2_MAX_HASH_LEN];
38 : : size_t buf_len, pad_len;
39 : : struct wpabuf *shared;
40 : : const struct ikev2_integ_alg *integ;
41 : : const struct ikev2_prf_alg *prf;
42 : : const struct ikev2_encr_alg *encr;
43 : : int ret;
44 : : const u8 *addr[2];
45 : : size_t len[2];
46 : :
47 : : /* RFC 4306, Sect. 2.14 */
48 : :
49 : 2 : integ = ikev2_get_integ(data->proposal.integ);
50 : 2 : prf = ikev2_get_prf(data->proposal.prf);
51 : 2 : encr = ikev2_get_encr(data->proposal.encr);
52 [ + - ][ - + ]: 2 : if (integ == NULL || prf == NULL || encr == NULL) {
[ + - ]
53 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unsupported proposal");
54 : 0 : return -1;
55 : : }
56 : :
57 : 2 : shared = dh_derive_shared(data->r_dh_public, data->i_dh_private,
58 : : data->dh);
59 [ - + ]: 2 : if (shared == NULL)
60 : 0 : return -1;
61 : :
62 : : /* Construct Ni | Nr | SPIi | SPIr */
63 : :
64 : 2 : buf_len = data->i_nonce_len + data->r_nonce_len + 2 * IKEV2_SPI_LEN;
65 : 2 : buf = os_malloc(buf_len);
66 [ - + ]: 2 : if (buf == NULL) {
67 : 0 : wpabuf_free(shared);
68 : 0 : return -1;
69 : : }
70 : :
71 : 2 : pos = buf;
72 : 2 : os_memcpy(pos, data->i_nonce, data->i_nonce_len);
73 : 2 : pos += data->i_nonce_len;
74 : 2 : os_memcpy(pos, data->r_nonce, data->r_nonce_len);
75 : 2 : pos += data->r_nonce_len;
76 : 2 : os_memcpy(pos, data->i_spi, IKEV2_SPI_LEN);
77 : 2 : pos += IKEV2_SPI_LEN;
78 : 2 : os_memcpy(pos, data->r_spi, IKEV2_SPI_LEN);
79 : :
80 : : /* SKEYSEED = prf(Ni | Nr, g^ir) */
81 : :
82 : : /* Use zero-padding per RFC 4306, Sect. 2.14 */
83 : 2 : pad_len = data->dh->prime_len - wpabuf_len(shared);
84 [ - + ]: 2 : pad = os_zalloc(pad_len ? pad_len : 1);
85 [ - + ]: 2 : if (pad == NULL) {
86 : 0 : wpabuf_free(shared);
87 : 0 : os_free(buf);
88 : 0 : return -1;
89 : : }
90 : 2 : addr[0] = pad;
91 : 2 : len[0] = pad_len;
92 : 2 : addr[1] = wpabuf_head(shared);
93 : 2 : len[1] = wpabuf_len(shared);
94 [ - + ]: 2 : if (ikev2_prf_hash(prf->id, buf, data->i_nonce_len + data->r_nonce_len,
95 : : 2, addr, len, skeyseed) < 0) {
96 : 0 : wpabuf_free(shared);
97 : 0 : os_free(buf);
98 : 0 : os_free(pad);
99 : 0 : return -1;
100 : : }
101 : 2 : os_free(pad);
102 : 2 : wpabuf_free(shared);
103 : :
104 : : /* DH parameters are not needed anymore, so free them */
105 : 2 : wpabuf_free(data->r_dh_public);
106 : 2 : data->r_dh_public = NULL;
107 : 2 : wpabuf_free(data->i_dh_private);
108 : 2 : data->i_dh_private = NULL;
109 : :
110 : 2 : wpa_hexdump_key(MSG_DEBUG, "IKEV2: SKEYSEED",
111 : : skeyseed, prf->hash_len);
112 : :
113 : 2 : ret = ikev2_derive_sk_keys(prf, integ, encr, skeyseed, buf, buf_len,
114 : : &data->keys);
115 : 2 : os_free(buf);
116 : 2 : return ret;
117 : : }
118 : :
119 : :
120 : 8 : static int ikev2_parse_transform(struct ikev2_initiator_data *data,
121 : : struct ikev2_proposal_data *prop,
122 : : const u8 *pos, const u8 *end)
123 : : {
124 : : int transform_len;
125 : : const struct ikev2_transform *t;
126 : : u16 transform_id;
127 : : const u8 *tend;
128 : :
129 [ - + ]: 8 : if (end - pos < (int) sizeof(*t)) {
130 : 0 : wpa_printf(MSG_INFO, "IKEV2: Too short transform");
131 : 0 : return -1;
132 : : }
133 : :
134 : 8 : t = (const struct ikev2_transform *) pos;
135 : 8 : transform_len = WPA_GET_BE16(t->transform_length);
136 [ - + ][ + - ]: 8 : if (transform_len < (int) sizeof(*t) || pos + transform_len > end) {
137 : 0 : wpa_printf(MSG_INFO, "IKEV2: Invalid transform length %d",
138 : : transform_len);
139 : 0 : return -1;
140 : : }
141 : 8 : tend = pos + transform_len;
142 : :
143 : 8 : transform_id = WPA_GET_BE16(t->transform_id);
144 : :
145 : 8 : wpa_printf(MSG_DEBUG, "IKEV2: Transform:");
146 : 8 : wpa_printf(MSG_DEBUG, "IKEV2: Type: %d Transform Length: %d "
147 : : "Transform Type: %d Transform ID: %d",
148 : 16 : t->type, transform_len, t->transform_type, transform_id);
149 : :
150 [ - + ][ + + ]: 8 : if (t->type != 0 && t->type != 3) {
151 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Transform type");
152 : 0 : return -1;
153 : : }
154 : :
155 : 8 : pos = (const u8 *) (t + 1);
156 [ + + ]: 8 : if (pos < tend) {
157 : 2 : wpa_hexdump(MSG_DEBUG, "IKEV2: Transform Attributes",
158 : 2 : pos, tend - pos);
159 : : }
160 : :
161 [ + + + + : 8 : switch (t->transform_type) {
- ]
162 : : case IKEV2_TRANSFORM_ENCR:
163 [ + - ][ + - ]: 2 : if (ikev2_get_encr(transform_id) &&
164 : 2 : transform_id == data->proposal.encr) {
165 [ + - ]: 2 : if (transform_id == ENCR_AES_CBC) {
166 [ - + ]: 2 : if (tend - pos != 4) {
167 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: No "
168 : : "Transform Attr for AES");
169 : 0 : break;
170 : : }
171 [ - + ]: 2 : if (WPA_GET_BE16(pos) != 0x800e) {
172 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: Not a "
173 : : "Key Size attribute for "
174 : : "AES");
175 : 0 : break;
176 : : }
177 [ - + ]: 2 : if (WPA_GET_BE16(pos + 2) != 128) {
178 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: "
179 : : "Unsupported AES key size "
180 : : "%d bits",
181 : 0 : WPA_GET_BE16(pos + 2));
182 : 0 : break;
183 : : }
184 : : }
185 : 2 : prop->encr = transform_id;
186 : : }
187 : 2 : break;
188 : : case IKEV2_TRANSFORM_PRF:
189 [ + - ][ + - ]: 2 : if (ikev2_get_prf(transform_id) &&
190 : 2 : transform_id == data->proposal.prf)
191 : 2 : prop->prf = transform_id;
192 : 2 : break;
193 : : case IKEV2_TRANSFORM_INTEG:
194 [ + - ][ + - ]: 2 : if (ikev2_get_integ(transform_id) &&
195 : 2 : transform_id == data->proposal.integ)
196 : 2 : prop->integ = transform_id;
197 : 2 : break;
198 : : case IKEV2_TRANSFORM_DH:
199 [ + - ][ + - ]: 2 : if (dh_groups_get(transform_id) &&
200 : 2 : transform_id == data->proposal.dh)
201 : 2 : prop->dh = transform_id;
202 : 2 : break;
203 : : }
204 : :
205 : 8 : return transform_len;
206 : : }
207 : :
208 : :
209 : 2 : static int ikev2_parse_proposal(struct ikev2_initiator_data *data,
210 : : struct ikev2_proposal_data *prop,
211 : : const u8 *pos, const u8 *end)
212 : : {
213 : : const u8 *pend, *ppos;
214 : : int proposal_len, i;
215 : : const struct ikev2_proposal *p;
216 : :
217 [ - + ]: 2 : if (end - pos < (int) sizeof(*p)) {
218 : 0 : wpa_printf(MSG_INFO, "IKEV2: Too short proposal");
219 : 0 : return -1;
220 : : }
221 : :
222 : 2 : p = (const struct ikev2_proposal *) pos;
223 : 2 : proposal_len = WPA_GET_BE16(p->proposal_length);
224 [ - + ][ + - ]: 2 : if (proposal_len < (int) sizeof(*p) || pos + proposal_len > end) {
225 : 0 : wpa_printf(MSG_INFO, "IKEV2: Invalid proposal length %d",
226 : : proposal_len);
227 : 0 : return -1;
228 : : }
229 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: SAi1 Proposal # %d",
230 : 2 : p->proposal_num);
231 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Type: %d Proposal Length: %d "
232 : : " Protocol ID: %d",
233 : 4 : p->type, proposal_len, p->protocol_id);
234 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: SPI Size: %d Transforms: %d",
235 : 4 : p->spi_size, p->num_transforms);
236 : :
237 [ # # ][ - + ]: 2 : if (p->type != 0 && p->type != 2) {
238 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Proposal type");
239 : 0 : return -1;
240 : : }
241 : :
242 [ - + ]: 2 : if (p->protocol_id != IKEV2_PROTOCOL_IKE) {
243 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: Unexpected Protocol ID "
244 : : "(only IKE allowed for EAP-IKEv2)");
245 : 0 : return -1;
246 : : }
247 : :
248 [ - + ]: 2 : if (p->proposal_num != prop->proposal_num) {
249 [ # # ]: 0 : if (p->proposal_num == prop->proposal_num + 1)
250 : 0 : prop->proposal_num = p->proposal_num;
251 : : else {
252 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Proposal #");
253 : 0 : return -1;
254 : : }
255 : : }
256 : :
257 : 2 : ppos = (const u8 *) (p + 1);
258 : 2 : pend = pos + proposal_len;
259 [ - + ]: 2 : if (ppos + p->spi_size > pend) {
260 : 0 : wpa_printf(MSG_INFO, "IKEV2: Not enough room for SPI "
261 : : "in proposal");
262 : 0 : return -1;
263 : : }
264 [ - + ]: 2 : if (p->spi_size) {
265 : 0 : wpa_hexdump(MSG_DEBUG, "IKEV2: SPI",
266 : 0 : ppos, p->spi_size);
267 : 0 : ppos += p->spi_size;
268 : : }
269 : :
270 : : /*
271 : : * For initial IKE_SA negotiation, SPI Size MUST be zero; for
272 : : * subsequent negotiations, it must be 8 for IKE. We only support
273 : : * initial case for now.
274 : : */
275 [ - + ]: 2 : if (p->spi_size != 0) {
276 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected SPI Size");
277 : 0 : return -1;
278 : : }
279 : :
280 [ - + ]: 2 : if (p->num_transforms == 0) {
281 : 0 : wpa_printf(MSG_INFO, "IKEV2: At least one transform required");
282 : 0 : return -1;
283 : : }
284 : :
285 [ + + ]: 10 : for (i = 0; i < (int) p->num_transforms; i++) {
286 : 8 : int tlen = ikev2_parse_transform(data, prop, ppos, pend);
287 [ - + ]: 8 : if (tlen < 0)
288 : 0 : return -1;
289 : 8 : ppos += tlen;
290 : : }
291 : :
292 [ - + ]: 2 : if (ppos != pend) {
293 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected data after "
294 : : "transforms");
295 : 0 : return -1;
296 : : }
297 : :
298 : 2 : return proposal_len;
299 : : }
300 : :
301 : :
302 : 2 : static int ikev2_process_sar1(struct ikev2_initiator_data *data,
303 : : const u8 *sar1, size_t sar1_len)
304 : : {
305 : : struct ikev2_proposal_data prop;
306 : : const u8 *pos, *end;
307 : 2 : int found = 0;
308 : :
309 : : /* Security Association Payloads: <Proposals> */
310 : :
311 [ - + ]: 2 : if (sar1 == NULL) {
312 : 0 : wpa_printf(MSG_INFO, "IKEV2: SAr1 not received");
313 : 0 : return -1;
314 : : }
315 : :
316 : 2 : os_memset(&prop, 0, sizeof(prop));
317 : 2 : prop.proposal_num = 1;
318 : :
319 : 2 : pos = sar1;
320 : 2 : end = sar1 + sar1_len;
321 : :
322 [ + - ]: 2 : while (pos < end) {
323 : : int plen;
324 : :
325 : 2 : prop.integ = -1;
326 : 2 : prop.prf = -1;
327 : 2 : prop.encr = -1;
328 : 2 : prop.dh = -1;
329 : 2 : plen = ikev2_parse_proposal(data, &prop, pos, end);
330 [ - + ]: 2 : if (plen < 0)
331 : 0 : return -1;
332 : :
333 [ + - ][ + - ]: 2 : if (!found && prop.integ != -1 && prop.prf != -1 &&
[ + - ][ + - ]
334 [ + - ]: 2 : prop.encr != -1 && prop.dh != -1) {
335 : 2 : found = 1;
336 : : }
337 : :
338 : 2 : pos += plen;
339 : :
340 : : /* Only one proposal expected in SAr */
341 : 2 : break;
342 : : }
343 : :
344 [ - + ]: 2 : if (pos != end) {
345 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected data after proposal");
346 : 0 : return -1;
347 : : }
348 : :
349 [ - + ]: 2 : if (!found) {
350 : 0 : wpa_printf(MSG_INFO, "IKEV2: No acceptable proposal found");
351 : 0 : return -1;
352 : : }
353 : :
354 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Accepted proposal #%d: ENCR:%d PRF:%d "
355 : 2 : "INTEG:%d D-H:%d", data->proposal.proposal_num,
356 : : data->proposal.encr, data->proposal.prf,
357 : : data->proposal.integ, data->proposal.dh);
358 : :
359 : 2 : return 0;
360 : : }
361 : :
362 : :
363 : 2 : static int ikev2_process_ker(struct ikev2_initiator_data *data,
364 : : const u8 *ker, size_t ker_len)
365 : : {
366 : : u16 group;
367 : :
368 : : /*
369 : : * Key Exchange Payload:
370 : : * DH Group # (16 bits)
371 : : * RESERVED (16 bits)
372 : : * Key Exchange Data (Diffie-Hellman public value)
373 : : */
374 : :
375 [ - + ]: 2 : if (ker == NULL) {
376 : 0 : wpa_printf(MSG_INFO, "IKEV2: KEr not received");
377 : 0 : return -1;
378 : : }
379 : :
380 [ - + ]: 2 : if (ker_len < 4 + 96) {
381 : 0 : wpa_printf(MSG_INFO, "IKEV2: Too show Key Exchange Payload");
382 : 0 : return -1;
383 : : }
384 : :
385 : 2 : group = WPA_GET_BE16(ker);
386 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: KEr DH Group #%u", group);
387 : :
388 [ - + ]: 2 : if (group != data->proposal.dh) {
389 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: KEr DH Group #%u does not match "
390 : : "with the selected proposal (%u)",
391 : : group, data->proposal.dh);
392 : 0 : return -1;
393 : : }
394 : :
395 [ - + ]: 2 : if (data->dh == NULL) {
396 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unsupported DH group");
397 : 0 : return -1;
398 : : }
399 : :
400 : : /* RFC 4306, Section 3.4:
401 : : * The length of DH public value MUST be equal to the length of the
402 : : * prime modulus.
403 : : */
404 [ - + ]: 2 : if (ker_len - 4 != data->dh->prime_len) {
405 : 0 : wpa_printf(MSG_INFO, "IKEV2: Invalid DH public value length "
406 : : "%ld (expected %ld)",
407 : 0 : (long) (ker_len - 4), (long) data->dh->prime_len);
408 : 0 : return -1;
409 : : }
410 : :
411 : 2 : wpabuf_free(data->r_dh_public);
412 : 2 : data->r_dh_public = wpabuf_alloc_copy(ker + 4, ker_len - 4);
413 [ - + ]: 2 : if (data->r_dh_public == NULL)
414 : 0 : return -1;
415 : :
416 : 2 : wpa_hexdump_buf(MSG_DEBUG, "IKEV2: KEr Diffie-Hellman Public Value",
417 : 2 : data->r_dh_public);
418 : :
419 : 2 : return 0;
420 : : }
421 : :
422 : :
423 : 2 : static int ikev2_process_nr(struct ikev2_initiator_data *data,
424 : : const u8 *nr, size_t nr_len)
425 : : {
426 [ - + ]: 2 : if (nr == NULL) {
427 : 0 : wpa_printf(MSG_INFO, "IKEV2: Nr not received");
428 : 0 : return -1;
429 : : }
430 : :
431 [ + - ][ - + ]: 2 : if (nr_len < IKEV2_NONCE_MIN_LEN || nr_len > IKEV2_NONCE_MAX_LEN) {
432 : 0 : wpa_printf(MSG_INFO, "IKEV2: Invalid Nr length %ld",
433 : : (long) nr_len);
434 : 0 : return -1;
435 : : }
436 : :
437 : 2 : data->r_nonce_len = nr_len;
438 : 2 : os_memcpy(data->r_nonce, nr, nr_len);
439 : 2 : wpa_hexdump(MSG_MSGDUMP, "IKEV2: Nr",
440 : 2 : data->r_nonce, data->r_nonce_len);
441 : :
442 : 2 : return 0;
443 : : }
444 : :
445 : :
446 : 2 : static int ikev2_process_sa_init_encr(struct ikev2_initiator_data *data,
447 : : const struct ikev2_hdr *hdr,
448 : : const u8 *encrypted,
449 : : size_t encrypted_len, u8 next_payload)
450 : : {
451 : : u8 *decrypted;
452 : : size_t decrypted_len;
453 : : struct ikev2_payloads pl;
454 : 2 : int ret = 0;
455 : :
456 : 2 : decrypted = ikev2_decrypt_payload(data->proposal.encr,
457 : : data->proposal.integ, &data->keys, 0,
458 : : hdr, encrypted, encrypted_len,
459 : : &decrypted_len);
460 [ - + ]: 2 : if (decrypted == NULL)
461 : 0 : return -1;
462 : :
463 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Processing decrypted payloads");
464 : :
465 [ - + ]: 2 : if (ikev2_parse_payloads(&pl, next_payload, decrypted,
466 : : decrypted + decrypted_len) < 0) {
467 : 0 : wpa_printf(MSG_INFO, "IKEV2: Failed to parse decrypted "
468 : : "payloads");
469 : 0 : return -1;
470 : : }
471 : :
472 [ + - ]: 2 : if (pl.idr)
473 : 2 : ret = ikev2_process_idr(data, pl.idr, pl.idr_len);
474 : :
475 : 2 : os_free(decrypted);
476 : :
477 : 2 : return ret;
478 : : }
479 : :
480 : :
481 : 2 : static int ikev2_process_sa_init(struct ikev2_initiator_data *data,
482 : : const struct ikev2_hdr *hdr,
483 : : struct ikev2_payloads *pl)
484 : : {
485 [ + - + - ]: 4 : if (ikev2_process_sar1(data, pl->sa, pl->sa_len) < 0 ||
486 [ - + ]: 4 : ikev2_process_ker(data, pl->ke, pl->ke_len) < 0 ||
487 : 2 : ikev2_process_nr(data, pl->nonce, pl->nonce_len) < 0)
488 : 0 : return -1;
489 : :
490 : 2 : os_memcpy(data->r_spi, hdr->r_spi, IKEV2_SPI_LEN);
491 : :
492 [ - + ]: 2 : if (ikev2_derive_keys(data) < 0)
493 : 0 : return -1;
494 : :
495 [ + - ]: 2 : if (pl->encrypted) {
496 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Encrypted payload in SA_INIT - "
497 : : "try to get IDr from it");
498 [ - + ]: 2 : if (ikev2_process_sa_init_encr(data, hdr, pl->encrypted,
499 : : pl->encrypted_len,
500 : 2 : pl->encr_next_payload) < 0) {
501 : 0 : wpa_printf(MSG_INFO, "IKEV2: Failed to process "
502 : : "encrypted payload");
503 : 0 : return -1;
504 : : }
505 : : }
506 : :
507 : 2 : data->state = SA_AUTH;
508 : :
509 : 2 : return 0;
510 : : }
511 : :
512 : :
513 : 4 : static int ikev2_process_idr(struct ikev2_initiator_data *data,
514 : : const u8 *idr, size_t idr_len)
515 : : {
516 : : u8 id_type;
517 : :
518 [ - + ]: 4 : if (idr == NULL) {
519 : 0 : wpa_printf(MSG_INFO, "IKEV2: No IDr received");
520 : 0 : return -1;
521 : : }
522 : :
523 [ - + ]: 4 : if (idr_len < 4) {
524 : 0 : wpa_printf(MSG_INFO, "IKEV2: Too short IDr payload");
525 : 0 : return -1;
526 : : }
527 : :
528 : 4 : id_type = idr[0];
529 : 4 : idr += 4;
530 : 4 : idr_len -= 4;
531 : :
532 : 4 : wpa_printf(MSG_DEBUG, "IKEV2: IDr ID Type %d", id_type);
533 : 4 : wpa_hexdump_ascii(MSG_DEBUG, "IKEV2: IDr", idr, idr_len);
534 [ + + ]: 4 : if (data->IDr) {
535 [ + - ][ + - ]: 2 : if (id_type != data->IDr_type || idr_len != data->IDr_len ||
[ - + ]
536 : 2 : os_memcmp(idr, data->IDr, idr_len) != 0) {
537 : 0 : wpa_printf(MSG_INFO, "IKEV2: IDr differs from the one "
538 : : "received earlier");
539 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: Previous IDr ID Type %d",
540 : : id_type);
541 : 0 : wpa_hexdump_ascii(MSG_DEBUG, "Previous IKEV2: IDr",
542 : 0 : data->IDr, data->IDr_len);
543 : 0 : return -1;
544 : : }
545 : 2 : os_free(data->IDr);
546 : : }
547 : 4 : data->IDr = os_malloc(idr_len);
548 [ - + ]: 4 : if (data->IDr == NULL)
549 : 0 : return -1;
550 : 4 : os_memcpy(data->IDr, idr, idr_len);
551 : 4 : data->IDr_len = idr_len;
552 : 4 : data->IDr_type = id_type;
553 : :
554 : 4 : return 0;
555 : : }
556 : :
557 : :
558 : 2 : static int ikev2_process_cert(struct ikev2_initiator_data *data,
559 : : const u8 *cert, size_t cert_len)
560 : : {
561 : : u8 cert_encoding;
562 : :
563 [ + - ]: 2 : if (cert == NULL) {
564 [ - + ]: 2 : if (data->peer_auth == PEER_AUTH_CERT) {
565 : 0 : wpa_printf(MSG_INFO, "IKEV2: No Certificate received");
566 : 0 : return -1;
567 : : }
568 : 2 : return 0;
569 : : }
570 : :
571 [ # # ]: 0 : if (cert_len < 1) {
572 : 0 : wpa_printf(MSG_INFO, "IKEV2: No Cert Encoding field");
573 : 0 : return -1;
574 : : }
575 : :
576 : 0 : cert_encoding = cert[0];
577 : 0 : cert++;
578 : 0 : cert_len--;
579 : :
580 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: Cert Encoding %d", cert_encoding);
581 : 0 : wpa_hexdump(MSG_MSGDUMP, "IKEV2: Certificate Data", cert, cert_len);
582 : :
583 : : /* TODO: validate certificate */
584 : :
585 : 2 : return 0;
586 : : }
587 : :
588 : :
589 : 0 : static int ikev2_process_auth_cert(struct ikev2_initiator_data *data,
590 : : u8 method, const u8 *auth, size_t auth_len)
591 : : {
592 [ # # ]: 0 : if (method != AUTH_RSA_SIGN) {
593 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unsupported authentication "
594 : : "method %d", method);
595 : 0 : return -1;
596 : : }
597 : :
598 : : /* TODO: validate AUTH */
599 : 0 : return 0;
600 : : }
601 : :
602 : :
603 : 2 : static int ikev2_process_auth_secret(struct ikev2_initiator_data *data,
604 : : u8 method, const u8 *auth,
605 : : size_t auth_len)
606 : : {
607 : : u8 auth_data[IKEV2_MAX_HASH_LEN];
608 : : const struct ikev2_prf_alg *prf;
609 : :
610 [ - + ]: 2 : if (method != AUTH_SHARED_KEY_MIC) {
611 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unsupported authentication "
612 : : "method %d", method);
613 : 0 : return -1;
614 : : }
615 : :
616 : : /* msg | Ni | prf(SK_pr,IDr') */
617 [ - + ]: 2 : if (ikev2_derive_auth_data(data->proposal.prf, data->r_sign_msg,
618 : 4 : data->IDr, data->IDr_len, data->IDr_type,
619 : 2 : &data->keys, 0, data->shared_secret,
620 : : data->shared_secret_len,
621 : 2 : data->i_nonce, data->i_nonce_len,
622 : 2 : data->key_pad, data->key_pad_len,
623 : : auth_data) < 0) {
624 : 0 : wpa_printf(MSG_INFO, "IKEV2: Could not derive AUTH data");
625 : 0 : return -1;
626 : : }
627 : :
628 : 2 : wpabuf_free(data->r_sign_msg);
629 : 2 : data->r_sign_msg = NULL;
630 : :
631 : 2 : prf = ikev2_get_prf(data->proposal.prf);
632 [ - + ]: 2 : if (prf == NULL)
633 : 0 : return -1;
634 : :
635 [ + - ][ - + ]: 2 : if (auth_len != prf->hash_len ||
636 : 2 : os_memcmp(auth, auth_data, auth_len) != 0) {
637 : 0 : wpa_printf(MSG_INFO, "IKEV2: Invalid Authentication Data");
638 : 0 : wpa_hexdump(MSG_DEBUG, "IKEV2: Received Authentication Data",
639 : : auth, auth_len);
640 : 0 : wpa_hexdump(MSG_DEBUG, "IKEV2: Expected Authentication Data",
641 : : auth_data, prf->hash_len);
642 : 0 : return -1;
643 : : }
644 : :
645 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Peer authenticated successfully "
646 : : "using shared keys");
647 : :
648 : 2 : return 0;
649 : : }
650 : :
651 : :
652 : 2 : static int ikev2_process_auth(struct ikev2_initiator_data *data,
653 : : const u8 *auth, size_t auth_len)
654 : : {
655 : : u8 auth_method;
656 : :
657 [ - + ]: 2 : if (auth == NULL) {
658 : 0 : wpa_printf(MSG_INFO, "IKEV2: No Authentication Payload");
659 : 0 : return -1;
660 : : }
661 : :
662 [ - + ]: 2 : if (auth_len < 4) {
663 : 0 : wpa_printf(MSG_INFO, "IKEV2: Too short Authentication "
664 : : "Payload");
665 : 0 : return -1;
666 : : }
667 : :
668 : 2 : auth_method = auth[0];
669 : 2 : auth += 4;
670 : 2 : auth_len -= 4;
671 : :
672 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Auth Method %d", auth_method);
673 : 2 : wpa_hexdump(MSG_MSGDUMP, "IKEV2: Authentication Data", auth, auth_len);
674 : :
675 [ - + - ]: 2 : switch (data->peer_auth) {
676 : : case PEER_AUTH_CERT:
677 : 0 : return ikev2_process_auth_cert(data, auth_method, auth,
678 : : auth_len);
679 : : case PEER_AUTH_SECRET:
680 : 2 : return ikev2_process_auth_secret(data, auth_method, auth,
681 : : auth_len);
682 : : }
683 : :
684 : 2 : return -1;
685 : : }
686 : :
687 : :
688 : 2 : static int ikev2_process_sa_auth_decrypted(struct ikev2_initiator_data *data,
689 : : u8 next_payload,
690 : : u8 *payload, size_t payload_len)
691 : : {
692 : : struct ikev2_payloads pl;
693 : :
694 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Processing decrypted payloads");
695 : :
696 [ - + ]: 2 : if (ikev2_parse_payloads(&pl, next_payload, payload, payload +
697 : : payload_len) < 0) {
698 : 0 : wpa_printf(MSG_INFO, "IKEV2: Failed to parse decrypted "
699 : : "payloads");
700 : 0 : return -1;
701 : : }
702 : :
703 [ + - + - ]: 4 : if (ikev2_process_idr(data, pl.idr, pl.idr_len) < 0 ||
704 [ - + ]: 4 : ikev2_process_cert(data, pl.cert, pl.cert_len) < 0 ||
705 : 2 : ikev2_process_auth(data, pl.auth, pl.auth_len) < 0)
706 : 0 : return -1;
707 : :
708 : 2 : return 0;
709 : : }
710 : :
711 : :
712 : 2 : static int ikev2_process_sa_auth(struct ikev2_initiator_data *data,
713 : : const struct ikev2_hdr *hdr,
714 : : struct ikev2_payloads *pl)
715 : : {
716 : : u8 *decrypted;
717 : : size_t decrypted_len;
718 : : int ret;
719 : :
720 : 2 : decrypted = ikev2_decrypt_payload(data->proposal.encr,
721 : : data->proposal.integ,
722 : : &data->keys, 0, hdr, pl->encrypted,
723 : : pl->encrypted_len, &decrypted_len);
724 [ - + ]: 2 : if (decrypted == NULL)
725 : 0 : return -1;
726 : :
727 : 2 : ret = ikev2_process_sa_auth_decrypted(data, pl->encr_next_payload,
728 : : decrypted, decrypted_len);
729 : 2 : os_free(decrypted);
730 : :
731 [ + - ][ + - ]: 2 : if (ret == 0 && !data->unknown_user) {
732 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Authentication completed");
733 : 2 : data->state = IKEV2_DONE;
734 : : }
735 : :
736 : 2 : return ret;
737 : : }
738 : :
739 : :
740 : 4 : static int ikev2_validate_rx_state(struct ikev2_initiator_data *data,
741 : : u8 exchange_type, u32 message_id)
742 : : {
743 [ + + - - : 4 : switch (data->state) {
- ]
744 : : case SA_INIT:
745 : : /* Expect to receive IKE_SA_INIT: HDR, SAr, KEr, Nr, [CERTREQ],
746 : : * [SK{IDr}] */
747 [ - + ]: 2 : if (exchange_type != IKE_SA_INIT) {
748 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Exchange Type "
749 : : "%u in SA_INIT state", exchange_type);
750 : 0 : return -1;
751 : : }
752 [ - + ]: 2 : if (message_id != 0) {
753 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Message ID %u "
754 : : "in SA_INIT state", message_id);
755 : 0 : return -1;
756 : : }
757 : 2 : break;
758 : : case SA_AUTH:
759 : : /* Expect to receive IKE_SA_AUTH:
760 : : * HDR, SK {IDr, [CERT,] [CERTREQ,] [NFID,] AUTH}
761 : : */
762 [ - + ]: 2 : if (exchange_type != IKE_SA_AUTH) {
763 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Exchange Type "
764 : : "%u in SA_AUTH state", exchange_type);
765 : 0 : return -1;
766 : : }
767 [ - + ]: 2 : if (message_id != 1) {
768 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Message ID %u "
769 : : "in SA_AUTH state", message_id);
770 : 0 : return -1;
771 : : }
772 : 2 : break;
773 : : case CHILD_SA:
774 [ # # ]: 0 : if (exchange_type != CREATE_CHILD_SA) {
775 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Exchange Type "
776 : : "%u in CHILD_SA state", exchange_type);
777 : 0 : return -1;
778 : : }
779 [ # # ]: 0 : if (message_id != 2) {
780 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Message ID %u "
781 : : "in CHILD_SA state", message_id);
782 : 0 : return -1;
783 : : }
784 : 0 : break;
785 : : case IKEV2_DONE:
786 : 0 : return -1;
787 : : }
788 : :
789 : 4 : return 0;
790 : : }
791 : :
792 : :
793 : 4 : int ikev2_initiator_process(struct ikev2_initiator_data *data,
794 : : const struct wpabuf *buf)
795 : : {
796 : : const struct ikev2_hdr *hdr;
797 : : u32 length, message_id;
798 : : const u8 *pos, *end;
799 : : struct ikev2_payloads pl;
800 : :
801 : 4 : wpa_printf(MSG_MSGDUMP, "IKEV2: Received message (len %lu)",
802 : : (unsigned long) wpabuf_len(buf));
803 : :
804 [ - + ]: 4 : if (wpabuf_len(buf) < sizeof(*hdr)) {
805 : 0 : wpa_printf(MSG_INFO, "IKEV2: Too short frame to include HDR");
806 : 0 : return -1;
807 : : }
808 : :
809 : 4 : hdr = (const struct ikev2_hdr *) wpabuf_head(buf);
810 : 4 : end = wpabuf_head_u8(buf) + wpabuf_len(buf);
811 : 4 : message_id = WPA_GET_BE32(hdr->message_id);
812 : 4 : length = WPA_GET_BE32(hdr->length);
813 : :
814 : 4 : wpa_hexdump(MSG_DEBUG, "IKEV2: IKE_SA Initiator's SPI",
815 : 4 : hdr->i_spi, IKEV2_SPI_LEN);
816 : 4 : wpa_hexdump(MSG_DEBUG, "IKEV2: IKE_SA Initiator's SPI",
817 : 4 : hdr->r_spi, IKEV2_SPI_LEN);
818 : 4 : wpa_printf(MSG_DEBUG, "IKEV2: Next Payload: %u Version: 0x%x "
819 : : "Exchange Type: %u",
820 : 12 : hdr->next_payload, hdr->version, hdr->exchange_type);
821 : 4 : wpa_printf(MSG_DEBUG, "IKEV2: Message ID: %u Length: %u",
822 : : message_id, length);
823 : :
824 [ - + ]: 4 : if (hdr->version != IKEV2_VERSION) {
825 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unsupported HDR version 0x%x "
826 : 0 : "(expected 0x%x)", hdr->version, IKEV2_VERSION);
827 : 0 : return -1;
828 : : }
829 : :
830 [ - + ]: 4 : if (length != wpabuf_len(buf)) {
831 : 0 : wpa_printf(MSG_INFO, "IKEV2: Invalid length (HDR: %lu != "
832 : : "RX: %lu)", (unsigned long) length,
833 : : (unsigned long) wpabuf_len(buf));
834 : 0 : return -1;
835 : : }
836 : :
837 [ - + ]: 4 : if (ikev2_validate_rx_state(data, hdr->exchange_type, message_id) < 0)
838 : 0 : return -1;
839 : :
840 [ - + ]: 4 : if ((hdr->flags & (IKEV2_HDR_INITIATOR | IKEV2_HDR_RESPONSE)) !=
841 : : IKEV2_HDR_RESPONSE) {
842 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected Flags value 0x%x",
843 : 0 : hdr->flags);
844 : 0 : return -1;
845 : : }
846 : :
847 [ + + ]: 4 : if (data->state != SA_INIT) {
848 [ - + ]: 2 : if (os_memcmp(data->i_spi, hdr->i_spi, IKEV2_SPI_LEN) != 0) {
849 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected IKE_SA "
850 : : "Initiator's SPI");
851 : 0 : return -1;
852 : : }
853 [ - + ]: 2 : if (os_memcmp(data->r_spi, hdr->r_spi, IKEV2_SPI_LEN) != 0) {
854 : 0 : wpa_printf(MSG_INFO, "IKEV2: Unexpected IKE_SA "
855 : : "Responder's SPI");
856 : 0 : return -1;
857 : : }
858 : : }
859 : :
860 : 4 : pos = (const u8 *) (hdr + 1);
861 [ - + ]: 4 : if (ikev2_parse_payloads(&pl, hdr->next_payload, pos, end) < 0)
862 : 0 : return -1;
863 : :
864 [ + + - - ]: 4 : switch (data->state) {
865 : : case SA_INIT:
866 [ - + ]: 2 : if (ikev2_process_sa_init(data, hdr, &pl) < 0)
867 : 0 : return -1;
868 : 2 : wpabuf_free(data->r_sign_msg);
869 : 2 : data->r_sign_msg = wpabuf_dup(buf);
870 : 2 : break;
871 : : case SA_AUTH:
872 [ - + ]: 2 : if (ikev2_process_sa_auth(data, hdr, &pl) < 0)
873 : 0 : return -1;
874 : 2 : break;
875 : : case CHILD_SA:
876 : : case IKEV2_DONE:
877 : 0 : break;
878 : : }
879 : :
880 : 4 : return 0;
881 : : }
882 : :
883 : :
884 : 4 : static void ikev2_build_hdr(struct ikev2_initiator_data *data,
885 : : struct wpabuf *msg, u8 exchange_type,
886 : : u8 next_payload, u32 message_id)
887 : : {
888 : : struct ikev2_hdr *hdr;
889 : :
890 : 4 : wpa_printf(MSG_DEBUG, "IKEV2: Adding HDR");
891 : :
892 : : /* HDR - RFC 4306, Sect. 3.1 */
893 : 4 : hdr = wpabuf_put(msg, sizeof(*hdr));
894 : 4 : os_memcpy(hdr->i_spi, data->i_spi, IKEV2_SPI_LEN);
895 : 4 : os_memcpy(hdr->r_spi, data->r_spi, IKEV2_SPI_LEN);
896 : 4 : hdr->next_payload = next_payload;
897 : 4 : hdr->version = IKEV2_VERSION;
898 : 4 : hdr->exchange_type = exchange_type;
899 : 4 : hdr->flags = IKEV2_HDR_INITIATOR;
900 : 4 : WPA_PUT_BE32(hdr->message_id, message_id);
901 : 4 : }
902 : :
903 : :
904 : 2 : static int ikev2_build_sai(struct ikev2_initiator_data *data,
905 : : struct wpabuf *msg, u8 next_payload)
906 : : {
907 : : struct ikev2_payload_hdr *phdr;
908 : : size_t plen;
909 : : struct ikev2_proposal *p;
910 : : struct ikev2_transform *t;
911 : :
912 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Adding SAi payload");
913 : :
914 : : /* SAi1 - RFC 4306, Sect. 2.7 and 3.3 */
915 : 2 : phdr = wpabuf_put(msg, sizeof(*phdr));
916 : 2 : phdr->next_payload = next_payload;
917 : 2 : phdr->flags = 0;
918 : :
919 : : /* TODO: support for multiple proposals */
920 : 2 : p = wpabuf_put(msg, sizeof(*p));
921 : 2 : p->proposal_num = data->proposal.proposal_num;
922 : 2 : p->protocol_id = IKEV2_PROTOCOL_IKE;
923 : 2 : p->num_transforms = 4;
924 : :
925 : 2 : t = wpabuf_put(msg, sizeof(*t));
926 : 2 : t->type = 3;
927 : 2 : t->transform_type = IKEV2_TRANSFORM_ENCR;
928 : 2 : WPA_PUT_BE16(t->transform_id, data->proposal.encr);
929 [ + - ]: 2 : if (data->proposal.encr == ENCR_AES_CBC) {
930 : : /* Transform Attribute: Key Len = 128 bits */
931 : 2 : wpabuf_put_be16(msg, 0x800e); /* AF=1, AttrType=14 */
932 : 2 : wpabuf_put_be16(msg, 128); /* 128-bit key */
933 : : }
934 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) t;
935 : 2 : WPA_PUT_BE16(t->transform_length, plen);
936 : :
937 : 2 : t = wpabuf_put(msg, sizeof(*t));
938 : 2 : t->type = 3;
939 : 2 : WPA_PUT_BE16(t->transform_length, sizeof(*t));
940 : 2 : t->transform_type = IKEV2_TRANSFORM_PRF;
941 : 2 : WPA_PUT_BE16(t->transform_id, data->proposal.prf);
942 : :
943 : 2 : t = wpabuf_put(msg, sizeof(*t));
944 : 2 : t->type = 3;
945 : 2 : WPA_PUT_BE16(t->transform_length, sizeof(*t));
946 : 2 : t->transform_type = IKEV2_TRANSFORM_INTEG;
947 : 2 : WPA_PUT_BE16(t->transform_id, data->proposal.integ);
948 : :
949 : 2 : t = wpabuf_put(msg, sizeof(*t));
950 : 2 : WPA_PUT_BE16(t->transform_length, sizeof(*t));
951 : 2 : t->transform_type = IKEV2_TRANSFORM_DH;
952 : 2 : WPA_PUT_BE16(t->transform_id, data->proposal.dh);
953 : :
954 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) p;
955 : 2 : WPA_PUT_BE16(p->proposal_length, plen);
956 : :
957 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
958 : 2 : WPA_PUT_BE16(phdr->payload_length, plen);
959 : :
960 : 2 : return 0;
961 : : }
962 : :
963 : :
964 : 2 : static int ikev2_build_kei(struct ikev2_initiator_data *data,
965 : : struct wpabuf *msg, u8 next_payload)
966 : : {
967 : : struct ikev2_payload_hdr *phdr;
968 : : size_t plen;
969 : : struct wpabuf *pv;
970 : :
971 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Adding KEi payload");
972 : :
973 : 2 : data->dh = dh_groups_get(data->proposal.dh);
974 : 2 : pv = dh_init(data->dh, &data->i_dh_private);
975 [ - + ]: 2 : if (pv == NULL) {
976 : 0 : wpa_printf(MSG_DEBUG, "IKEV2: Failed to initialize DH");
977 : 0 : return -1;
978 : : }
979 : :
980 : : /* KEi - RFC 4306, Sect. 3.4 */
981 : 2 : phdr = wpabuf_put(msg, sizeof(*phdr));
982 : 2 : phdr->next_payload = next_payload;
983 : 2 : phdr->flags = 0;
984 : :
985 : 2 : wpabuf_put_be16(msg, data->proposal.dh); /* DH Group # */
986 : 2 : wpabuf_put(msg, 2); /* RESERVED */
987 : : /*
988 : : * RFC 4306, Sect. 3.4: possible zero padding for public value to
989 : : * match the length of the prime.
990 : : */
991 : 2 : wpabuf_put(msg, data->dh->prime_len - wpabuf_len(pv));
992 : 2 : wpabuf_put_buf(msg, pv);
993 : 2 : wpabuf_free(pv);
994 : :
995 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
996 : 2 : WPA_PUT_BE16(phdr->payload_length, plen);
997 : 2 : return 0;
998 : : }
999 : :
1000 : :
1001 : 2 : static int ikev2_build_ni(struct ikev2_initiator_data *data,
1002 : : struct wpabuf *msg, u8 next_payload)
1003 : : {
1004 : : struct ikev2_payload_hdr *phdr;
1005 : : size_t plen;
1006 : :
1007 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Adding Ni payload");
1008 : :
1009 : : /* Ni - RFC 4306, Sect. 3.9 */
1010 : 2 : phdr = wpabuf_put(msg, sizeof(*phdr));
1011 : 2 : phdr->next_payload = next_payload;
1012 : 2 : phdr->flags = 0;
1013 : 2 : wpabuf_put_data(msg, data->i_nonce, data->i_nonce_len);
1014 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
1015 : 2 : WPA_PUT_BE16(phdr->payload_length, plen);
1016 : 2 : return 0;
1017 : : }
1018 : :
1019 : :
1020 : 2 : static int ikev2_build_idi(struct ikev2_initiator_data *data,
1021 : : struct wpabuf *msg, u8 next_payload)
1022 : : {
1023 : : struct ikev2_payload_hdr *phdr;
1024 : : size_t plen;
1025 : :
1026 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Adding IDi payload");
1027 : :
1028 [ - + ]: 2 : if (data->IDi == NULL) {
1029 : 0 : wpa_printf(MSG_INFO, "IKEV2: No IDi available");
1030 : 0 : return -1;
1031 : : }
1032 : :
1033 : : /* IDi - RFC 4306, Sect. 3.5 */
1034 : 2 : phdr = wpabuf_put(msg, sizeof(*phdr));
1035 : 2 : phdr->next_payload = next_payload;
1036 : 2 : phdr->flags = 0;
1037 : 2 : wpabuf_put_u8(msg, ID_KEY_ID);
1038 : 2 : wpabuf_put(msg, 3); /* RESERVED */
1039 : 2 : wpabuf_put_data(msg, data->IDi, data->IDi_len);
1040 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
1041 : 2 : WPA_PUT_BE16(phdr->payload_length, plen);
1042 : 2 : return 0;
1043 : : }
1044 : :
1045 : :
1046 : 2 : static int ikev2_build_auth(struct ikev2_initiator_data *data,
1047 : : struct wpabuf *msg, u8 next_payload)
1048 : : {
1049 : : struct ikev2_payload_hdr *phdr;
1050 : : size_t plen;
1051 : : const struct ikev2_prf_alg *prf;
1052 : :
1053 : 2 : wpa_printf(MSG_DEBUG, "IKEV2: Adding AUTH payload");
1054 : :
1055 : 2 : prf = ikev2_get_prf(data->proposal.prf);
1056 [ - + ]: 2 : if (prf == NULL)
1057 : 0 : return -1;
1058 : :
1059 : : /* Authentication - RFC 4306, Sect. 3.8 */
1060 : 2 : phdr = wpabuf_put(msg, sizeof(*phdr));
1061 : 2 : phdr->next_payload = next_payload;
1062 : 2 : phdr->flags = 0;
1063 : 2 : wpabuf_put_u8(msg, AUTH_SHARED_KEY_MIC);
1064 : 2 : wpabuf_put(msg, 3); /* RESERVED */
1065 : :
1066 : : /* msg | Nr | prf(SK_pi,IDi') */
1067 [ - + ]: 2 : if (ikev2_derive_auth_data(data->proposal.prf, data->i_sign_msg,
1068 : 2 : data->IDi, data->IDi_len, ID_KEY_ID,
1069 : 2 : &data->keys, 1, data->shared_secret,
1070 : : data->shared_secret_len,
1071 : 2 : data->r_nonce, data->r_nonce_len,
1072 : 2 : data->key_pad, data->key_pad_len,
1073 : 2 : wpabuf_put(msg, prf->hash_len)) < 0) {
1074 : 0 : wpa_printf(MSG_INFO, "IKEV2: Could not derive AUTH data");
1075 : 0 : return -1;
1076 : : }
1077 : 2 : wpabuf_free(data->i_sign_msg);
1078 : 2 : data->i_sign_msg = NULL;
1079 : :
1080 : 2 : plen = (u8 *) wpabuf_put(msg, 0) - (u8 *) phdr;
1081 : 2 : WPA_PUT_BE16(phdr->payload_length, plen);
1082 : 2 : return 0;
1083 : : }
1084 : :
1085 : :
1086 : 2 : static struct wpabuf * ikev2_build_sa_init(struct ikev2_initiator_data *data)
1087 : : {
1088 : : struct wpabuf *msg;
1089 : :
1090 : : /* build IKE_SA_INIT: HDR, SAi, KEi, Ni */
1091 : :
1092 [ - + ]: 2 : if (os_get_random(data->i_spi, IKEV2_SPI_LEN))
1093 : 0 : return NULL;
1094 : 2 : wpa_hexdump(MSG_DEBUG, "IKEV2: IKE_SA Initiator's SPI",
1095 : 2 : data->i_spi, IKEV2_SPI_LEN);
1096 : :
1097 : 2 : data->i_nonce_len = IKEV2_NONCE_MIN_LEN;
1098 [ - + ]: 2 : if (random_get_bytes(data->i_nonce, data->i_nonce_len))
1099 : 0 : return NULL;
1100 : 2 : wpa_hexdump(MSG_DEBUG, "IKEV2: Ni", data->i_nonce, data->i_nonce_len);
1101 : :
1102 : 2 : msg = wpabuf_alloc(sizeof(struct ikev2_hdr) + 1000);
1103 [ - + ]: 2 : if (msg == NULL)
1104 : 0 : return NULL;
1105 : :
1106 : 2 : ikev2_build_hdr(data, msg, IKE_SA_INIT, IKEV2_PAYLOAD_SA, 0);
1107 [ + - + - ]: 4 : if (ikev2_build_sai(data, msg, IKEV2_PAYLOAD_KEY_EXCHANGE) ||
1108 [ - + ]: 4 : ikev2_build_kei(data, msg, IKEV2_PAYLOAD_NONCE) ||
1109 : 2 : ikev2_build_ni(data, msg, IKEV2_PAYLOAD_NO_NEXT_PAYLOAD)) {
1110 : 0 : wpabuf_free(msg);
1111 : 0 : return NULL;
1112 : : }
1113 : :
1114 : 2 : ikev2_update_hdr(msg);
1115 : :
1116 : 2 : wpa_hexdump_buf(MSG_MSGDUMP, "IKEV2: Sending message (SA_INIT)", msg);
1117 : :
1118 : 2 : wpabuf_free(data->i_sign_msg);
1119 : 2 : data->i_sign_msg = wpabuf_dup(msg);
1120 : :
1121 : 2 : return msg;
1122 : : }
1123 : :
1124 : :
1125 : 2 : static struct wpabuf * ikev2_build_sa_auth(struct ikev2_initiator_data *data)
1126 : : {
1127 : : struct wpabuf *msg, *plain;
1128 : : const u8 *secret;
1129 : : size_t secret_len;
1130 : :
1131 : 2 : secret = data->get_shared_secret(data->cb_ctx, data->IDr,
1132 : : data->IDr_len, &secret_len);
1133 [ - + ]: 2 : if (secret == NULL) {
1134 : 0 : wpa_printf(MSG_INFO, "IKEV2: Could not get shared secret - "
1135 : : "use fake value");
1136 : : /* RFC 5106, Sect. 7:
1137 : : * Use a random key to fake AUTH generation in order to prevent
1138 : : * probing of user identities.
1139 : : */
1140 : 0 : data->unknown_user = 1;
1141 : 0 : os_free(data->shared_secret);
1142 : 0 : data->shared_secret = os_malloc(16);
1143 [ # # ]: 0 : if (data->shared_secret == NULL)
1144 : 0 : return NULL;
1145 : 0 : data->shared_secret_len = 16;
1146 [ # # ]: 0 : if (random_get_bytes(data->shared_secret, 16))
1147 : 0 : return NULL;
1148 : : } else {
1149 : 2 : os_free(data->shared_secret);
1150 : 2 : data->shared_secret = os_malloc(secret_len);
1151 [ - + ]: 2 : if (data->shared_secret == NULL)
1152 : 0 : return NULL;
1153 : 2 : os_memcpy(data->shared_secret, secret, secret_len);
1154 : 2 : data->shared_secret_len = secret_len;
1155 : : }
1156 : :
1157 : : /* build IKE_SA_AUTH: HDR, SK {IDi, [CERT,] [CERTREQ,] AUTH} */
1158 : :
1159 : 2 : msg = wpabuf_alloc(sizeof(struct ikev2_hdr) + data->IDr_len + 1000);
1160 [ - + ]: 2 : if (msg == NULL)
1161 : 0 : return NULL;
1162 : 2 : ikev2_build_hdr(data, msg, IKE_SA_AUTH, IKEV2_PAYLOAD_ENCRYPTED, 1);
1163 : :
1164 : 2 : plain = wpabuf_alloc(data->IDr_len + 1000);
1165 [ - + ]: 2 : if (plain == NULL) {
1166 : 0 : wpabuf_free(msg);
1167 : 0 : return NULL;
1168 : : }
1169 : :
1170 [ + - + - ]: 4 : if (ikev2_build_idi(data, plain, IKEV2_PAYLOAD_AUTHENTICATION) ||
1171 [ - + ]: 4 : ikev2_build_auth(data, plain, IKEV2_PAYLOAD_NO_NEXT_PAYLOAD) ||
1172 : 2 : ikev2_build_encrypted(data->proposal.encr, data->proposal.integ,
1173 : : &data->keys, 1, msg, plain,
1174 : : IKEV2_PAYLOAD_IDi)) {
1175 : 0 : wpabuf_free(plain);
1176 : 0 : wpabuf_free(msg);
1177 : 0 : return NULL;
1178 : : }
1179 : 2 : wpabuf_free(plain);
1180 : :
1181 : 2 : wpa_hexdump_buf(MSG_MSGDUMP, "IKEV2: Sending message (SA_AUTH)", msg);
1182 : :
1183 : 2 : return msg;
1184 : : }
1185 : :
1186 : :
1187 : 4 : struct wpabuf * ikev2_initiator_build(struct ikev2_initiator_data *data)
1188 : : {
1189 [ + + - - : 4 : switch (data->state) {
- ]
1190 : : case SA_INIT:
1191 : 2 : return ikev2_build_sa_init(data);
1192 : : case SA_AUTH:
1193 : 2 : return ikev2_build_sa_auth(data);
1194 : : case CHILD_SA:
1195 : 0 : return NULL;
1196 : : case IKEV2_DONE:
1197 : 0 : return NULL;
1198 : : }
1199 : 4 : return NULL;
1200 : : }
|
