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 param.satype = RCT_SATYPE_ESP; /* XXX */
301 param.seq = child_sa->sadb_request.seqno;
302 param.eno = err;
303 child_sa->sadb_request.method->acquire_error(¶m);
304
305 ikev2_child_state_set(child_sa, IKEV2_CHILD_STATE_EXPIRED);
306 ++isakmpstat.child_abort;
307 }
308
309 /*
310 * find ike_sa by ike message spi
311 */
312 struct ikev2_sa *
313 ikev2_find_sa(rc_vchar_t *message)
314 {
315 struct ikev2_header *ikehdr;
316 isakmp_cookie_t *spi_i;
317 isakmp_cookie_t *spi_r;
318 int is_response;
319 int remote_is_initiator;
320 struct ikev2_sa *sa;
321
322 ikehdr = (struct ikev2_header *)message->v;
323
324 spi_i = &ikehdr->initiator_spi;
325 spi_r = &ikehdr->responder_spi;
326 is_response = (ikehdr->flags & IKEV2FLAG_RESPONSE) != 0;
327 remote_is_initiator = (ikehdr->flags & IKEV2FLAG_INITIATOR) != 0;
328
329 FOREACH_SA(sa) {
330 if (!remote_is_initiator && sa->is_initiator) {
331 if (memcmp(spi_i, &sa->index.i_ck,
332 sizeof(isakmp_cookie_t)) == 0)
333 return sa;
334 } else if (remote_is_initiator && !sa->is_initiator) {
335 /* retransmission of IKE_SA_INIT requests? */
336 if (ikehdr->exchange_type == IKEV2EXCH_IKE_SA_INIT &&
337 !is_response) {
338 if (memcmp(spi_i, &sa->index.i_ck,
339 sizeof(isakmp_cookie_t)) == 0 &&
340 sa->peer_first_message &&
341 message->l == sa->peer_first_message->l &&
342 memcmp(message->v,
343 sa->peer_first_message->v,
344 message->l) == 0)
345 return sa;
346 } else {
347 if (memcmp(spi_i, &sa->index.i_ck,
348 sizeof(isakmp_cookie_t)) == 0 &&
349 memcmp(spi_r, &sa->index.r_ck,
350 sizeof(isakmp_cookie_t)) == 0)
351 return sa;
352 }
353 }
354 }
355
356 return 0;
357 }
358
359 /*
360 * find ike_sa by addr
361 */
362 struct ikev2_sa *
363 ikev2_find_sa_by_addr(struct sockaddr *addr)
364 {
365 struct ikev2_sa *sa;
366 struct ikev2_sa *candidate = 0;
367
368 FOREACH_SA(sa) {
369 if (rcs_cmpsa_wop(sa->remote, addr) == 0) {
370 switch (sa->state) {
371 case IKEV2_STATE_ESTABLISHED:
372 return sa;
373 case IKEV2_STATE_DYING:
374 case IKEV2_STATE_DEAD:
375 break;
376 default:
377 candidate = sa;
378 break;
379 }
380 }
381 }
382 return candidate;
383 }
384
385 struct ikev2_sa *
386 ikev2_find_sa_by_serial(int num)
387 {
388 struct ikev2_sa *sa;
389
390 FOREACH_SA(sa) {
391 if (sa->serial_number == num)
392 return sa;
393 }
394 return 0;
395 }
396
397 /*
398 * creates a new IKE_SA
399 * if initiator_spi is NULL, creates an initiator SA
400 * if initiator_spi is non-NULL, creates a responder SA, remembers initiator_spi
401 */
402 struct ikev2_sa *
403 ikev2_allocate_sa(isakmp_cookie_t *initiator_spi, struct sockaddr *local,
404 struct sockaddr *remote, struct rcf_remote *conf)
405 {
406 struct ikev2_sa *sa;
407 extern void ikev2_verified(struct verified_info *);
408 extern void ikev2_timeout(struct transmit_info *);
409 static int serial_number = 0;
410
411 TRACE((PLOGLOC, "ikev2_create_sa(%p, %s, %s, %p)\n",
412 initiator_spi, rcs_sa2str(local), rcs_sa2str(remote), conf));
413
414 sa = racoon_calloc(1, sizeof(struct ikev2_sa));
415 TRACE((PLOGLOC, "sa: %p\n", sa));
416 if (!sa)
417 goto fail;
418 if (initiator_spi) {
419 rc_vchar_t *r;
420 memcpy(sa->index.i_ck, initiator_spi, sizeof(isakmp_cookie_t));
421 r = random_bytes(sizeof(isakmp_cookie_t));
422 if (!r)
423 goto fail;
424 memcpy(sa->index.r_ck, r->v, sizeof(isakmp_cookie_t));
425 rc_vfree(r);
426 } else {
427 rc_vchar_t *r;
428 sa->is_initiator = TRUE;
429 r = random_bytes(sizeof(isakmp_cookie_t));
430 if (!r)
431 goto fail;
432 memcpy(sa->index.i_ck, r->v, sizeof(isakmp_cookie_t));
433 rc_vfree(r);
434 }
435 sa->serial_number = ++serial_number;
436 sa->version = IKEV2_VERSION;
437 sa->state = IKEV2_STATE_IDLING;
438 if (local) {
439 sa->local = rcs_sadup(local);
440 if (!sa->local)
441 goto fail;
442 }
443 if (remote) {
444 sa->remote = rcs_sadup(remote);
445 if (!sa->remote)
446 goto fail;
447 }
448
449 IKEV2_CHILD_LIST_INIT(&sa->children);
450
451 sa->verified_info.is_initiator = sa->is_initiator;
452 sa->verified_info.verify = ikev2_verify;
453 sa->verified_info.verified_callback = ikev2_verified;
454 sa->verified_info.callback_param = (void *)sa;
455
456 sa->transmit_info.timeout_callback = ikev2_timeout;
457 sa->transmit_info.callback_param = (void *)sa;
458
459 sa->response_info.timeout_callback = 0;
460 sa->response_info.callback_param = (void *)0;
461 sa->response_info.times_per_send = 1;
462
463 sa->lifetime_byte = 0;
464
465 SCHED_INIT(sa->expire_timer);
466 SCHED_INIT(sa->soft_expire_timer);
467 SCHED_INIT(sa->grace_timer);
468 SCHED_INIT(sa->polling_timer);
469 SCHED_INIT(sa->natk_timer);
470
471 ikev2_set_rmconf(sa, conf);
472
473 ikev2_sa_start_nego_timer(sa);
474
475 /* if this is responder, increment half-open sa counter */
476 if (initiator_spi)
477 ++ikev2_half_open_sa;
478
479 return sa;
480
481 fail:
482 if (sa)
483 racoon_free(sa);
484 return 0;
485 }
486
487 struct ikev2_sa *
488 ikev2_create_sa(isakmp_cookie_t *initiator_spi, struct sockaddr *local,
489 struct sockaddr *remote, struct rcf_remote *conf)
490 {
491 struct ikev2_sa *sa;
492
493 sa = ikev2_allocate_sa(initiator_spi, local, remote, conf);
494 if (!sa)
495 return 0;
496 ikev2_sa_insert(sa);
497
498 return sa;
499 }
500
501 static void ikev2_negotiation_timeout_callback(void *);
502
503 void
504 ikev2_sa_start_nego_timer(struct ikev2_sa *sa)
505 {
506 int time_limit;
507
508 time_limit = ikev2_kmp_sa_nego_time_limit(sa->rmconf);
509 sa->expire_timer =
510 sched_new(time_limit, ikev2_negotiation_timeout_callback, sa);
511 }
512
513 static void
514 ikev2_negotiation_timeout_callback(void *param)
515 {
516 struct ikev2_sa *sa;
517
518 sa = (struct ikev2_sa *)param;
519 SCHED_KILL(sa->expire_timer);
520 ikev2_abort(sa, ETIMEDOUT);
521 }
522
523 static void ikev2_sa_lifetime_callback(void *);
524 static void ikev2_sa_lifetime_soft_callback(void *);
525
526 void
527 ikev2_sa_start_lifetime_timer(struct ikev2_sa *sa)
528 {
529 int time_limit;
530 int lifetime_soft;
531
532 time_limit = ikev2_kmp_sa_lifetime_time(sa->rmconf);
533 if (sa->due_time.tv_sec > 0) {
534 struct timeval now, diff;
535 gettimeofday(&now, 0);
536 if (sa->due_time.tv_sec <= now.tv_sec) {
537 isakmp_log(sa, 0, 0, 0,
538 PLOG_INTERR, PLOGLOC,
539 "certificate expired already\n");
540 ikev2_sa_expire(sa, TRUE);
541 time_limit = 0;
542 } else {
543 timersub(&sa->due_time, &now, &diff);
544 if (time_limit == 0 || diff.tv_sec < time_limit) {
545 isakmp_log(sa, 0, 0, 0,
546 PLOG_INTWARN, PLOGLOC,
547 "certificate expiration is earlier than life time\n");
548 time_limit = diff.tv_sec;
549 }
550 }
551 }
552 TRACE((PLOGLOC, "lifetime: %d\n", time_limit));
553 if (time_limit > 0) {
554 sa->expire_timer =
555 sched_new(time_limit, ikev2_sa_lifetime_callback, sa);
556 if (!sa->expire_timer)
557 goto fail_nomem;
558 lifetime_soft = time_limit * (ikev2_lifetime_soft_factor +
559 ikev2_lifetime_soft_jitter *
560 ((double)eay_random_uint32() /
561 UINT32_MAX));
562 TRACE((PLOGLOC, "lifetime_soft: %d\n", lifetime_soft));
563 sa->soft_expire_timer =
564 sched_new(lifetime_soft,
565 ikev2_sa_lifetime_soft_callback, sa);
566 if (!sa->soft_expire_timer)
567 goto fail_nomem;
568 }
569 return;
570
571 fail_nomem:
572 return;
573 }
574
575 static void
576 ikev2_sa_lifetime_callback(void *param)
577 {
578 struct ikev2_sa *ike_sa;
579 struct ikev2_child_sa *child_sa;
580
581 ike_sa = (struct ikev2_sa *)param;
582 TRACE((PLOGLOC, "lifetime expired %p\n", ike_sa));
583 SCHED_KILL(ike_sa->expire_timer);
584 ikev2_sa_expire(ike_sa, TRUE);
585 child_sa = ikev2_choose_pending_child(ike_sa, TRUE);
586 if (child_sa)
587 ikev2_wakeup_child_sa(child_sa);
588 }
589
590 static void
591 ikev2_sa_lifetime_soft_callback(void *param)
592 {
593 struct ikev2_sa *ike_sa;
594 struct ikev2_child_sa *child_sa;
595
596 ike_sa = (struct ikev2_sa *)param;
597 TRACE((PLOGLOC, "soft lifetime expired %p\n", ike_sa));
598 SCHED_KILL(ike_sa->soft_expire_timer);
599 ike_sa->soft_expired = TRUE;
600 if (ike_sa->child_created > 0 && !ike_sa->rekey_inprogress)
601 ikev2_rekey_ikesa_initiate(ike_sa);
602 child_sa = ikev2_choose_pending_child(ike_sa, TRUE);
603 if (child_sa)
604 ikev2_wakeup_child_sa(child_sa);
605 }
606
607 static void ikev2_sa_grace_period_callback(void *);
608
609 void
610 ikev2_sa_start_grace_period(struct ikev2_sa *sa)
611 {
612 int grace_period;
613
614 grace_period = ikev2_kmp_sa_grace_period(sa->rmconf);
615 if (grace_period <= 0)
616 return;
617 sa->grace_timer =
618 sched_new(grace_period, ikev2_sa_grace_period_callback, sa);
619 }
620
621 void
622 ikev2_sa_stop_grace_timer(struct ikev2_sa *sa)
623 {
624 if (sa->grace_timer)
625 SCHED_KILL(sa->grace_timer);
626 }
627
628 static void
629 ikev2_sa_grace_period_callback(void *param)
630 {
631 struct ikev2_sa *ike_sa;
632 struct ikev2_child_sa *child_sa;
633
634 ike_sa = (struct ikev2_sa *)param;
635 TRACE((PLOGLOC, "grace period expired %p\n", ike_sa));
636 SCHED_KILL(ike_sa->grace_timer);
637 ikev2_sa_expire(ike_sa, TRUE);
638 child_sa = ikev2_choose_pending_child(ike_sa, TRUE);
639 if (child_sa)
640 ikev2_wakeup_child_sa(child_sa);
641 }
642
643 void
644 ikev2_sa_expire(struct ikev2_sa *ike_sa, int send_delete)
645 {
646 struct ikev2_child_sa *child_sa;
647
648 TRACE((PLOGLOC, "expire ikev2_sa %p\n", ike_sa));
649
650 switch (ike_sa->state) {
651 case IKEV2_STATE_INI_IKE_SA_INIT_SENT:
652 case IKEV2_STATE_RES_IKE_SA_INIT_SENT:
653 case IKEV2_STATE_INI_IKE_AUTH_SENT:
654 case IKEV2_STATE_RES_IKE_AUTH_RCVD:
655 case IKEV2_STATE_INI_IKE_AUTH_RCVD:
656 isakmp_log(ike_sa, 0, 0, 0,
657 PLOG_INTERR, PLOGLOC, "ike_sa expired\n");
658 ikev2_abort(ike_sa, ETIMEDOUT);
659 break;
660 case IKEV2_STATE_ESTABLISHED:
661 if (ike_sa->child_created > 0) {
662 if (!ike_sa->rekey_inprogress)
663 ikev2_rekey_ikesa_initiate(ike_sa);
664 } else {
665 /* (draft-17)
666 * Closing the IKE_SA implicitly closes all associated CHILD_SAs.
667 */
668 for (child_sa =
669 IKEV2_CHILD_LIST_FIRST(&ike_sa->children);
670 !IKEV2_CHILD_LIST_END(child_sa);
671 child_sa = IKEV2_CHILD_LIST_NEXT(child_sa)) {
672 if (child_sa->state == IKEV2_CHILD_STATE_MATURE) {
673 ikev2_child_delete_ipsecsa(child_sa);
674 ikev2_child_state_set(child_sa,
675 IKEV2_CHILD_STATE_EXPIRED);
676 }
677 }
678
679 if (send_delete)
680 ikev2_sa_delete(ike_sa);
681 }
682 ikev2_set_state(ike_sa, IKEV2_STATE_DYING);
683 break;
684 case IKEV2_STATE_DYING:
685 ikev2_set_state(ike_sa, IKEV2_STATE_DEAD);
686 break;
687 case IKEV2_STATE_DEAD:
688 break;
689 default:
690 TRACE((PLOGLOC, "state: %d\n", ike_sa->state));
691 break;
692 }
693 }
694
695 static void ikev2_sa_delete_callback(enum request_callback,
696 struct ikev2_child_sa *, void *);
697
698 void
699 ikev2_sa_delete(struct ikev2_sa *sa)
700 {
701 struct ikev2_payloads *payl;
702
703 TRACE((PLOGLOC, "initiating DELETE IKE_SA\n"));
704 payl = racoon_malloc(sizeof(struct ikev2_payloads));
705 ikev2_payloads_init(payl);
706 ikev2_payloads_push(payl,
707 IKEV2_PAYLOAD_DELETE,
708 ikev2_delete_payload(IKEV2_DELETE_PROTO_IKE, 0, 0,
709 0), TRUE);
710 (void)ikev2_request_initiator_start(sa, ikev2_sa_delete_callback, payl);
711 }
712
713 static void
714 ikev2_sa_delete_callback(enum request_callback action,
715 struct ikev2_child_sa *child_sa, void *data)
716 {
717 TRACE((PLOGLOC,
718 "ikev2_sa_delete_callback(%d, %p, %p)\n", action, child_sa,
719 data));
720 switch (action) {
721 case REQUEST_CALLBACK_CONTINUE:
722 ikev2_informational_initiator_transmit(child_sa->parent,
723 child_sa,
724 (struct ikev2_payloads *)
725 data);
726 break;
727 case REQUEST_CALLBACK_TRANSMIT_ERROR:
728 /* none here */
729 break;
730 case REQUEST_CALLBACK_RESPONSE:
731 ikev2_info_init_delete_recv(child_sa, (rc_vchar_t *)data);
732 ikev2_set_state(child_sa->parent, IKEV2_STATE_DEAD);
733 break;
734 default:
735 isakmp_log(child_sa->parent, 0, 0, 0,
736 PLOG_INTERR, PLOGLOC,
737 "unknown action code %d\n", (int)action);
738 break;
739 }
740 }
741
742 void
743 ikev2_sa_stop_timer(struct ikev2_sa *sa)
744 {
745 if (sa->expire_timer)
746 SCHED_KILL(sa->expire_timer);
747 if (sa->soft_expire_timer)
748 SCHED_KILL(sa->soft_expire_timer);
749 if (sa->grace_timer)
750 SCHED_KILL(sa->grace_timer);
751 }
752
753 /* shut down all IKE_SA by sending DELETE */
754 static void ikev2_shutdown_sa(struct ikev2_sa *ike_sa);
755
756 void
757 ikev2_shutdown(void)
758 {
759 struct ikev2_sa *ike_sa;
760
761 FOREACH_SA(ike_sa) {
762 ikev2_shutdown_sa(ike_sa);
763 }
764 }
765
766 static void
767 ikev2_shutdown_sa(struct ikev2_sa *ike_sa)
768 {
769 struct ikev2_child_sa *child_sa;
770
771 TRACE((PLOGLOC, "shutdown ikev2_sa %p state %d\n",
772 ike_sa, ike_sa->state));
773
774 switch (ike_sa->state) {
775 case IKEV2_STATE_INI_IKE_SA_INIT_SENT:
776 case IKEV2_STATE_RES_IKE_SA_INIT_SENT:
777 case IKEV2_STATE_INI_IKE_AUTH_SENT:
778 case IKEV2_STATE_RES_IKE_AUTH_RCVD:
779 case IKEV2_STATE_INI_IKE_AUTH_RCVD:
780 ikev2_abort(ike_sa, ETIMEDOUT);
781 break;
782 case IKEV2_STATE_ESTABLISHED:
783 ikev2_set_state(ike_sa, IKEV2_STATE_DYING);
784 for (child_sa = IKEV2_CHILD_LIST_FIRST(&ike_sa->children);
785 !IKEV2_CHILD_LIST_END(child_sa);
786 child_sa = IKEV2_CHILD_LIST_NEXT(child_sa)) {
787 if (child_sa->state == IKEV2_CHILD_STATE_MATURE) {
788 ikev2_child_delete_ipsecsa(child_sa);
789 ikev2_child_state_set(child_sa,
790 IKEV2_CHILD_STATE_EXPIRED);
791 }
792 }
793 ikev2_sa_delete(ike_sa);
794 break;
795 case IKEV2_STATE_DYING:
796 ikev2_set_state(ike_sa, IKEV2_STATE_DEAD);
797 break;
798 case IKEV2_STATE_DEAD:
799 break;
800 default:
801 TRACE((PLOGLOC, "state: %d\n", ike_sa->state));
802 break;
803 }
804 }
805
806 static void ikev2_poll_timer_callback(void *);
807
808 void
809 ikev2_sa_start_polling_timer(struct ikev2_sa *sa)
810 {
811 int interval;
812
813 if (sa->polling_timer)
814 SCHED_KILL(sa->polling_timer);
815
816 interval = ikev2_dpd_interval(sa->rmconf);
817 TRACE((PLOGLOC, "dpd polling interval %d\n", interval));
818 if (interval > 0)
819 sa->polling_timer =
820 sched_new(interval, ikev2_poll_timer_callback, sa);
821 }
822
823 static void
824 ikev2_poll_timer_callback(void *param)
825 {
826 struct ikev2_sa *sa;
827
828 sa = (struct ikev2_sa *)param;
829 SCHED_KILL(sa->polling_timer);
830 if (sa->state == IKEV2_STATE_ESTABLISHED)
831 ikev2_poll(sa);
832 }
833
834 void
835 ikev2_dispose_sa(struct ikev2_sa *sa)
836 {
837 TRACE((PLOGLOC, "ikev2_dispose_sa(%p)\n", sa));
838
839 /* remove from sa list in advance */
840 /* ikev2_sa_remove(sa); */
841
842 assert(IKEV2_CHILD_LIST_EMPTY(&sa->children));
843
844 if (sa->new_sa)
845 ikev2_dispose_sa(sa->new_sa);
846
847 if (sa->expire_timer)
848 SCHED_KILL(sa->expire_timer);
849 if (sa->soft_expire_timer)
850 SCHED_KILL(sa->soft_expire_timer);
851 if (sa->grace_timer)
852 SCHED_KILL(sa->grace_timer);
853 if (sa->polling_timer)
854 SCHED_KILL(sa->polling_timer);
855 if (sa->natk_timer)
856 SCHED_KILL(sa->natk_timer);
857
858 if (sa->rmconf)
859 rcf_free_remote(sa->rmconf);
860
861 if (sa->negotiated_sa)
862 racoon_free(sa->negotiated_sa);
863
864 if (sa->prf)
865 keyed_hash_dispose(sa->prf);
866
867 if (sa->n_i)
868 rc_vfree(sa->n_i);
869 if (sa->n_r)
870 rc_vfree(sa->n_r);
871 if (sa->dhpriv)
872 rc_vfreez(sa->dhpriv);
873 if (sa->dhpub)
874 rc_vfree(sa->dhpub);
875 if (sa->dhpub_p)
876 rc_vfree(sa->dhpub_p);
877 if (sa->skeyseed)
878 rc_vfreez(sa->skeyseed);
879 if (sa->sk_d)
880 rc_vfreez(sa->sk_d);
881 if (sa->sk_a_i)
882 rc_vfreez(sa->sk_a_i);
883 if (sa->sk_a_r)
884 rc_vfreez(sa->sk_a_r);
885 if (sa->sk_e_i)
886 rc_vfreez(sa->sk_e_i);
887 if (sa->sk_e_r)
888 rc_vfreez(sa->sk_e_r);
889 if (sa->sk_p_i)
890 rc_vfreez(sa->sk_p_i);
891 if (sa->sk_p_r)
892 rc_vfreez(sa->sk_p_r);
893 if (sa->id_i)
894 rc_vfree(sa->id_i);
895 if (sa->id_r)
896 rc_vfree(sa->id_r);
897 if (sa->my_first_message)
898 rc_vfree(sa->my_first_message);
899 if (sa->peer_first_message)
900 rc_vfree(sa->peer_first_message);
901 if (sa->encryptor)
902 encryptor_destroy(sa->encryptor);
903 if (sa->authenticator)
904 auth_destroy(sa->authenticator);
905
906 if (sa->verified_info.packet)
907 rc_vfree(sa->verified_info.packet);
908
909 if (sa->transmit_info.packet)
910 rc_vfree(sa->transmit_info.packet);
911 if (sa->transmit_info.timer)
912 SCHED_KILL(sa->transmit_info.timer);
913 if (sa->response_info.packet)
914 rc_vfree(sa->response_info.packet);
915 if (sa->response_info.timer)
916 SCHED_KILL(sa->response_info.timer);
917
918 if (sa->local)
919 rc_free(sa->local);
920 if (sa->remote)
921 rc_free(sa->remote);
922
923 racoon_free(sa);
924 }
925
926 /*
927 * set ike_sa->encryptor, authenticator, prf according to negotiated_sa
928 * (negotiated_sa may be equal to ike_sa->negotiated_sa)
929 * returns 0 if successful, non-0 otherwise
930 */
931 int
932 ikev2_set_negotiated_sa(struct ikev2_sa *ike_sa,
933 struct ikev2_isakmpsa *negotiated_sa)
934 {
935 struct encryptor *encryptor = 0;
936 struct authenticator *authenticator = 0;
937 struct keyed_hash *prf = 0;
938
939 TRACE((PLOGLOC, "ikev2_set_negotiated_sa(%p, %p)\n", ike_sa,
940 negotiated_sa));
941 assert(!ike_sa->encryptor && !ike_sa->authenticator && !ike_sa->prf);
942
943 encryptor = ikev2_encryptor_new(negotiated_sa->encr,
944 negotiated_sa->encrklen);
945 if (!encryptor) {
946 isakmp_log(ike_sa, 0, 0, 0,
947 PLOG_INTERR, PLOGLOC,
948 "failed creating ike_sa encryptor\n");
949 goto fail;
950 }
951 authenticator = ikev2_authenticator_new(negotiated_sa->integr);
952 if (!authenticator) {
953 isakmp_log(ike_sa, 0, 0, 0,
954 PLOG_INTERR, PLOGLOC,
955 "failed creating ike_sa authenticator\n");
956 goto fail;
957 }
958 prf = ikev2_prf_new(negotiated_sa->prf);
959 if (!prf)
960 goto fail;
961
962 ike_sa->negotiated_sa = negotiated_sa;
963 ike_sa->encryptor = encryptor;
964 ike_sa->authenticator = authenticator;
965 ike_sa->prf = prf;
966 return 0;
967
968 fail:
969 if (encryptor)
970 encryptor_destroy(encryptor);
971 if (authenticator)
972 auth_destroy(authenticator);
973 if (prf)
974 keyed_hash_dispose(prf);
975 return -1;
976 }
977
978 void
979 ikev2_set_rmconf(struct ikev2_sa *sa, struct rcf_remote *conf)
980 {
981 if (sa->rmconf)
982 rcf_free_remote(sa->rmconf);
983
984 sa->rmconf = conf;
985
986 sa->transmit_info.retry_limit = ikev2_max_retry_to_send(conf);
987 sa->transmit_info.times_per_send = ikev2_times_per_send(conf);
988 sa->transmit_info.interval_to_send = ikev2_interval_to_send(conf);
989 if (sa->transmit_info.interval_to_send > 100000) /* XXX */
990 sa->transmit_info.interval_to_send = 100000;
991 }
992
993 struct contact_list {
994 rc_vchar_t *remote_index;
995 struct contact_list *next;
996 };
997
998 struct contact_list *contacted_list = 0;
999
1000 int
1001 ikev2_send_initial_contact(struct ikev2_sa *ike_sa)
1002 {
1003 struct contact_list *peer;
1004 struct contact_list *c;
1005
1006 for (peer = contacted_list; peer; peer = peer->next) {
1007 if (rc_vmemcmp(peer->remote_index, ike_sa->rmconf->rm_index) == 0)
1008 return FALSE;
1009 }
1010
1011 c = racoon_malloc(sizeof(struct contact_list));
1012 if (!c)
1013 return FALSE;
1014
1015 c->remote_index = rc_vdup(ike_sa->rmconf->rm_index);
1016 c->next = contacted_list;
1017 contacted_list = c;
1018
1019 return TRUE;
1020 }