1 /* $Id: ike_sa.c,v 1.79 2007/12/05 07:26:09 fukumoto Exp $ */
2
3 /*
4 * Copyright (C) 2004 WIDE Project.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <config.h>
33
34 #include <assert.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/types.h>
38 #include <limits.h>
39 #include <inttypes.h>
40
41 #include "gcmalloc.h"
42 #include "racoon.h"
43 #include "isakmp_impl.h"
44 #include "ikev2_impl.h"
45
46 #include "ike_conf.h"
47 #include "var.h"
48 #include "crypto_impl.h"
49
50 #include "debug.h"
51
52 void ikev2_sa_start_nego_timer(struct ikev2_sa *sa);
53 void ikev2_sa_start_grace_period(struct ikev2_sa *sa);
54
55 IKEV2_SA_LIST_HEAD ikev2_sa_list;
56
57 #define FOREACH_SA(v_) TAILQ_FOREACH(v_, &ikev2_sa_list, link)
58
59 void
60 ikev2_sa_init(void)
61 {
62 IKEV2_SA_LIST_INIT(&ikev2_sa_list);
63 }
64
65 void
66 ikev2_sa_insert(struct ikev2_sa *sa)
67 {
68 IKEV2_SA_LIST_LINK(&ikev2_sa_list, sa);
69 }
70
71 static void
72 ikev2_sa_remove(struct ikev2_sa *sa)
73 {
74 IKEV2_SA_LIST_REMOVE(&ikev2_sa_list, sa);
75 }
76
77 #ifdef DEBUG
78 void
79 ikev2_dump(void)
80 {
81 struct timeval tv;
82 struct ikev2_sa *sa;
83 struct ikev2_child_sa *child_sa;
84
85 gettimeofday(&tv, 0);
86 plog(PLOG_DEBUG, PLOGLOC, 0, "timeofday: %ld\n", (long)tv.tv_sec);
87 FOREACH_SA(sa) {
88 plog(PLOG_DEBUG, PLOGLOC, 0, "IKE_SA %p\n", sa);
89 plog(PLOG_DEBUG, PLOGLOC, 0,
90 "index:%02x%02x%02x%02x%02x%02x%02x%02x %02x%02x%02x%02x%02x%02x%02x%02x "
91 "serial_number:%d "
92 "version:%d is_initiator:%d remote:%s local:%s rmconf:%p "
93 "send_message_id:%d request_pending:%d recv_message_id:%d "
94 "state:%d negotiated_sa:%p prf:%p (%s) dh_choice:%p "
95 "encryptor:%p authenticator:%p "
96 "due_time:%ld lifetime_byte:%d "
97 "child_created:%d rekey_inprogress:%d new_sa:%p\n",
98 sa->index.i_ck[0], sa->index.i_ck[1], sa->index.i_ck[2],
99 sa->index.i_ck[3], sa->index.i_ck[4], sa->index.i_ck[5],
100 sa->index.i_ck[6], sa->index.i_ck[7], sa->index.r_ck[0],
101 sa->index.r_ck[1], sa->index.r_ck[2], sa->index.r_ck[3],
102 sa->index.r_ck[4], sa->index.r_ck[5], sa->index.r_ck[6],
103 sa->index.r_ck[7], sa->serial_number, sa->version,
104 sa->is_initiator, rcs_sa2str(sa->remote),
105 rcs_sa2str(sa->local), sa->rmconf, sa->send_message_id,
106 sa->request_pending, sa->recv_message_id, sa->state,
107 sa->negotiated_sa, sa->prf,
108 (!sa->
109 prf ? "(undef)" : (sa->prf && sa->prf->method
110 && sa->prf->method->name) ? sa->prf->
111 method->name : "(unknown)"), sa->dh_choice, sa->encryptor,
112 sa->authenticator, (long)sa->due_time.tv_sec,
113 sa->lifetime_byte, sa->child_created, sa->rekey_inprogress,
114 sa->new_sa);
115
116 if (!sa->expire_timer)
117 plog(PLOG_DEBUG, PLOGLOC, 0, "expire_timer:none\n");
118 else
119 plog(PLOG_DEBUG, PLOGLOC, 0,
120 "expire_timer: xtime %ld func %p param %p\n",
121 (long)sa->expire_timer->xtime,
122 sa->expire_timer->func, sa->expire_timer->param);
123
124 if (!sa->soft_expire_timer)
125 plog(PLOG_DEBUG, PLOGLOC, 0,
126 "soft_expire_timer:none\n");
127 else
128 plog(PLOG_DEBUG, PLOGLOC, 0,
129 "soft_expire_timer: xtime %ld func %p param %p\n",
130 (long)sa->soft_expire_timer->xtime,
131 sa->soft_expire_timer->func,
132 sa->soft_expire_timer->param);
133
134 if (!sa->grace_timer)
135 plog(PLOG_DEBUG, PLOGLOC, 0, "grace_timer:none\n");
136 else
137 plog(PLOG_DEBUG, PLOGLOC, 0,
138 "grace_timer: xtime %ld func %p param %p\n",
139 (long)sa->grace_timer->xtime,
140 sa->grace_timer->func, sa->grace_timer->param);
141
142 if (!sa->polling_timer)
143 plog(PLOG_DEBUG, PLOGLOC, 0, "polling_timer:none\n");
144 else
145 plog(PLOG_DEBUG, PLOGLOC, 0,
146 "polling_timer: xtime %ld func %p param %p\n",
147 (long)sa->polling_timer->xtime,
148 sa->polling_timer->func, sa->polling_timer->param);
149
150 if (!sa->natk_timer)
151 plog(PLOG_DEBUG, PLOGLOC, 0, "natk_timer:none\n");
152 else
153 plog(PLOG_DEBUG, PLOGLOC, 0,
154 "natk_timer: xtime %ld func %p param %p\n",
155 (long)sa->natk_timer->xtime,
156 sa->natk_timer->func, sa->natk_timer->param);
157
158 #define D(msg, x) do { plog(PLOG_DEBUG, PLOGLOC, 0, msg); if (!(x)) plog(PLOG_DEBUG, PLOGLOC, 0, "null\n"); else plogdump(PLOG_DEBUG, PLOGLOC, 0, (x)->v, (x)->l); } while(0)
159 D("n_i:\n", sa->n_i);
160 D("n_r:\n", sa->n_r);
161 D("dhpriv:\n", sa->dhpriv);
162 D("dhpub:\n", sa->dhpub);
163 D("dhpub_p:\n", sa->dhpub_p);
164 D("skeyseed:\n", sa->skeyseed);
165 D("sk_d:\n", sa->sk_d);
166 D("sk_a_i\n", sa->sk_a_i);
167 D("sk_a_r:\n", sa->sk_a_r);
168 D("sk_e_i:\n", sa->sk_e_i);
169 D("sk_e_r:\n", sa->sk_e_r);
170 D("sk_p_i:\n", sa->sk_p_i);
171 D("sk_p_r:\n", sa->sk_p_r);
172 D("id_i:\n", sa->id_i);
173 D("id_r:\n", sa->id_r);
174 D("my_first_message:\n", sa->my_first_message);
175 D("peer_first_message:\n", sa->peer_first_message);
176
177 plog(PLOG_DEBUG, PLOGLOC, 0,
178 "verified_info: packet %p result %d\n",
179 sa->verified_info.packet, sa->verified_info.result);
180
181 plog(PLOG_DEBUG, PLOGLOC, 0,
182 "transmit_info: packet %p sent_time %ld.%08d retry_count %d retry_limit %d interval_to_send %d times_per_send %d\n",
183 sa->transmit_info.packet,
184 (long)sa->transmit_info.sent_time.tv_sec,
185 (int)sa->transmit_info.sent_time.tv_usec,
186 sa->transmit_info.retry_count,
187 sa->transmit_info.retry_limit,
188 sa->transmit_info.interval_to_send,
189 sa->transmit_info.times_per_send);
190 if (!sa->transmit_info.timer)
191 plog(PLOG_DEBUG, PLOGLOC, 0, "timer none\n");
192 else
193 plog(PLOG_DEBUG, PLOGLOC, 0,
194 "timer xtime %ld func %p param %p\n",
195 (long)sa->transmit_info.timer->xtime,
196 sa->transmit_info.timer->func,
197 sa->transmit_info.timer->param);
198
199 plog(PLOG_DEBUG, PLOGLOC, 0, "children:\n");
200 for (child_sa = IKEV2_CHILD_LIST_FIRST(&sa->children);
201 !IKEV2_CHILD_LIST_END(child_sa);
202 child_sa = IKEV2_CHILD_LIST_NEXT(child_sa)) {
203 plog(PLOG_DEBUG, PLOGLOC, 0,
204 "child_sa %p child_id:%lx is_initiator:%d state:%d "
205 "local:%s remote:%s message_id:0x%lx\n",
206 child_sa,
207 child_sa->child_id, child_sa->is_initiator,
208 child_sa->state, rcs_sa2str(child_sa->local),
209 rcs_sa2str(child_sa->remote),
210 (unsigned long)child_sa->message_id);
211 }
212 }
213 }
214 #endif
215
216 void
217 ikev2_sa_periodic_task(void)
218 {
219 struct ikev2_sa *sa, *next_sa;
220
221 for (sa = IKEV2_SA_LIST_FIRST(&ikev2_sa_list); sa; sa = next_sa) {
222 struct ikev2_child_sa *child_sa;
223 struct ikev2_child_sa *next;
224
225 TRACE((PLOGLOC, "ike_sa: %p state %d\n", sa, sa->state));
226 next_sa = IKEV2_SA_LIST_NEXT(sa);
227 for (child_sa = IKEV2_CHILD_LIST_FIRST(&sa->children);
228 !IKEV2_CHILD_LIST_END(child_sa); child_sa = next) {
229 TRACE((PLOGLOC, "child_sa: %p state %d\n", child_sa,
230 child_sa->state));
231 next = IKEV2_CHILD_LIST_NEXT(child_sa);
232 if (child_sa->state == IKEV2_CHILD_STATE_EXPIRED) {
233 TRACE((PLOGLOC, "deallocating child_sa %p\n",
234 child_sa));
235 ikev2_remove_child(child_sa);
236 ikev2_destroy_child_sa(child_sa);
237 }
238 }
239 if ((sa->state == IKEV2_STATE_DYING
240 || sa->state == IKEV2_STATE_DEAD)
241 && IKEV2_CHILD_LIST_FIRST(&sa->children) == NULL) {
242 TRACE((PLOGLOC, "deallocating ike_sa %p\n", sa));
243 ikev2_sa_remove(sa);
244 ikev2_dispose_sa(sa);
245 } else if (sa->state == IKEV2_STATE_ESTABLISHED
246 && IKEV2_CHILD_LIST_FIRST(&sa->children) == NULL
247 && !sa->rekey_inprogress) {
248 TRACE((PLOGLOC, "launching grace period %p\n", sa));
249 ikev2_sa_start_grace_period(sa);
250 }
251 }
252 }
253
254 /*
255 * abort negotiation of ike_sa
256 * kills pending children, deletes established ipsec sa
257 */
258 void
259 ikev2_abort(struct ikev2_sa *ike_sa, int err)
260 {
261 struct ikev2_child_sa *child_sa;
262
263 TRACE((PLOGLOC, "ikev2_abort(%p, %d)\n", ike_sa, err));
264 isakmp_log(ike_sa, 0, 0, 0, PLOG_INFO, PLOGLOC, "aborting ike_sa\n");
265 ikev2_set_state(ike_sa, IKEV2_STATE_DYING);
266
267 for (child_sa = IKEV2_CHILD_LIST_FIRST(&ike_sa->children);
268 !IKEV2_CHILD_LIST_END(child_sa);
269 child_sa = IKEV2_CHILD_LIST_NEXT(child_sa)) {
270 TRACE((PLOGLOC, "child_sa %p state %d\n", child_sa,
271 child_sa->state));
272 switch (child_sa->state) {
273 case IKEV2_CHILD_STATE_GETSPI:
274 ikev2_child_abort(child_sa, err);
275 break;
276 case IKEV2_CHILD_STATE_MATURE:
277 ikev2_child_delete_ipsecsa(child_sa);
278 ikev2_child_state_set(child_sa,
279 IKEV2_CHILD_STATE_EXPIRED);
280 break;
281 case IKEV2_CHILD_STATE_EXPIRED:
282 break;
283 case IKEV2_CHILD_STATE_REQUEST_PENDING:
284 case IKEV2_CHILD_STATE_REQUEST_SENT:
285 default:
286 ikev2_child_state_set(child_sa,
287 IKEV2_CHILD_STATE_EXPIRED);
288 break;
289 }
290 }
291 ikev2_set_state(ike_sa, IKEV2_STATE_DEAD);
292 ++isakmpstat.abort;
293 }
294
295 void
296 ikev2_child_abort(struct ikev2_child_sa *child_sa, int err)
297 {
298 struct rcpfk_msg param;
299
300 (void) memset(¶m, 0, sizeof (param));
301 param.satype = RCT_SATYPE_ESP; /* XXX */
302 param.seq = child_sa->sadb_request.seqno;
303 param.eno = err;
304 child_sa->sadb_request.method->acquire_error(¶m);
305
306 ikev2_child_state_set(child_sa, IKEV2_CHILD_STATE_EXPIRED);
307 ++isakmpstat.child_abort;
308 }
309
310 /*
311 * find ike_sa by ike message spi
312 */
313 struct ikev2_sa *
314 ikev2_find_sa(rc_vchar_t *message)
315 {
316 struct ikev2_header *ikehdr;
317 isakmp_cookie_t *spi_i;
318 isakmp_cookie_t *spi_r;
319 int is_response;
320 int remote_is_initiator;
321 struct ikev2_sa *sa;
322
323 ikehdr = (struct ikev2_header *)message->v;
324
325 spi_i = &ikehdr->initiator_spi;
326 spi_r = &ikehdr->responder_spi;
327 is_response = (ikehdr->flags & IKEV2FLAG_RESPONSE) != 0;
328 remote_is_initiator = (ikehdr->flags & IKEV2FLAG_INITIATOR) != 0;
329
330 FOREACH_SA(sa) {
331 if (!remote_is_initiator && sa->is_initiator) {
332 if (memcmp(spi_i, &sa->index.i_ck,
333 sizeof(isakmp_cookie_t)) == 0)
334 return sa;
335 } else if (remote_is_initiator && !sa->is_initiator) {
336 /* retransmission of IKE_SA_INIT requests? */
337 if (ikehdr->exchange_type == IKEV2EXCH_IKE_SA_INIT &&
338 !is_response) {
339 if (memcmp(spi_i, &sa->index.i_ck,
340 sizeof(isakmp_cookie_t)) == 0 &&
341 sa->peer_first_message &&
342 message->l == sa->peer_first_message->l &&
343 memcmp(message->v,
344 sa->peer_first_message->v,
345 message->l) == 0)
346 return sa;
347 } else {
348 if (memcmp(spi_i, &sa->index.i_ck,
349 sizeof(isakmp_cookie_t)) == 0 &&
350 memcmp(spi_r, &sa->index.r_ck,
351 sizeof(isakmp_cookie_t)) == 0)
352 return sa;
353 }
354 }
355 }
356
357 return 0;
358 }
359
360 /*
361 * find ike_sa by addr
362 */
363 struct ikev2_sa *
364 ikev2_find_sa_by_addr(struct sockaddr *addr)
365 {
366 struct ikev2_sa *sa;
367 struct ikev2_sa *candidate = 0;
368
369 FOREACH_SA(sa) {
370 if (rcs_cmpsa_wop(sa->remote, addr) == 0) {
371 switch (sa->state) {
372 case IKEV2_STATE_ESTABLISHED:
373 return sa;
374 case IKEV2_STATE_DYING:
375 case IKEV2_STATE_DEAD:
376 break;
377 default:
378 candidate = sa;
379 break;
380 }
381 }
382 }
383 return candidate;
384 }
385
386 struct ikev2_sa *
387 ikev2_find_sa_by_serial(int num)
388 {
389 struct ikev2_sa *sa;
390
391 FOREACH_SA(sa) {
392 if (sa->serial_number == num)
393 return sa;
394 }
395 return 0;
396 }
397
398 /*
399 * creates a new IKE_SA
400 * if initiator_spi is NULL, creates an initiator SA
401 * if initiator_spi is non-NULL, creates a responder SA, remembers initiator_spi
402 */
403 struct ikev2_sa *
404 ikev2_allocate_sa(isakmp_cookie_t *initiator_spi, struct sockaddr *local,
405 struct sockaddr *remote, struct rcf_remote *conf)
406 {
407 struct ikev2_sa *sa;
408 extern void ikev2_verified(struct verified_info *);
409 extern void ikev2_timeout(struct transmit_info *);
410 static int serial_number = 0;
411
412 TRACE((PLOGLOC, "ikev2_create_sa(%p, %s, %s, %p)\n",
413 initiator_spi, rcs_sa2str(local), rcs_sa2str(remote), conf));
414
415 sa = racoon_calloc(1, sizeof(struct ikev2_sa));
416 TRACE((PLOGLOC, "sa: %p\n", sa));
417 if (!sa)
418 goto fail;
419 if (initiator_spi) {
420 rc_vchar_t *r;
421 memcpy(sa->index.i_ck, initiator_spi, sizeof(isakmp_cookie_t));
422 r = random_bytes(sizeof(isakmp_cookie_t));
423 if (!r)
424 goto fail;
425 memcpy(sa->index.r_ck, r->v, sizeof(isakmp_cookie_t));
426 rc_vfree(r);
427 } else {
428 rc_vchar_t *r;
429 sa->is_initiator = TRUE;
430 r = random_bytes(sizeof(isakmp_cookie_t));
431 if (!r)
432 goto fail;
433 memcpy(sa->index.i_ck, r->v, sizeof(isakmp_cookie_t));
434 rc_vfree(r);
435 }
436 sa->serial_number = ++serial_number;
437 sa->version = IKEV2_VERSION;
438 sa->state = IKEV2_STATE_IDLING;
439 if (local) {
440 sa->local = rcs_sadup(local);
441 if (!sa->local)
442 goto fail;
443 }
444 if (remote) {
445 sa->remote = rcs_sadup(remote);
446 if (!sa->remote)
447 goto fail;
448 }
449
450 IKEV2_CHILD_LIST_INIT(&sa->children);
451
452 sa->verified_info.is_initiator = sa->is_initiator;
453 sa->verified_info.verify = ikev2_verify;
454 sa->verified_info.verified_callback = ikev2_verified;
455 sa->verified_info.callback_param = (void *)sa;
456
457 sa->transmit_info.timeout_callback = ikev2_timeout;
458 sa->transmit_info.callback_param = (void *)sa;
459
460 sa->response_info.timeout_callback = 0;
461 sa->response_info.callback_param = (void *)0;
462 sa->response_info.times_per_send = 1;
463
464 sa->lifetime_byte = 0;
465
466 SCHED_INIT(sa->expire_timer);
467 SCHED_INIT(sa->soft_expire_timer);
468 SCHED_INIT(sa->grace_timer);
469 SCHED_INIT(sa->polling_timer);
470 SCHED_INIT(sa->natk_timer);
471
472 ikev2_set_rmconf(sa, conf);
473
474 ikev2_sa_start_nego_timer(sa);
475
476 /* if this is responder, increment half-open sa counter */
477 if (initiator_spi)
478 ++ikev2_half_open_sa;
479
480 return sa;
481
482 fail:
483 if (sa)
484 racoon_free(sa);
485 return 0;
486 }
487
488 struct ikev2_sa *
489 ikev2_create_sa(isakmp_cookie_t *initiator_spi, struct sockaddr *local,
490 struct sockaddr *remote, struct rcf_remote *conf)
491 {
492 struct ikev2_sa *sa;
493
494 sa = ikev2_allocate_sa(initiator_spi, local, remote, conf);
495 if (!sa)
496 return 0;
497 ikev2_sa_insert(sa);
498
499 return sa;
500 }
501
502 static void ikev2_negotiation_timeout_callback(void *);
503
504 void
505 ikev2_sa_start_nego_timer(struct ikev2_sa *sa)
506 {
507 int time_limit;
508
509 time_limit = ikev2_kmp_sa_nego_time_limit(sa->rmconf);
510 sa->expire_timer =
511 sched_new(time_limit, ikev2_negotiation_timeout_callback, sa);
512 }
513
514 static void
515 ikev2_negotiation_timeout_callback(void *param)
516 {
517 struct ikev2_sa *sa;
518
519 sa = (struct ikev2_sa *)param;
520 SCHED_KILL(sa->expire_timer);
521 ikev2_abort(sa, ETIMEDOUT);
522 }
523
524 static void ikev2_sa_lifetime_callback(void *);
525 static void ikev2_sa_lifetime_soft_callback(void *);
526
527 void
528 ikev2_sa_start_lifetime_timer(struct ikev2_sa *sa)
529 {
530 int time_limit;
531 int lifetime_soft;
532
533 time_limit = ikev2_kmp_sa_lifetime_time(sa->rmconf);
534 if (sa->due_time.tv_sec > 0) {
535 struct timeval now, diff;
536 gettimeofday(&now, 0);
537 if (sa->due_time.tv_sec <= now.tv_sec) {
538 isakmp_log(sa, 0, 0, 0,
539 PLOG_INTERR, PLOGLOC,
540 "certificate expired already\n");
541 ikev2_sa_expire(sa, TRUE);
542 time_limit = 0;
543 } else {
544 timersub(&sa->due_time, &now, &diff);
545 if (time_limit == 0 || diff.tv_sec < time_limit) {
546 isakmp_log(sa, 0, 0, 0,
547 PLOG_INTWARN, PLOGLOC,
548 "certificate expiration is earlier than life time\n");
549 time_limit = diff.tv_sec;
550 }
551 }
552 }
553 TRACE((PLOGLOC, "lifetime: %d\n", time_limit));
554 if (time_limit > 0) {
555 sa->expire_timer =
556 sched_new(time_limit, ikev2_sa_lifetime_callback, sa);
557 if (!sa->expire_timer)
558 goto fail_nomem;
559 lifetime_soft = time_limit * (ikev2_lifetime_soft_factor +
560 ikev2_lifetime_soft_jitter *
561 ((double)eay_random_uint32() /
562 UINT32_MAX));
563 TRACE((PLOGLOC, "lifetime_soft: %d\n", lifetime_soft));
564 sa->soft_expire_timer =
565 sched_new(lifetime_soft,
566 ikev2_sa_lifetime_soft_callback, sa);
567 if (!sa->soft_expire_timer)
568 goto fail_nomem;
569 }
570 return;
571
572 fail_nomem:
573 return;
574 }
575
576 static void
577 ikev2_sa_lifetime_callback(void *param)
578 {
579 struct ikev2_sa *ike_sa;
580 struct ikev2_child_sa *child_sa;
581
582 ike_sa = (struct ikev2_sa *)param;
583 TRACE((PLOGLOC, "lifetime expired %p\n", ike_sa));
584 SCHED_KILL(ike_sa->expire_timer);
585 ikev2_sa_expire(ike_sa, TRUE);
586 child_sa = ikev2_choose_pending_child(ike_sa, TRUE);
587 if (child_sa)
588 ikev2_wakeup_child_sa(child_sa);
589 }
590
591 static void
592 ikev2_sa_lifetime_soft_callback(void *param)
593 {
594 struct ikev2_sa *ike_sa;
595 struct ikev2_child_sa *child_sa;
596
597 ike_sa = (struct ikev2_sa *)param;
598 TRACE((PLOGLOC, "soft lifetime expired %p\n", ike_sa));
599 SCHED_KILL(ike_sa->soft_expire_timer);
600 ike_sa->soft_expired = TRUE;
601 if (ike_sa->child_created > 0 && !ike_sa->rekey_inprogress)
602 ikev2_rekey_ikesa_initiate(ike_sa);
603 child_sa = ikev2_choose_pending_child(ike_sa, TRUE);
604 if (child_sa)
605 ikev2_wakeup_child_sa(child_sa);
606 }
607
608 static void ikev2_sa_grace_period_callback(void *);
609
610 void
611 ikev2_sa_start_grace_period(struct ikev2_sa *sa)
612 {
613 int grace_period;
614
615 grace_period = ikev2_kmp_sa_grace_period(sa->rmconf);
616 if (grace_period <= 0)
617 return;
618 sa->grace_timer =
619 sched_new(grace_period, ikev2_sa_grace_period_callback, sa);
620 }
621
622 void
623 ikev2_sa_stop_grace_timer(struct ikev2_sa *sa)
624 {
625 if (sa->grace_timer)
626 SCHED_KILL(sa->grace_timer);
627 }
628
629 static void
630 ikev2_sa_grace_period_callback(void *param)
631 {
632 struct ikev2_sa *ike_sa;
633 struct ikev2_child_sa *child_sa;
634
635 ike_sa = (struct ikev2_sa *)param;
636 TRACE((PLOGLOC, "grace period expired %p\n", ike_sa));
637 SCHED_KILL(ike_sa->grace_timer);
638 ikev2_sa_expire(ike_sa, TRUE);
639 child_sa = ikev2_choose_pending_child(ike_sa, TRUE);
640 if (child_sa)
641 ikev2_wakeup_child_sa(child_sa);
642 }
643
644 void
645 ikev2_sa_expire(struct ikev2_sa *ike_sa, int send_delete)
646 {
647 struct ikev2_child_sa *child_sa;
648
649 TRACE((PLOGLOC, "expire ikev2_sa %p\n", ike_sa));
650
651 switch (ike_sa->state) {
652 case IKEV2_STATE_INI_IKE_SA_INIT_SENT:
653 case IKEV2_STATE_RES_IKE_SA_INIT_SENT:
654 case IKEV2_STATE_INI_IKE_AUTH_SENT:
655 case IKEV2_STATE_RES_IKE_AUTH_RCVD:
656 case IKEV2_STATE_INI_IKE_AUTH_RCVD:
657 isakmp_log(ike_sa, 0, 0, 0,
658 PLOG_INTERR, PLOGLOC, "ike_sa expired\n");
659 ikev2_abort(ike_sa, ETIMEDOUT);
660 break;
661 case IKEV2_STATE_ESTABLISHED:
662 if (ike_sa->child_created > 0) {
663 if (!ike_sa->rekey_inprogress)
664 ikev2_rekey_ikesa_initiate(ike_sa);
665 } else {
666 /* (draft-17)
667 * Closing the IKE_SA implicitly closes all associated CHILD_SAs.
668 */
669 for (child_sa =
670 IKEV2_CHILD_LIST_FIRST(&ike_sa->children);
671 !IKEV2_CHILD_LIST_END(child_sa);
672 child_sa = IKEV2_CHILD_LIST_NEXT(child_sa)) {
673 if (child_sa->state == IKEV2_CHILD_STATE_MATURE) {
674 ikev2_child_delete_ipsecsa(child_sa);
675 ikev2_child_state_set(child_sa,
676 IKEV2_CHILD_STATE_EXPIRED);
677 }
678 }
679
680 if (send_delete)
681 ikev2_sa_delete(ike_sa);
682 }
683 ikev2_set_state(ike_sa, IKEV2_STATE_DYING);
684 break;
685 case IKEV2_STATE_DYING:
686 ikev2_set_state(ike_sa, IKEV2_STATE_DEAD);
687 break;
688 case IKEV2_STATE_DEAD:
689 break;
690 default:
691 TRACE((PLOGLOC, "state: %d\n", ike_sa->state));
692 break;
693 }
694 }
695
696 static void ikev2_sa_delete_callback(enum request_callback,
697 struct ikev2_child_sa *, void *);
698
699 void
700 ikev2_sa_delete(struct ikev2_sa *sa)
701 {
702 struct ikev2_payloads *payl;
703
704 TRACE((PLOGLOC, "initiating DELETE IKE_SA\n"));
705 payl = racoon_malloc(sizeof(struct ikev2_payloads));
706 ikev2_payloads_init(payl);
707 ikev2_payloads_push(payl,
708 IKEV2_PAYLOAD_DELETE,
709 ikev2_delete_payload(IKEV2_DELETE_PROTO_IKE, 0, 0,
710 0), TRUE);
711 (void)ikev2_request_initiator_start(sa, ikev2_sa_delete_callback, payl);
712 }
713
714 static void
715 ikev2_sa_delete_callback(enum request_callback action,
716 struct ikev2_child_sa *child_sa, void *data)
717 {
718 TRACE((PLOGLOC,
719 "ikev2_sa_delete_callback(%d, %p, %p)\n", action, child_sa,
720 data));
721 switch (action) {
722 case REQUEST_CALLBACK_CONTINUE:
723 ikev2_informational_initiator_transmit(child_sa->parent,
724 child_sa,
725 (struct ikev2_payloads *)
726 data);
727 break;
728 case REQUEST_CALLBACK_TRANSMIT_ERROR:
729 /* none here */
730 break;
731 case REQUEST_CALLBACK_RESPONSE:
732 ikev2_info_init_delete_recv(child_sa, (rc_vchar_t *)data);
733 ikev2_set_state(child_sa->parent, IKEV2_STATE_DEAD);
734 break;
735 default:
736 isakmp_log(child_sa->parent, 0, 0, 0,
737 PLOG_INTERR, PLOGLOC,
738 "unknown action code %d\n", (int)action);
739 break;
740 }
741 }
742
743 void
744 ikev2_sa_stop_timer(struct ikev2_sa *sa)
745 {
746 if (sa->expire_timer)
747 SCHED_KILL(sa->expire_timer);
748 if (sa->soft_expire_timer)
749 SCHED_KILL(sa->soft_expire_timer);
750 if (sa->grace_timer)
751 SCHED_KILL(sa->grace_timer);
752 }
753
754 /* shut down all IKE_SA by sending DELETE */
755 static void ikev2_shutdown_sa(struct ikev2_sa *ike_sa);
756
757 void
758 ikev2_shutdown(void)
759 {
760 struct ikev2_sa *ike_sa;
761
762 FOREACH_SA(ike_sa) {
763 ikev2_shutdown_sa(ike_sa);
764 }
765 }
766
767 static void
768 ikev2_shutdown_sa(struct ikev2_sa *ike_sa)
769 {
770 struct ikev2_child_sa *child_sa;
771
772 TRACE((PLOGLOC, "shutdown ikev2_sa %p state %d\n",
773 ike_sa, ike_sa->state));
774
775 switch (ike_sa->state) {
776 case IKEV2_STATE_INI_IKE_SA_INIT_SENT:
777 case IKEV2_STATE_RES_IKE_SA_INIT_SENT:
778 case IKEV2_STATE_INI_IKE_AUTH_SENT:
779 case IKEV2_STATE_RES_IKE_AUTH_RCVD:
780 case IKEV2_STATE_INI_IKE_AUTH_RCVD:
781 ikev2_abort(ike_sa, ETIMEDOUT);
782 break;
783 case IKEV2_STATE_ESTABLISHED:
784 ikev2_set_state(ike_sa, IKEV2_STATE_DYING);
785 for (child_sa = IKEV2_CHILD_LIST_FIRST(&ike_sa->children);
786 !IKEV2_CHILD_LIST_END(child_sa);
787 child_sa = IKEV2_CHILD_LIST_NEXT(child_sa)) {
788 if (child_sa->state == IKEV2_CHILD_STATE_MATURE) {
789 ikev2_child_delete_ipsecsa(child_sa);
790 ikev2_child_state_set(child_sa,
791 IKEV2_CHILD_STATE_EXPIRED);
792 }
793 }
794 ikev2_sa_delete(ike_sa);
795 break;
796 case IKEV2_STATE_DYING:
797 ikev2_set_state(ike_sa, IKEV2_STATE_DEAD);
798 break;
799 case IKEV2_STATE_DEAD:
800 break;
801 default:
802 TRACE((PLOGLOC, "state: %d\n", ike_sa->state));
803 break;
804 }
805 }
806
807 static void ikev2_poll_timer_callback(void *);
808
809 void
810 ikev2_sa_start_polling_timer(struct ikev2_sa *sa)
811 {
812 int interval;
813
814 if (sa->polling_timer)
815 SCHED_KILL(sa->polling_timer);
816
817 interval = ikev2_dpd_interval(sa->rmconf);
818 TRACE((PLOGLOC, "dpd polling interval %d\n", interval));
819 if (interval > 0)
820 sa->polling_timer =
821 sched_new(interval, ikev2_poll_timer_callback, sa);
822 }
823
824 static void
825 ikev2_poll_timer_callback(void *param)
826 {
827 struct ikev2_sa *sa;
828
829 sa = (struct ikev2_sa *)param;
830 SCHED_KILL(sa->polling_timer);
831 if (sa->state == IKEV2_STATE_ESTABLISHED)
832 ikev2_poll(sa);
833 }
834
835 void
836 ikev2_dispose_sa(struct ikev2_sa *sa)
837 {
838 TRACE((PLOGLOC, "ikev2_dispose_sa(%p)\n", sa));
839
840 /* remove from sa list in advance */
841 /* ikev2_sa_remove(sa); */
842
843 assert(IKEV2_CHILD_LIST_EMPTY(&sa->children));
844
845 if (sa->new_sa)
846 ikev2_dispose_sa(sa->new_sa);
847
848 if (sa->expire_timer)
849 SCHED_KILL(sa->expire_timer);
850 if (sa->soft_expire_timer)
851 SCHED_KILL(sa->soft_expire_timer);
852 if (sa->grace_timer)
853 SCHED_KILL(sa->grace_timer);
854 if (sa->polling_timer)
855 SCHED_KILL(sa->polling_timer);
856 if (sa->natk_timer)
857 SCHED_KILL(sa->natk_timer);
858
859 if (sa->rmconf)
860 rcf_free_remote(sa->rmconf);
861
862 if (sa->negotiated_sa)
863 racoon_free(sa->negotiated_sa);
864
865 if (sa->prf)
866 keyed_hash_dispose(sa->prf);
867
868 if (sa->n_i)
869 rc_vfree(sa->n_i);
870 if (sa->n_r)
871 rc_vfree(sa->n_r);
872 if (sa->dhpriv)
873 rc_vfreez(sa->dhpriv);
874 if (sa->dhpub)
875 rc_vfree(sa->dhpub);
876 if (sa->dhpub_p)
877 rc_vfree(sa->dhpub_p);
878 if (sa->skeyseed)
879 rc_vfreez(sa->skeyseed);
880 if (sa->sk_d)
881 rc_vfreez(sa->sk_d);
882 if (sa->sk_a_i)
883 rc_vfreez(sa->sk_a_i);
884 if (sa->sk_a_r)
885 rc_vfreez(sa->sk_a_r);
886 if (sa->sk_e_i)
887 rc_vfreez(sa->sk_e_i);
888 if (sa->sk_e_r)
889 rc_vfreez(sa->sk_e_r);
890 if (sa->sk_p_i)
891 rc_vfreez(sa->sk_p_i);
892 if (sa->sk_p_r)
893 rc_vfreez(sa->sk_p_r);
894 if (sa->id_i)
895 rc_vfree(sa->id_i);
896 if (sa->id_r)
897 rc_vfree(sa->id_r);
898 if (sa->my_first_message)
899 rc_vfree(sa->my_first_message);
900 if (sa->peer_first_message)
901 rc_vfree(sa->peer_first_message);
902 if (sa->encryptor)
903 encryptor_destroy(sa->encryptor);
904 if (sa->authenticator)
905 auth_destroy(sa->authenticator);
906
907 if (sa->verified_info.packet)
908 rc_vfree(sa->verified_info.packet);
909
910 if (sa->transmit_info.packet)
911 rc_vfree(sa->transmit_info.packet);
912 if (sa->transmit_info.timer)
913 SCHED_KILL(sa->transmit_info.timer);
914 if (sa->response_info.packet)
915 rc_vfree(sa->response_info.packet);
916 if (sa->response_info.timer)
917 SCHED_KILL(sa->response_info.timer);
918
919 if (sa->local)
920 rc_free(sa->local);
921 if (sa->remote)
922 rc_free(sa->remote);
923
924 racoon_free(sa);
925 }
926
927 /*
928 * set ike_sa->encryptor, authenticator, prf according to negotiated_sa
929 * (negotiated_sa may be equal to ike_sa->negotiated_sa)
930 * returns 0 if successful, non-0 otherwise
931 */
932 int
933 ikev2_set_negotiated_sa(struct ikev2_sa *ike_sa,
934 struct ikev2_isakmpsa *negotiated_sa)
935 {
936 struct encryptor *encryptor = 0;
937 struct authenticator *authenticator = 0;
938 struct keyed_hash *prf = 0;
939
940 TRACE((PLOGLOC, "ikev2_set_negotiated_sa(%p, %p)\n", ike_sa,
941 negotiated_sa));
942 assert(!ike_sa->encryptor && !ike_sa->authenticator && !ike_sa->prf);
943
944 encryptor = ikev2_encryptor_new(negotiated_sa->encr,
945 negotiated_sa->encrklen);
946 if (!encryptor) {
947 isakmp_log(ike_sa, 0, 0, 0,
948 PLOG_INTERR, PLOGLOC,
949 "failed creating ike_sa encryptor\n");
950 goto fail;
951 }
952 authenticator = ikev2_authenticator_new(negotiated_sa->integr);
953 if (!authenticator) {
954 isakmp_log(ike_sa, 0, 0, 0,
955 PLOG_INTERR, PLOGLOC,
956 "failed creating ike_sa authenticator\n");
957 goto fail;
958 }
959 prf = ikev2_prf_new(negotiated_sa->prf);
960 if (!prf)
961 goto fail;
962
963 ike_sa->negotiated_sa = negotiated_sa;
964 ike_sa->encryptor = encryptor;
965 ike_sa->authenticator = authenticator;
966 ike_sa->prf = prf;
967 return 0;
968
969 fail:
970 if (encryptor)
971 encryptor_destroy(encryptor);
972 if (authenticator)
973 auth_destroy(authenticator);
974 if (prf)
975 keyed_hash_dispose(prf);
976 return -1;
977 }
978
979 void
980 ikev2_set_rmconf(struct ikev2_sa *sa, struct rcf_remote *conf)
981 {
982 if (sa->rmconf)
983 rcf_free_remote(sa->rmconf);
984
985 sa->rmconf = conf;
986
987 sa->transmit_info.retry_limit = ikev2_max_retry_to_send(conf);
988 sa->transmit_info.times_per_send = ikev2_times_per_send(conf);
989 sa->transmit_info.interval_to_send = ikev2_interval_to_send(conf);
990 if (sa->transmit_info.interval_to_send > 100000) /* XXX */
991 sa->transmit_info.interval_to_send = 100000;
992 }
993
994 struct contact_list {
995 rc_vchar_t *remote_index;
996 struct contact_list *next;
997 };
998
999 struct contact_list *contacted_list = 0;
1000
1001 int
1002 ikev2_send_initial_contact(struct ikev2_sa *ike_sa)
1003 {
1004 struct contact_list *peer;
1005 struct contact_list *c;
1006
1007 for (peer = contacted_list; peer; peer = peer->next) {
1008 if (rc_vmemcmp(peer->remote_index, ike_sa->rmconf->rm_index) == 0)
1009 return FALSE;
1010 }
1011
1012 c = racoon_malloc(sizeof(struct contact_list));
1013 if (!c)
1014 return FALSE;
1015
1016 c->remote_index = rc_vdup(ike_sa->rmconf->rm_index);
1017 c->next = contacted_list;
1018 contacted_list = c;
1019
1020 return TRUE;
1021 }