]> git.saurik.com Git - apple/xnu.git/blame - bsd/netkey/key.c
projects / apple / xnu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xnu-3789.60.24.tar.gz
[apple/xnu.git] / bsd / netkey / key.c
CommitLineData
b0d623f7 1/*
ecc0ceb4 2 * Copyright (c) 2008-2016 Apple Inc. All rights reserved.
b0d623f7
A		 3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
39236c6e 5 *
b0d623f7
A		 6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
39236c6e 14 *
b0d623f7
A		 15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
39236c6e 17 *
b0d623f7
A		 18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
39236c6e 25 *
b0d623f7
A		 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
55e303ae
A		 29/* $FreeBSD: src/sys/netkey/key.c,v 1.16.2.13 2002/07/24 18:17:40 ume Exp $ */
30/* $KAME: key.c,v 1.191 2001/06/27 10:46:49 sakane Exp $ */
1c79356b
A		 31
32/*
33 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. Neither the name of the project nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 */
60
61/*
62 * This code is referd to RFC 2367
63 */
64
2d21ac55 65#include <machine/endian.h>
1c79356b
A		 66#include <sys/types.h>
67#include <sys/param.h>
68#include <sys/systm.h>
69#include <sys/kernel.h>
70#include <sys/mbuf.h>
71#include <sys/domain.h>
72#include <sys/protosw.h>
73#include <sys/malloc.h>
74#include <sys/socket.h>
75#include <sys/socketvar.h>
1c79356b 76#include <sys/sysctl.h>
1c79356b
A		 77#include <sys/errno.h>
78#include <sys/proc.h>
79#include <sys/queue.h>
55e303ae 80#include <sys/syslog.h>
6d2010ae 81#include <sys/mcache.h>
1c79356b 82
91447636
A		 83#include <kern/locks.h>
84
1c79356b
A		 85#include <net/if.h>
86#include <net/route.h>
87#include <net/raw_cb.h>
88
89#include <netinet/in.h>
90#include <netinet/in_systm.h>
91#include <netinet/ip.h>
92#include <netinet/in_var.h>
93
94#if INET6
95#include <netinet/ip6.h>
96#include <netinet6/in6_var.h>
97#include <netinet6/ip6_var.h>
98#endif /* INET6 */
99
1c79356b
A		 100#include <net/pfkeyv2.h>
101#include <netkey/keydb.h>
102#include <netkey/key.h>
103#include <netkey/keysock.h>
104#include <netkey/key_debug.h>
9bccf70c 105#include <stdarg.h>
d190cdc3 106#include <libkern/crypto/rand.h>
1c79356b
A		 107
108#include <netinet6/ipsec.h>
9bccf70c
A		 109#if INET6
110#include <netinet6/ipsec6.h>
111#endif
1c79356b 112#include <netinet6/ah.h>
9bccf70c
A		 113#if INET6
114#include <netinet6/ah6.h>
115#endif
1c79356b
A		 116#if IPSEC_ESP
117#include <netinet6/esp.h>
9bccf70c
A		 118#if INET6
119#include <netinet6/esp6.h>
120#endif
1c79356b
A		 121#endif
122#include <netinet6/ipcomp.h>
9bccf70c
A		 123#if INET6
124#include <netinet6/ipcomp6.h>
125#endif
126
127
128/* randomness */
129#include <sys/random.h>
1c79356b
A		 130
131#include <net/net_osdep.h>
132
55e303ae
A		 133#define FULLMASK 0xff
134
91447636
A		 135lck_grp_t *sadb_mutex_grp;
136lck_grp_attr_t *sadb_mutex_grp_attr;
137lck_attr_t *sadb_mutex_attr;
316670eb
A		 138decl_lck_mtx_data(, sadb_mutex_data);
139lck_mtx_t *sadb_mutex = &sadb_mutex_data;
2d21ac55
A		 140
141lck_grp_t *pfkey_stat_mutex_grp;
142lck_grp_attr_t *pfkey_stat_mutex_grp_attr;
143lck_attr_t *pfkey_stat_mutex_attr;
316670eb
A		 144decl_lck_mtx_data(, pfkey_stat_mutex_data);
145lck_mtx_t *pfkey_stat_mutex = &pfkey_stat_mutex_data;
2d21ac55 146
1c79356b
A		 147/*
148 * Note on SA reference counting:
149 * - SAs that are not in DEAD state will have (total external reference + 1)
150 * following value in reference count field. they cannot be freed and are
151 * referenced from SA header.
152 * - SAs that are in DEAD state will have (total external reference)
153 * in reference count field. they are ready to be freed. reference from
154 * SA header will be removed in key_delsav(), when the reference count
155 * field hits 0 (= no external reference other than from SA header.
156 */
157
158u_int32_t key_debug_level = 0; //### our sysctl is not dynamic
39236c6e 159static int key_timehandler_running = 0;
1c79356b
A		 160static u_int key_spi_trycnt = 1000;
161static u_int32_t key_spi_minval = 0x100;
162static u_int32_t key_spi_maxval = 0x0fffffff; /* XXX */
163static u_int32_t policy_id = 0;
164static u_int key_int_random = 60; /*interval to initialize randseed,1(m)*/
165static u_int key_larval_lifetime = 30; /* interval to expire acquiring, 30(s)*/
166static int key_blockacq_count = 10; /* counter for blocking SADB_ACQUIRE.*/
167static int key_blockacq_lifetime = 20; /* lifetime for blocking SADB_ACQUIRE.*/
55e303ae 168static int key_preferred_oldsa = 0; /* preferred old sa rather than new sa.*/
b0d623f7 169__private_extern__ int natt_keepalive_interval = 20; /* interval between natt keepalives.*/
316670eb 170__private_extern__ int ipsec_policy_count = 0;
2d21ac55 171static int ipsec_sav_count = 0;
1c79356b
A		 172
173static u_int32_t acq_seq = 0;
174static int key_tick_init_random = 0;
39037602
A		 175static u_int64_t up_time = 0;
176__private_extern__ u_int64_t natt_now = 0;
1c79356b
A		 177
178static LIST_HEAD(_sptree, secpolicy) sptree[IPSEC_DIR_MAX]; /* SPD */
179static LIST_HEAD(_sahtree, secashead) sahtree; /* SAD */
180static LIST_HEAD(_regtree, secreg) regtree[SADB_SATYPE_MAX + 1];
39236c6e
A		 181/* registed list */
182
91447636
A		 183#define SPIHASHSIZE 128
184#define SPIHASH(x) (((x) ^ ((x) >> 16)) % SPIHASHSIZE)
185static LIST_HEAD(_spihash, secasvar) spihash[SPIHASHSIZE];
186
1c79356b
A		 187#ifndef IPSEC_NONBLOCK_ACQUIRE
188static LIST_HEAD(_acqtree, secacq) acqtree; /* acquiring list */
189#endif
190static LIST_HEAD(_spacqtree, secspacq) spacqtree; /* SP acquiring list */
191
192struct key_cb key_cb;
193
194/* search order for SAs */
55e303ae 195static const u_int saorder_state_valid_prefer_old[] = {
1c79356b 196 SADB_SASTATE_DYING, SADB_SASTATE_MATURE,
1c79356b 197};
55e303ae
A		 198static const u_int saorder_state_valid_prefer_new[] = {
199 SADB_SASTATE_MATURE, SADB_SASTATE_DYING,
200};
201static const u_int saorder_state_alive[] = {
1c79356b
A		 202 /* except DEAD */
203 SADB_SASTATE_MATURE, SADB_SASTATE_DYING, SADB_SASTATE_LARVAL
204};
55e303ae 205static const u_int saorder_state_any[] = {
1c79356b
A		 206 SADB_SASTATE_MATURE, SADB_SASTATE_DYING,
207 SADB_SASTATE_LARVAL, SADB_SASTATE_DEAD
208};
209
9bccf70c
A		 210static const int minsize[] = {
211 sizeof(struct sadb_msg), /* SADB_EXT_RESERVED */
212 sizeof(struct sadb_sa), /* SADB_EXT_SA */
213 sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_CURRENT */
214 sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_HARD */
215 sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_SOFT */
216 sizeof(struct sadb_address), /* SADB_EXT_ADDRESS_SRC */
217 sizeof(struct sadb_address), /* SADB_EXT_ADDRESS_DST */
218 sizeof(struct sadb_address), /* SADB_EXT_ADDRESS_PROXY */
219 sizeof(struct sadb_key), /* SADB_EXT_KEY_AUTH */
220 sizeof(struct sadb_key), /* SADB_EXT_KEY_ENCRYPT */
221 sizeof(struct sadb_ident), /* SADB_EXT_IDENTITY_SRC */
222 sizeof(struct sadb_ident), /* SADB_EXT_IDENTITY_DST */
223 sizeof(struct sadb_sens), /* SADB_EXT_SENSITIVITY */
224 sizeof(struct sadb_prop), /* SADB_EXT_PROPOSAL */
225 sizeof(struct sadb_supported), /* SADB_EXT_SUPPORTED_AUTH */
226 sizeof(struct sadb_supported), /* SADB_EXT_SUPPORTED_ENCRYPT */
227 sizeof(struct sadb_spirange), /* SADB_EXT_SPIRANGE */
228 0, /* SADB_X_EXT_KMPRIVATE */
229 sizeof(struct sadb_x_policy), /* SADB_X_EXT_POLICY */
230 sizeof(struct sadb_x_sa2), /* SADB_X_SA2 */
b0d623f7
A		 231 sizeof(struct sadb_session_id), /* SADB_EXT_SESSION_ID */
232 sizeof(struct sadb_sastat), /* SADB_EXT_SASTAT */
39236c6e
A		 233 sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_IPSECIF */
234 sizeof(struct sadb_address), /* SADB_X_EXT_ADDR_RANGE_SRC_START */
235 sizeof(struct sadb_address), /* SADB_X_EXT_ADDR_RANGE_SRC_END */
236 sizeof(struct sadb_address), /* SADB_X_EXT_ADDR_RANGE_DST_START */
237 sizeof(struct sadb_address), /* SADB_X_EXT_ADDR_RANGE_DST_END */
3e170ce0
A		 238 sizeof(struct sadb_address), /* SADB_EXT_MIGRATE_ADDRESS_SRC */
239 sizeof(struct sadb_address), /* SADB_EXT_MIGRATE_ADDRESS_DST */
240 sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_MIGRATE_IPSECIF */
9bccf70c
A		 241};
242static const int maxsize[] = {
243 sizeof(struct sadb_msg), /* SADB_EXT_RESERVED */
55e303ae 244 sizeof(struct sadb_sa_2), /* SADB_EXT_SA */
9bccf70c
A		 245 sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_CURRENT */
246 sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_HARD */
247 sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_SOFT */
248 0, /* SADB_EXT_ADDRESS_SRC */
249 0, /* SADB_EXT_ADDRESS_DST */
250 0, /* SADB_EXT_ADDRESS_PROXY */
251 0, /* SADB_EXT_KEY_AUTH */
252 0, /* SADB_EXT_KEY_ENCRYPT */
253 0, /* SADB_EXT_IDENTITY_SRC */
254 0, /* SADB_EXT_IDENTITY_DST */
255 0, /* SADB_EXT_SENSITIVITY */
256 0, /* SADB_EXT_PROPOSAL */
257 0, /* SADB_EXT_SUPPORTED_AUTH */
258 0, /* SADB_EXT_SUPPORTED_ENCRYPT */
259 sizeof(struct sadb_spirange), /* SADB_EXT_SPIRANGE */
260 0, /* SADB_X_EXT_KMPRIVATE */
261 0, /* SADB_X_EXT_POLICY */
262 sizeof(struct sadb_x_sa2), /* SADB_X_SA2 */
b0d623f7
A		 263 0, /* SADB_EXT_SESSION_ID */
264 0, /* SADB_EXT_SASTAT */
39236c6e
A		 265 sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_IPSECIF */
266 0, /* SADB_X_EXT_ADDR_RANGE_SRC_START */
267 0, /* SADB_X_EXT_ADDR_RANGE_SRC_END */
268 0, /* SADB_X_EXT_ADDR_RANGE_DST_START */
269 0, /* SADB_X_EXT_ADDR_RANGE_DST_END */
3e170ce0
A		 270 0, /* SADB_EXT_MIGRATE_ADDRESS_SRC */
271 0, /* SADB_EXT_MIGRATE_ADDRESS_DST */
272 sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_MIGRATE_IPSECIF */
9bccf70c
A		 273};
274
275static int ipsec_esp_keymin = 256;
276static int ipsec_esp_auth = 0;
277static int ipsec_ah_keymin = 128;
278
1c79356b 279SYSCTL_DECL(_net_key);
6d2010ae
A		 280/* Thread safe: no accumulated state */
281SYSCTL_INT(_net_key, KEYCTL_DEBUG_LEVEL, debug, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 282 &key_debug_level, 0, "");
9bccf70c 283
1c79356b
A		 284
285/* max count of trial for the decision of spi value */
6d2010ae 286SYSCTL_INT(_net_key, KEYCTL_SPI_TRY, spi_trycnt, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 287 &key_spi_trycnt, 0, "");
1c79356b
A		 288
289/* minimum spi value to allocate automatically. */
6d2010ae 290SYSCTL_INT(_net_key, KEYCTL_SPI_MIN_VALUE, spi_minval, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 291 &key_spi_minval, 0, "");
1c79356b
A		 292
293/* maximun spi value to allocate automatically. */
6d2010ae 294SYSCTL_INT(_net_key, KEYCTL_SPI_MAX_VALUE, spi_maxval, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 295 &key_spi_maxval, 0, "");
1c79356b
A		 296
297/* interval to initialize randseed */
6d2010ae 298SYSCTL_INT(_net_key, KEYCTL_RANDOM_INT, int_random, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 299 &key_int_random, 0, "");
1c79356b 300
6d2010ae
A		 301/* lifetime for larval SA; thread safe due to > compare */
302SYSCTL_INT(_net_key, KEYCTL_LARVAL_LIFETIME, larval_lifetime, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 303 &key_larval_lifetime, 0, "");
1c79356b
A		 304
305/* counter for blocking to send SADB_ACQUIRE to IKEd */
6d2010ae 306SYSCTL_INT(_net_key, KEYCTL_BLOCKACQ_COUNT, blockacq_count, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 307 &key_blockacq_count, 0, "");
1c79356b 308
6d2010ae
A		 309/* lifetime for blocking to send SADB_ACQUIRE to IKEd: Thread safe, > compare */
310SYSCTL_INT(_net_key, KEYCTL_BLOCKACQ_LIFETIME, blockacq_lifetime, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 311 &key_blockacq_lifetime, 0, "");
1c79356b 312
55e303ae 313/* ESP auth */
6d2010ae 314SYSCTL_INT(_net_key, KEYCTL_ESP_AUTH, esp_auth, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 315 &ipsec_esp_auth, 0, "");
55e303ae 316
9bccf70c 317/* minimum ESP key length */
6d2010ae 318SYSCTL_INT(_net_key, KEYCTL_ESP_KEYMIN, esp_keymin, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 319 &ipsec_esp_keymin, 0, "");
9bccf70c
A		 320
321/* minimum AH key length */
6d2010ae 322SYSCTL_INT(_net_key, KEYCTL_AH_KEYMIN, ah_keymin, CTLFLAG_RW | CTLFLAG_LOCKED, \
39236c6e 323 &ipsec_ah_keymin, 0, "");
1c79356b 324
55e303ae 325/* perfered old SA rather than new SA */
6d2010ae 326SYSCTL_INT(_net_key, KEYCTL_PREFERED_OLDSA, prefered_oldsa, CTLFLAG_RW | CTLFLAG_LOCKED,\
39236c6e 327 &key_preferred_oldsa, 0, "");
55e303ae
A		 328
329/* time between NATT keepalives in seconds, 0 disabled */
6d2010ae 330SYSCTL_INT(_net_key, KEYCTL_NATT_KEEPALIVE_INTERVAL, natt_keepalive_interval, CTLFLAG_RW | CTLFLAG_LOCKED,\
39236c6e 331 &natt_keepalive_interval, 0, "");
55e303ae 332
91447636 333/* PF_KEY statistics */
6d2010ae 334SYSCTL_STRUCT(_net_key, KEYCTL_PFKEYSTAT, pfkeystat, CTLFLAG_RD | CTLFLAG_LOCKED,\
39236c6e 335 &pfkeystat, pfkeystat, "");
91447636 336
1c79356b
A		 337#ifndef LIST_FOREACH
338#define LIST_FOREACH(elm, head, field) \
39236c6e 339for (elm = LIST_FIRST(head); elm; elm = LIST_NEXT(elm, field))
1c79356b
A		 340#endif
341#define __LIST_CHAINED(elm) \
39236c6e 342(!((elm)->chain.le_next == NULL && (elm)->chain.le_prev == NULL))
1c79356b
A		 343#define LIST_INSERT_TAIL(head, elm, type, field) \
344do {\
39236c6e
A		 345struct type *curelm = LIST_FIRST(head); \
346if (curelm == NULL) {\
347LIST_INSERT_HEAD(head, elm, field); \
348} else { \
349while (LIST_NEXT(curelm, field)) \
350curelm = LIST_NEXT(curelm, field);\
351LIST_INSERT_AFTER(curelm, elm, field);\
352}\
1c79356b
A		 353} while (0)
354
355#define KEY_CHKSASTATE(head, sav, name) \
356do { \
39236c6e
A		 357if ((head) != (sav)) { \
358ipseclog((LOG_DEBUG, "%s: state mismatched (TREE=%d SA=%d)\n", \
359(name), (head), (sav))); \
360continue; \
361} \
1c79356b
A		 362} while (0)
363
364#define KEY_CHKSPDIR(head, sp, name) \
365do { \
39236c6e
A		 366if ((head) != (sp)) { \
367ipseclog((LOG_DEBUG, "%s: direction mismatched (TREE=%d SP=%d), " \
368"anyway continue.\n", \
369(name), (head), (sp))); \
370} \
1c79356b
A		 371} while (0)
372
373#if 1
2d21ac55 374#define KMALLOC_WAIT(p, t, n) \
39236c6e 375((p) = (t) _MALLOC((u_int32_t)(n), M_SECA, M_WAITOK))
2d21ac55 376#define KMALLOC_NOWAIT(p, t, n) \
39236c6e 377((p) = (t) _MALLOC((u_int32_t)(n), M_SECA, M_NOWAIT))
1c79356b 378#define KFREE(p) \
39236c6e 379_FREE((caddr_t)(p), M_SECA);
1c79356b 380#else
2d21ac55 381#define KMALLOC_WAIT(p, t, n) \
1c79356b 382do { \
39236c6e
A		 383((p) = (t)_MALLOC((u_int32_t)(n), M_SECA, M_WAITOK)); \
384printf("%s %d: %p <- KMALLOC_WAIT(%s, %d)\n", \
385__FILE__, __LINE__, (p), #t, n); \
1c79356b 386} while (0)
2d21ac55 387#define KMALLOC_NOWAIT(p, t, n) \
39236c6e
A		 388do { \
389((p) = (t)_MALLOC((u_int32_t)(n), M_SECA, M_NOWAIT)); \
390printf("%s %d: %p <- KMALLOC_NOWAIT(%s, %d)\n", \
391__FILE__, __LINE__, (p), #t, n); \
392} while (0)
1c79356b
A		 393
394#define KFREE(p) \
39236c6e
A		 395do { \
396printf("%s %d: %p -> KFREE()\n", __FILE__, __LINE__, (p)); \
397_FREE((caddr_t)(p), M_SECA); \
398} while (0)
1c79356b
A		 399#endif
400
401/*
402 * set parameters into secpolicyindex buffer.
403 * Must allocate secpolicyindex buffer passed to this function.
404 */
39236c6e 405#define KEY_SETSECSPIDX(_dir, s, d, ps, pd, ulp, ifp, s_s, s_e, d_s, d_e, idx) \
1c79356b 406do { \
39236c6e
A		 407bzero((idx), sizeof(struct secpolicyindex)); \
408(idx)->dir = (_dir); \
409(idx)->prefs = (ps); \
410(idx)->prefd = (pd); \
411(idx)->ul_proto = (ulp); \
412(idx)->internal_if = (ifp); \
413if (s) bcopy((s), &(idx)->src, ((struct sockaddr *)(s))->sa_len); \
414if (d) bcopy((d), &(idx)->dst, ((struct sockaddr *)(d))->sa_len); \
415if (s_s) bcopy((s_s), &(idx)->src_range.start, ((struct sockaddr *)(s_s))->sa_len); \
416if (s_e) bcopy((s_e), &(idx)->src_range.end, ((struct sockaddr *)(s_e))->sa_len); \
417if (d_s) bcopy((d_s), &(idx)->dst_range.start, ((struct sockaddr *)(d_s))->sa_len); \
418if (d_e) bcopy((d_e), &(idx)->dst_range.end, ((struct sockaddr *)(d_e))->sa_len); \
1c79356b
A		 419} while (0)
420
421/*
422 * set parameters into secasindex buffer.
423 * Must allocate secasindex buffer before calling this function.
424 */
fe8ab488 425#define KEY_SETSECASIDX(p, m, r, s, d, ifi, idx) \
1c79356b 426do { \
39236c6e
A		 427bzero((idx), sizeof(struct secasindex)); \
428(idx)->proto = (p); \
429(idx)->mode = (m); \
430(idx)->reqid = (r); \
431bcopy((s), &(idx)->src, ((const struct sockaddr *)(s))->sa_len); \
432bcopy((d), &(idx)->dst, ((const struct sockaddr *)(d))->sa_len); \
fe8ab488 433(idx)->ipsec_ifindex = (ifi); \
1c79356b
A		 434} while (0)
435
436/* key statistics */
437struct _keystat {
b0d623f7 438 u_int32_t getspi_count; /* the avarage of count to try to get new SPI */
1c79356b
A		 439} keystat;
440
9bccf70c
A		 441struct sadb_msghdr {
442 struct sadb_msg *msg;
443 struct sadb_ext *ext[SADB_EXT_MAX + 1];
444 int extoff[SADB_EXT_MAX + 1];
445 int extlen[SADB_EXT_MAX + 1];
446};
447
39236c6e 448static struct secpolicy *__key_getspbyid(u_int32_t id);
2d21ac55
A		 449static struct secasvar *key_do_allocsa_policy(struct secashead *, u_int, u_int16_t);
450static int key_do_get_translated_port(struct secashead *, struct secasvar *, u_int);
91447636
A		 451static void key_delsp(struct secpolicy *);
452static struct secpolicy *key_getsp(struct secpolicyindex *);
91447636
A		 453static u_int32_t key_newreqid(void);
454static struct mbuf *key_gather_mbuf(struct mbuf *,
39236c6e 455 const struct sadb_msghdr *, int, int, int *);
91447636 456static int key_spdadd(struct socket *, struct mbuf *,
39236c6e 457 const struct sadb_msghdr *);
91447636
A		 458static u_int32_t key_getnewspid(void);
459static int key_spddelete(struct socket *, struct mbuf *,
39236c6e 460 const struct sadb_msghdr *);
91447636 461static int key_spddelete2(struct socket *, struct mbuf *,
39236c6e
A		 462 const struct sadb_msghdr *);
463static int key_spdenable(struct socket *, struct mbuf *,
464 const struct sadb_msghdr *);
465static int key_spddisable(struct socket *, struct mbuf *,
466 const struct sadb_msghdr *);
91447636 467static int key_spdget(struct socket *, struct mbuf *,
39236c6e 468 const struct sadb_msghdr *);
91447636 469static int key_spdflush(struct socket *, struct mbuf *,
39236c6e 470 const struct sadb_msghdr *);
91447636 471static int key_spddump(struct socket *, struct mbuf *,
39236c6e 472 const struct sadb_msghdr *);
91447636 473static struct mbuf *key_setdumpsp(struct secpolicy *,
39236c6e 474 u_int8_t, u_int32_t, u_int32_t);
91447636
A		 475static u_int key_getspreqmsglen(struct secpolicy *);
476static int key_spdexpire(struct secpolicy *);
fe8ab488 477static struct secashead *key_newsah(struct secasindex *, ifnet_t, u_int, u_int8_t);
91447636 478static struct secasvar *key_newsav(struct mbuf *,
fe8ab488
A		 479 const struct sadb_msghdr *, struct secashead *, int *,
480 struct socket *);
91447636
A		 481static struct secashead *key_getsah(struct secasindex *);
482static struct secasvar *key_checkspidup(struct secasindex *, u_int32_t);
483static void key_setspi __P((struct secasvar *, u_int32_t));
484static struct secasvar *key_getsavbyspi(struct secashead *, u_int32_t);
485static int key_setsaval(struct secasvar *, struct mbuf *,
39236c6e 486 const struct sadb_msghdr *);
91447636
A		 487static int key_mature(struct secasvar *);
488static struct mbuf *key_setdumpsa(struct secasvar *, u_int8_t,
39236c6e 489 u_int8_t, u_int32_t, u_int32_t);
91447636 490static struct mbuf *key_setsadbmsg(u_int8_t, u_int16_t, u_int8_t,
39236c6e 491 u_int32_t, pid_t, u_int16_t);
91447636
A		 492static struct mbuf *key_setsadbsa(struct secasvar *);
493static struct mbuf *key_setsadbaddr(u_int16_t,
39236c6e
A		 494 struct sockaddr *, u_int8_t, u_int16_t);
495static struct mbuf *key_setsadbipsecif(ifnet_t, ifnet_t, ifnet_t, int);
1c79356b 496#if 0
91447636 497static struct mbuf *key_setsadbident(u_int16_t, u_int16_t, caddr_t,
39236c6e 498 int, u_int64_t);
9bccf70c 499#endif
fe8ab488 500static struct mbuf *key_setsadbxsa2(u_int8_t, u_int32_t, u_int32_t, u_int16_t);
91447636 501static struct mbuf *key_setsadbxpolicy(u_int16_t, u_int8_t,
39236c6e 502 u_int32_t);
91447636 503static void *key_newbuf(const void *, u_int);
9bccf70c 504#if INET6
91447636 505static int key_ismyaddr6(struct sockaddr_in6 *);
1c79356b 506#endif
b0d623f7 507static void key_update_natt_keepalive_timestamp(struct secasvar *, struct secasvar *);
55e303ae
A		 508
509/* flags for key_cmpsaidx() */
2d21ac55
A		 510#define CMP_HEAD 0x1 /* protocol, addresses. */
511#define CMP_PORT 0x2 /* additionally HEAD, reqid, mode. */
512#define CMP_REQID 0x4 /* additionally HEAD, reqid. */
513#define CMP_MODE 0x8 /* additionally mode. */
514#define CMP_EXACTLY 0xF /* all elements. */
91447636
A		 515static int key_cmpsaidx(struct secasindex *, struct secasindex *, int);
516
517static int key_cmpspidx_exactly(struct secpolicyindex *,
39236c6e 518 struct secpolicyindex *);
91447636 519static int key_cmpspidx_withmask(struct secpolicyindex *,
39236c6e 520 struct secpolicyindex *);
91447636 521static int key_sockaddrcmp(struct sockaddr *, struct sockaddr *, int);
39236c6e 522static int key_is_addr_in_range(struct sockaddr_storage *, struct secpolicyaddrrange *);
91447636
A		 523static int key_bbcmp(caddr_t, caddr_t, u_int);
524static void key_srandom(void);
525static u_int16_t key_satype2proto(u_int8_t);
526static u_int8_t key_proto2satype(u_int16_t);
527
528static int key_getspi(struct socket *, struct mbuf *,
39236c6e 529 const struct sadb_msghdr *);
91447636
A		 530static u_int32_t key_do_getnewspi(struct sadb_spirange *, struct secasindex *);
531static int key_update(struct socket *, struct mbuf *,
39236c6e 532 const struct sadb_msghdr *);
9bccf70c 533#if IPSEC_DOSEQCHECK
91447636 534static struct secasvar *key_getsavbyseq(struct secashead *, u_int32_t);
9bccf70c 535#endif
91447636
A		 536static int key_add(struct socket *, struct mbuf *, const struct sadb_msghdr *);
537static int key_setident(struct secashead *, struct mbuf *,
39236c6e 538 const struct sadb_msghdr *);
91447636
A		 539static struct mbuf *key_getmsgbuf_x1(struct mbuf *, const struct sadb_msghdr *);
540static int key_delete(struct socket *, struct mbuf *,
39236c6e 541 const struct sadb_msghdr *);
91447636
A		 542static int key_get(struct socket *, struct mbuf *, const struct sadb_msghdr *);
543
544static void key_getcomb_setlifetime(struct sadb_comb *);
9bccf70c 545#if IPSEC_ESP
91447636 546static struct mbuf *key_getcomb_esp(void);
9bccf70c 547#endif
91447636
A		 548static struct mbuf *key_getcomb_ah(void);
549static struct mbuf *key_getcomb_ipcomp(void);
550static struct mbuf *key_getprop(const struct secasindex *);
9bccf70c 551
91447636 552static int key_acquire(struct secasindex *, struct secpolicy *);
9bccf70c 553#ifndef IPSEC_NONBLOCK_ACQUIRE
91447636
A		 554static struct secacq *key_newacq(struct secasindex *);
555static struct secacq *key_getacq(struct secasindex *);
556static struct secacq *key_getacqbyseq(u_int32_t);
9bccf70c 557#endif
91447636
A		 558static struct secspacq *key_newspacq(struct secpolicyindex *);
559static struct secspacq *key_getspacq(struct secpolicyindex *);
560static int key_acquire2(struct socket *, struct mbuf *,
39236c6e 561 const struct sadb_msghdr *);
91447636 562static int key_register(struct socket *, struct mbuf *,
39236c6e 563 const struct sadb_msghdr *);
91447636
A		 564static int key_expire(struct secasvar *);
565static int key_flush(struct socket *, struct mbuf *,
39236c6e 566 const struct sadb_msghdr *);
91447636
A		 567static int key_dump(struct socket *, struct mbuf *, const struct sadb_msghdr *);
568static int key_promisc(struct socket *, struct mbuf *,
39236c6e 569 const struct sadb_msghdr *);
91447636
A		 570static int key_senderror(struct socket *, struct mbuf *, int);
571static int key_validate_ext(const struct sadb_ext *, int);
572static int key_align(struct mbuf *, struct sadb_msghdr *);
91447636 573static struct mbuf *key_alloc_mbuf(int);
b0d623f7 574static int key_getsastat (struct socket *, struct mbuf *, const struct sadb_msghdr *);
3e170ce0 575static int key_migrate (struct socket *, struct mbuf *, const struct sadb_msghdr *);
316670eb 576static int key_setsaval2(struct secasvar *sav,
39236c6e
A		 577 u_int8_t satype,
578 u_int8_t alg_auth,
579 u_int8_t alg_enc,
580 u_int32_t flags,
581 u_int8_t replay,
582 struct sadb_key *key_auth,
583 u_int16_t key_auth_len,
584 struct sadb_key *key_enc,
585 u_int16_t key_enc_len,
586 u_int16_t natt_port,
587 u_int32_t seq,
588 u_int32_t spi,
589 u_int32_t pid,
590 struct sadb_lifetime *lifetime_hard,
591 struct sadb_lifetime *lifetime_soft);
ecc0ceb4 592static void bzero_keys(const struct sadb_msghdr *);
9bccf70c
A		 593
594extern int ipsec_bypass;
b0d623f7
A		 595extern int esp_udp_encap_port;
596int ipsec_send_natt_keepalive(struct secasvar *sav);
3e170ce0 597bool ipsec_fill_offload_frame(ifnet_t ifp, struct secasvar *sav, struct ifnet_keepalive_offload_frame *frame, size_t frame_data_offset);
1c79356b 598
39236c6e 599void key_init(struct protosw *, struct domain *);
91447636
A		 600
601/*
602 * PF_KEY init
6d2010ae 603 * setup locks, call raw_init(), and then init timer and associated data
91447636
A		 604 *
605 */
606void
39236c6e 607key_init(struct protosw *pp, struct domain *dp)
91447636 608{
39236c6e 609 static int key_initialized = 0;
91447636 610 int i;
39236c6e
A		 611
612 VERIFY((pp->pr_flags & (PR_INITIALIZED|PR_ATTACHED)) == PR_ATTACHED);
99c3a104
A		 613
614 _CASSERT(PFKEY_ALIGN8(sizeof(struct sadb_msg)) <= _MHLEN);
39236c6e
A		 615
616 if (key_initialized)
617 return;
618 key_initialized = 1;
99c3a104 619
91447636
A		 620 sadb_mutex_grp_attr = lck_grp_attr_alloc_init();
621 sadb_mutex_grp = lck_grp_alloc_init("sadb", sadb_mutex_grp_attr);
622 sadb_mutex_attr = lck_attr_alloc_init();
2d21ac55 623
39236c6e
A		 624 lck_mtx_init(sadb_mutex, sadb_mutex_grp, sadb_mutex_attr);
625
2d21ac55
A		 626 pfkey_stat_mutex_grp_attr = lck_grp_attr_alloc_init();
627 pfkey_stat_mutex_grp = lck_grp_alloc_init("pfkey_stat", pfkey_stat_mutex_grp_attr);
628 pfkey_stat_mutex_attr = lck_attr_alloc_init();
39236c6e 629
316670eb 630 lck_mtx_init(pfkey_stat_mutex, pfkey_stat_mutex_grp, pfkey_stat_mutex_attr);
39236c6e 631
91447636
A		 632 for (i = 0; i < SPIHASHSIZE; i++)
633 LIST_INIT(&spihash[i]);
593a1d5f 634
39236c6e
A		 635 raw_init(pp, dp);
636
637 bzero((caddr_t)&key_cb, sizeof(key_cb));
638
6d2010ae
A		 639 for (i = 0; i < IPSEC_DIR_MAX; i++) {
640 LIST_INIT(&sptree[i]);
641 }
642 ipsec_policy_count = 0;
39236c6e 643
6d2010ae 644 LIST_INIT(&sahtree);
39236c6e 645
6d2010ae
A		 646 for (i = 0; i <= SADB_SATYPE_MAX; i++) {
647 LIST_INIT(&regtree[i]);
648 }
649 ipsec_sav_count = 0;
39236c6e 650
6d2010ae
A		 651#ifndef IPSEC_NONBLOCK_ACQUIRE
652 LIST_INIT(&acqtree);
653#endif
654 LIST_INIT(&spacqtree);
39236c6e 655
6d2010ae
A		 656 /* system default */
657#if INET
658 ip4_def_policy.policy = IPSEC_POLICY_NONE;
659 ip4_def_policy.refcnt++; /*never reclaim this*/
660#endif
661#if INET6
662 ip6_def_policy.policy = IPSEC_POLICY_NONE;
663 ip6_def_policy.refcnt++; /*never reclaim this*/
664#endif
39236c6e
A		 665
666 key_timehandler_running = 0;
667
6d2010ae
A		 668 /* initialize key statistics */
669 keystat.getspi_count = 1;
39236c6e 670
6d2010ae
A		 671#ifndef __APPLE__
672 printf("IPsec: Initialized Security Association Processing.\n");
673#endif
91447636
A		 674}
675
39236c6e
A		 676static void
677key_start_timehandler(void)
678{
679 /* must be called while locked */
680 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e
A		 681 if (key_timehandler_running == 0) {
682 key_timehandler_running = 1;
683 (void)timeout((void *)key_timehandler, (void *)0, hz);
684 }
fe8ab488
A		 685
686 /* Turn off the ipsec bypass */
687 if (ipsec_bypass != 0)
688 ipsec_bypass = 0;
39236c6e 689}
91447636 690
1c79356b
A		 691/* %%% IPsec policy management */
692/*
693 * allocating a SP for OUTBOUND or INBOUND packet.
694 * Must call key_freesp() later.
695 * OUT: NULL: not found
696 * others: found and return the pointer.
697 */
698struct secpolicy *
6d2010ae 699key_allocsp(
39236c6e
A		 700 struct secpolicyindex *spidx,
701 u_int dir)
1c79356b
A		 702{
703 struct secpolicy *sp;
9bccf70c 704 struct timeval tv;
39236c6e 705
2d21ac55 706 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
1c79356b
A		 707 /* sanity check */
708 if (spidx == NULL)
709 panic("key_allocsp: NULL pointer is passed.\n");
39236c6e 710
1c79356b
A		 711 /* check direction */
712 switch (dir) {
39236c6e
A		 713 case IPSEC_DIR_INBOUND:
714 case IPSEC_DIR_OUTBOUND:
715 break;
716 default:
717 panic("key_allocsp: Invalid direction is passed.\n");
1c79356b 718 }
39236c6e 719
1c79356b 720 /* get a SP entry */
1c79356b 721 KEYDEBUG(KEYDEBUG_IPSEC_DATA,
39236c6e
A		 722 printf("*** objects\n");
723 kdebug_secpolicyindex(spidx));
724
2d21ac55 725 lck_mtx_lock(sadb_mutex);
1c79356b
A		 726 LIST_FOREACH(sp, &sptree[dir], chain) {
727 KEYDEBUG(KEYDEBUG_IPSEC_DATA,
39236c6e
A		 728 printf("*** in SPD\n");
729 kdebug_secpolicyindex(&sp->spidx));
730
1c79356b
A		 731 if (sp->state == IPSEC_SPSTATE_DEAD)
732 continue;
39236c6e
A		 733
734 /* If the policy is disabled, skip */
735 if (sp->disabled > 0)
736 continue;
737
738 /* If the incoming spidx specifies bound if,
739 ignore unbound policies*/
740 if (spidx->internal_if != NULL
741 && (sp->spidx.internal_if == NULL || sp->ipsec_if == NULL))
742 continue;
743
1c79356b
A		 744 if (key_cmpspidx_withmask(&sp->spidx, spidx))
745 goto found;
746 }
2d21ac55 747 lck_mtx_unlock(sadb_mutex);
1c79356b 748 return NULL;
39236c6e 749
1c79356b 750found:
39236c6e 751
1c79356b 752 /* found a SPD entry */
9bccf70c
A		 753 microtime(&tv);
754 sp->lastused = tv.tv_sec;
1c79356b 755 sp->refcnt++;
2d21ac55
A		 756 lck_mtx_unlock(sadb_mutex);
757
758 /* sanity check */
759 KEY_CHKSPDIR(sp->spidx.dir, dir, "key_allocsp");
1c79356b 760 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
39236c6e
A		 761 printf("DP key_allocsp cause refcnt++:%d SP:0x%llx\n",
762 sp->refcnt, (uint64_t)VM_KERNEL_ADDRPERM(sp)));
1c79356b
A		 763 return sp;
764}
765
766/*
9bccf70c
A		 767 * return a policy that matches this particular inbound packet.
768 * XXX slow
769 */
770struct secpolicy *
6d2010ae 771key_gettunnel(
39236c6e
A		 772 struct sockaddr *osrc,
773 struct sockaddr *odst,
774 struct sockaddr *isrc,
775 struct sockaddr *idst)
9bccf70c
A		 776{
777 struct secpolicy *sp;
778 const int dir = IPSEC_DIR_INBOUND;
779 struct timeval tv;
9bccf70c
A		 780 struct ipsecrequest *r1, *r2, *p;
781 struct sockaddr *os, *od, *is, *id;
782 struct secpolicyindex spidx;
39236c6e 783
55e303ae
A		 784 if (isrc->sa_family != idst->sa_family) {
785 ipseclog((LOG_ERR, "protocol family mismatched %d != %d\n.",
39236c6e 786 isrc->sa_family, idst->sa_family));
55e303ae
A		 787 return NULL;
788 }
39236c6e 789
2d21ac55 790 lck_mtx_lock(sadb_mutex);
9bccf70c
A		 791 LIST_FOREACH(sp, &sptree[dir], chain) {
792 if (sp->state == IPSEC_SPSTATE_DEAD)
793 continue;
39236c6e 794
9bccf70c
A		 795 r1 = r2 = NULL;
796 for (p = sp->req; p; p = p->next) {
797 if (p->saidx.mode != IPSEC_MODE_TUNNEL)
798 continue;
39236c6e 799
9bccf70c
A		 800 r1 = r2;
801 r2 = p;
39236c6e 802
9bccf70c
A		 803 if (!r1) {
804 /* here we look at address matches only */
805 spidx = sp->spidx;
806 if (isrc->sa_len > sizeof(spidx.src) ||
807 idst->sa_len > sizeof(spidx.dst))
808 continue;
809 bcopy(isrc, &spidx.src, isrc->sa_len);
810 bcopy(idst, &spidx.dst, idst->sa_len);
811 if (!key_cmpspidx_withmask(&sp->spidx, &spidx))
39236c6e 812 continue;
9bccf70c
A		 813 } else {
814 is = (struct sockaddr *)&r1->saidx.src;
815 id = (struct sockaddr *)&r1->saidx.dst;
816 if (key_sockaddrcmp(is, isrc, 0) ||
817 key_sockaddrcmp(id, idst, 0))
818 continue;
819 }
39236c6e 820
9bccf70c
A		 821 os = (struct sockaddr *)&r2->saidx.src;
822 od = (struct sockaddr *)&r2->saidx.dst;
823 if (key_sockaddrcmp(os, osrc, 0) ||
824 key_sockaddrcmp(od, odst, 0))
825 continue;
39236c6e 826
9bccf70c
A		 827 goto found;
828 }
829 }
2d21ac55 830 lck_mtx_unlock(sadb_mutex);
9bccf70c 831 return NULL;
39236c6e 832
9bccf70c
A		 833found:
834 microtime(&tv);
835 sp->lastused = tv.tv_sec;
836 sp->refcnt++;
2d21ac55 837 lck_mtx_unlock(sadb_mutex);
9bccf70c
A		 838 return sp;
839}
840
fe8ab488
A		 841struct secasvar *key_alloc_outbound_sav_for_interface(ifnet_t interface, int family)
842{
843 struct secashead *sah;
844 struct secasvar *sav;
845 u_int stateidx;
846 u_int state;
847 const u_int *saorder_state_valid;
848 int arraysize;
849 struct sockaddr_in *sin;
850 u_int16_t dstport;
851
852 if (interface == NULL)
853 return NULL;
854
855 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
856
857 lck_mtx_lock(sadb_mutex);
858
859 LIST_FOREACH(sah, &sahtree, chain) {
860 if (sah->ipsec_if == interface &&
3e170ce0 861 (family == AF_INET6 || family == AF_INET) &&
fe8ab488
A		 862 sah->dir == IPSEC_DIR_OUTBOUND) {
863 /* This SAH is linked to the IPSec interface, and the right family. We found it! */
864 if (key_preferred_oldsa) {
865 saorder_state_valid = saorder_state_valid_prefer_old;
866 arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
867 } else {
868 saorder_state_valid = saorder_state_valid_prefer_new;
869 arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
870 }
871
872 sin = (struct sockaddr_in *)&sah->saidx.dst;
873 dstport = sin->sin_port;
874 if (sah->saidx.mode == IPSEC_MODE_TRANSPORT)
875 sin->sin_port = IPSEC_PORT_ANY;
876
877 for (stateidx = 0; stateidx < arraysize; stateidx++) {
878 state = saorder_state_valid[stateidx];
879 sav = key_do_allocsa_policy(sah, state, dstport);
880 if (sav != NULL) {
881 lck_mtx_unlock(sadb_mutex);
882 return sav;
883 }
884 }
885
886 break;
887 }
888 }
889
890 lck_mtx_unlock(sadb_mutex);
891 return NULL;
892}
893
9bccf70c
A		 894/*
895 * allocating an SA entry for an *OUTBOUND* packet.
896 * checking each request entries in SP, and acquire an SA if need.
1c79356b
A		 897 * OUT: 0: there are valid requests.
898 * ENOENT: policy may be valid, but SA with REQUIRE is on acquiring.
899 */
900int
6d2010ae 901key_checkrequest(
39236c6e
A		 902 struct ipsecrequest *isr,
903 struct secasindex *saidx,
904 struct secasvar **sav)
1c79356b
A		 905{
906 u_int level;
907 int error;
2d21ac55 908 struct sockaddr_in *sin;
39236c6e 909
2d21ac55
A		 910 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
911
912 *sav = NULL;
913
1c79356b
A		 914 /* sanity check */
915 if (isr == NULL || saidx == NULL)
916 panic("key_checkrequest: NULL pointer is passed.\n");
39236c6e 917
1c79356b
A		 918 /* check mode */
919 switch (saidx->mode) {
39236c6e
A		 920 case IPSEC_MODE_TRANSPORT:
921 case IPSEC_MODE_TUNNEL:
922 break;
923 case IPSEC_MODE_ANY:
924 default:
925 panic("key_checkrequest: Invalid policy defined.\n");
1c79356b 926 }
39236c6e 927
1c79356b
A		 928 /* get current level */
929 level = ipsec_get_reqlevel(isr);
39236c6e
A		 930
931
1c79356b 932 /*
1c79356b
A		 933 * key_allocsa_policy should allocate the oldest SA available.
934 * See key_do_allocsa_policy(), and draft-jenkins-ipsec-rekeying-03.txt.
935 */
2d21ac55
A		 936 if (*sav == NULL)
937 *sav = key_allocsa_policy(saidx);
39236c6e 938
1c79356b 939 /* When there is SA. */
2d21ac55 940 if (*sav != NULL)
1c79356b 941 return 0;
39236c6e 942
2d21ac55
A		 943 /* There is no SA.
944 *
945 * Remove dst port - used for special natt support - don't call
946 * key_acquire with it.
947 */
948 if (saidx->mode == IPSEC_MODE_TRANSPORT) {
949 sin = (struct sockaddr_in *)&saidx->dst;
950 sin->sin_port = IPSEC_PORT_ANY;
951 }
1c79356b 952 if ((error = key_acquire(saidx, isr->sp)) != 0) {
55e303ae
A		 953 /* XXX What should I do ? */
954 ipseclog((LOG_DEBUG, "key_checkrequest: error %d returned "
39236c6e 955 "from key_acquire.\n", error));
1c79356b
A		 956 return error;
957 }
39236c6e 958
1c79356b
A		 959 return level == IPSEC_LEVEL_REQUIRE ? ENOENT : 0;
960}
961
962/*
963 * allocating a SA for policy entry from SAD.
964 * NOTE: searching SAD of aliving state.
965 * OUT: NULL: not found.
966 * others: found and return the pointer.
967 */
e2fac8b1
A		 968u_int32_t sah_search_calls = 0;
969u_int32_t sah_search_count = 0;
2d21ac55 970struct secasvar *
6d2010ae 971key_allocsa_policy(
39236c6e 972 struct secasindex *saidx)
1c79356b
A		 973{
974 struct secashead *sah;
975 struct secasvar *sav;
976 u_int stateidx, state;
55e303ae
A		 977 const u_int *saorder_state_valid;
978 int arraysize;
2d21ac55
A		 979 struct sockaddr_in *sin;
980 u_int16_t dstport;
981
982 lck_mtx_lock(sadb_mutex);
e2fac8b1 983 sah_search_calls++;
1c79356b 984 LIST_FOREACH(sah, &sahtree, chain) {
39236c6e 985 sah_search_count++;
1c79356b
A		 986 if (sah->state == SADB_SASTATE_DEAD)
987 continue;
2d21ac55 988 if (key_cmpsaidx(&sah->saidx, saidx, CMP_MODE | CMP_REQID))
1c79356b
A		 989 goto found;
990 }
2d21ac55 991 lck_mtx_unlock(sadb_mutex);
1c79356b 992 return NULL;
39236c6e
A		 993
994found:
995
55e303ae
A		 996 /*
997 * search a valid state list for outbound packet.
998 * This search order is important.
999 */
1000 if (key_preferred_oldsa) {
1001 saorder_state_valid = saorder_state_valid_prefer_old;
1002 arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
1003 } else {
1004 saorder_state_valid = saorder_state_valid_prefer_new;
1005 arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
1006 }
39236c6e
A		 1007
1008
2d21ac55
A		 1009 sin = (struct sockaddr_in *)&saidx->dst;
1010 dstport = sin->sin_port;
1011 if (saidx->mode == IPSEC_MODE_TRANSPORT)
1012 sin->sin_port = IPSEC_PORT_ANY;
39236c6e 1013
55e303ae 1014 for (stateidx = 0; stateidx < arraysize; stateidx++) {
39236c6e 1015
1c79356b 1016 state = saorder_state_valid[stateidx];
39236c6e 1017
2d21ac55
A		 1018 sav = key_do_allocsa_policy(sah, state, dstport);
1019 if (sav != NULL) {
1020 lck_mtx_unlock(sadb_mutex);
1c79356b 1021 return sav;
2d21ac55 1022 }
1c79356b 1023 }
2d21ac55 1024 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 1025 return NULL;
1026}
1027
39236c6e
A		 1028static void
1029key_send_delete (struct secasvar *sav)
1030{
1031 struct mbuf *m, *result;
1032 u_int8_t satype;
1033
1034 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
1035
1036 if ((satype = key_proto2satype(sav->sah->saidx.proto)) == 0)
1037 panic("key_do_allocsa_policy: invalid proto is passed.\n");
1038
1039 m = key_setsadbmsg(SADB_DELETE, 0,
1040 satype, 0, 0, sav->refcnt - 1);
1041 if (!m)
1042 goto msgfail;
1043 result = m;
1044
1045 /* set sadb_address for saidx's. */
1046 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
1047 (struct sockaddr *)&sav->sah->saidx.src,
1048 sav->sah->saidx.src.ss_len << 3,
1049 IPSEC_ULPROTO_ANY);
1050 if (!m)
1051 goto msgfail;
1052 m_cat(result, m);
1053
1054 /* set sadb_address for saidx's. */
1055 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
1056 (struct sockaddr *)&sav->sah->saidx.dst,
1057 sav->sah->saidx.src.ss_len << 3,
1058 IPSEC_ULPROTO_ANY);
1059 if (!m)
1060 goto msgfail;
1061 m_cat(result, m);
1062
1063 /* create SA extension */
1064 m = key_setsadbsa(sav);
1065 if (!m)
1066 goto msgfail;
1067 m_cat(result, m);
1068
1069 if (result->m_len < sizeof(struct sadb_msg)) {
1070 result = m_pullup(result,
1071 sizeof(struct sadb_msg));
1072 if (result == NULL)
1073 goto msgfail;
1074 }
1075
1076 result->m_pkthdr.len = 0;
1077 for (m = result; m; m = m->m_next)
1078 result->m_pkthdr.len += m->m_len;
1079 mtod(result, struct sadb_msg *)->sadb_msg_len =
1080 PFKEY_UNIT64(result->m_pkthdr.len);
1081
1082 if (key_sendup_mbuf(NULL, result,
1083 KEY_SENDUP_REGISTERED))
1084 goto msgfail;
1085msgfail:
1086 key_freesav(sav, KEY_SADB_LOCKED);
1087}
1088
1c79356b
A		 1089/*
1090 * searching SAD with direction, protocol, mode and state.
1091 * called by key_allocsa_policy().
1092 * OUT:
1093 * NULL : not found
1094 * others : found, pointer to a SA.
1095 */
1096static struct secasvar *
6d2010ae 1097key_do_allocsa_policy(
39236c6e
A		 1098 struct secashead *sah,
1099 u_int state,
1100 u_int16_t dstport)
1c79356b 1101{
2d21ac55 1102 struct secasvar *sav, *nextsav, *candidate, *natt_candidate, *no_natt_candidate, *d;
39236c6e 1103
91447636 1104 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 1105
2d21ac55 1106 /* initialize */
1c79356b 1107 candidate = NULL;
2d21ac55
A		 1108 natt_candidate = NULL;
1109 no_natt_candidate = NULL;
39236c6e 1110
55e303ae
A		 1111 for (sav = LIST_FIRST(&sah->savtree[state]);
1112 sav != NULL;
1113 sav = nextsav) {
39236c6e 1114
55e303ae 1115 nextsav = LIST_NEXT(sav, chain);
39236c6e 1116
1c79356b
A		 1117 /* sanity check */
1118 KEY_CHKSASTATE(sav->state, state, "key_do_allocsa_policy");
39236c6e 1119
2d21ac55
A		 1120 if (sah->saidx.mode == IPSEC_MODE_TUNNEL && dstport &&
1121 ((sav->flags & SADB_X_EXT_NATT) != 0) &&
1122 ntohs(dstport) != sav->remote_ike_port)
1c79356b 1123 continue;
39236c6e 1124
2d21ac55
A		 1125 if (sah->saidx.mode == IPSEC_MODE_TRANSPORT &&
1126 ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0) &&
1127 ntohs(dstport) != sav->remote_ike_port)
1128 continue; /* skip this one - not a match - or not UDP */
39236c6e 1129
2d21ac55
A		 1130 if ((sah->saidx.mode == IPSEC_MODE_TUNNEL &&
1131 ((sav->flags & SADB_X_EXT_NATT) != 0)) ||
1132 (sah->saidx.mode == IPSEC_MODE_TRANSPORT &&
1133 ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0))) {
39236c6e
A		 1134 if (natt_candidate == NULL) {
1135 natt_candidate = sav;
1136 continue;
1137 } else
1138 candidate = natt_candidate;
1139 } else {
1140 if (no_natt_candidate == NULL) {
1141 no_natt_candidate = sav;
1142 continue;
1143 } else
1144 candidate = no_natt_candidate;
1145 }
1146
1c79356b 1147 /* Which SA is the better ? */
39236c6e 1148
1c79356b
A		 1149 /* sanity check 2 */
1150 if (candidate->lft_c == NULL || sav->lft_c == NULL)
1151 panic("key_do_allocsa_policy: "
39236c6e
A		 1152 "lifetime_current is NULL.\n");
1153
55e303ae
A		 1154 /* What the best method is to compare ? */
1155 if (key_preferred_oldsa) {
1156 if (candidate->lft_c->sadb_lifetime_addtime >
39236c6e 1157 sav->lft_c->sadb_lifetime_addtime) {
2d21ac55
A		 1158 if ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0)
1159 natt_candidate = sav;
1160 else
1161 no_natt_candidate = sav;
39236c6e 1162 }
55e303ae
A		 1163 continue;
1164 /*NOTREACHED*/
1165 }
39236c6e 1166
55e303ae
A		 1167 /* prefered new sa rather than old sa */
1168 if (candidate->lft_c->sadb_lifetime_addtime <
39236c6e 1169 sav->lft_c->sadb_lifetime_addtime) {
55e303ae 1170 d = candidate;
2d21ac55
A		 1171 if ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0)
1172 natt_candidate = sav;
1173 else
1174 no_natt_candidate = sav;
55e303ae
A		 1175 } else
1176 d = sav;
39236c6e 1177
55e303ae
A		 1178 /*
1179 * prepared to delete the SA when there is more
1180 * suitable candidate and the lifetime of the SA is not
1181 * permanent.
1182 */
1183 if (d->lft_c->sadb_lifetime_addtime != 0) {
39236c6e 1184 key_send_delete(d);
1c79356b
A		 1185 }
1186 }
39236c6e 1187
2d21ac55
A		 1188 /* choose latest if both types present */
1189 if (natt_candidate == NULL)
1190 candidate = no_natt_candidate;
1191 else if (no_natt_candidate == NULL)
1192 candidate = natt_candidate;
1193 else if (sah->saidx.mode == IPSEC_MODE_TUNNEL && dstport)
1194 candidate = natt_candidate;
1195 else if (natt_candidate->lft_c->sadb_lifetime_addtime >
39236c6e 1196 no_natt_candidate->lft_c->sadb_lifetime_addtime)
2d21ac55
A		 1197 candidate = natt_candidate;
1198 else
1199 candidate = no_natt_candidate;
39236c6e 1200
1c79356b
A		 1201 if (candidate) {
1202 candidate->refcnt++;
1203 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
39236c6e
A		 1204 printf("DP allocsa_policy cause "
1205 "refcnt++:%d SA:0x%llx\n", candidate->refcnt,
1206 (uint64_t)VM_KERNEL_ADDRPERM(candidate)));
1c79356b
A		 1207 }
1208 return candidate;
1209}
1210
1211/*
1212 * allocating a SA entry for a *INBOUND* packet.
1213 * Must call key_freesav() later.
1214 * OUT: positive: pointer to a sav.
91447636 1215 * NULL: not found, or error occurred.
1c79356b
A		 1216 *
1217 * In the comparison, source address will be ignored for RFC2401 conformance.
1218 * To quote, from section 4.1:
1219 * A security association is uniquely identified by a triple consisting
1220 * of a Security Parameter Index (SPI), an IP Destination Address, and a
1221 * security protocol (AH or ESP) identifier.
1222 * Note that, however, we do need to keep source address in IPsec SA.
9bccf70c 1223 * IKE specification and PF_KEY specification do assume that we
1c79356b
A		 1224 * keep source address in IPsec SA. We see a tricky situation here.
1225 */
1226struct secasvar *
6d2010ae 1227key_allocsa(
39236c6e
A		 1228 u_int family,
1229 caddr_t src,
1230 caddr_t dst,
1231 u_int proto,
1232 u_int32_t spi)
1c79356b 1233{
91447636
A		 1234 struct secasvar *sav, *match;
1235 u_int stateidx, state, tmpidx, matchidx;
9bccf70c
A		 1236 struct sockaddr_in sin;
1237 struct sockaddr_in6 sin6;
55e303ae
A		 1238 const u_int *saorder_state_valid;
1239 int arraysize;
2d21ac55
A		 1240
1241 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
39236c6e 1242
1c79356b
A		 1243 /* sanity check */
1244 if (src == NULL || dst == NULL)
1245 panic("key_allocsa: NULL pointer is passed.\n");
39236c6e 1246
55e303ae
A		 1247 /*
1248 * when both systems employ similar strategy to use a SA.
1249 * the search order is important even in the inbound case.
1250 */
1251 if (key_preferred_oldsa) {
1252 saorder_state_valid = saorder_state_valid_prefer_old;
1253 arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
1254 } else {
1255 saorder_state_valid = saorder_state_valid_prefer_new;
1256 arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
1257 }
39236c6e 1258
1c79356b
A		 1259 /*
1260 * searching SAD.
1261 * XXX: to be checked internal IP header somewhere. Also when
1262 * IPsec tunnel packet is received. But ESP tunnel mode is
1263 * encrypted so we can't check internal IP header.
1264 */
91447636
A		 1265 /*
1266 * search a valid state list for inbound packet.
1267 * the search order is not important.
1268 */
1269 match = NULL;
1270 matchidx = arraysize;
2d21ac55 1271 lck_mtx_lock(sadb_mutex);
91447636
A		 1272 LIST_FOREACH(sav, &spihash[SPIHASH(spi)], spihash) {
1273 if (sav->spi != spi)
1274 continue;
1275 if (proto != sav->sah->saidx.proto)
1276 continue;
1277 if (family != sav->sah->saidx.src.ss_family ||
1278 family != sav->sah->saidx.dst.ss_family)
1279 continue;
1280 tmpidx = arraysize;
1281 for (stateidx = 0; stateidx < matchidx; stateidx++) {
1c79356b 1282 state = saorder_state_valid[stateidx];
91447636
A		 1283 if (sav->state == state) {
1284 tmpidx = stateidx;
1285 break;
1286 }
1287 }
1288 if (tmpidx >= matchidx)
1289 continue;
39236c6e 1290
1c79356b 1291#if 0 /* don't check src */
91447636
A		 1292 /* check src address */
1293 switch (family) {
39236c6e
A		 1294 case AF_INET:
1295 bzero(&sin, sizeof(sin));
1296 sin.sin_family = AF_INET;
1297 sin.sin_len = sizeof(sin);
1298 bcopy(src, &sin.sin_addr,
1299 sizeof(sin.sin_addr));
1300 if (key_sockaddrcmp((struct sockaddr*)&sin,
1301 (struct sockaddr *)&sav->sah->saidx.src, 0) != 0)
1302 continue;
1303 break;
1304 case AF_INET6:
1305 bzero(&sin6, sizeof(sin6));
1306 sin6.sin6_family = AF_INET6;
1307 sin6.sin6_len = sizeof(sin6);
1308 bcopy(src, &sin6.sin6_addr,
1309 sizeof(sin6.sin6_addr));
1310 if (IN6_IS_SCOPE_LINKLOCAL(&sin6.sin6_addr)) {
1311 /* kame fake scopeid */
1312 sin6.sin6_scope_id =
1313 ntohs(sin6.sin6_addr.s6_addr16[1]);
1314 sin6.sin6_addr.s6_addr16[1] = 0;
1315 }
1316 if (key_sockaddrcmp((struct sockaddr*)&sin6,
1317 (struct sockaddr *)&sav->sah->saidx.src, 0) != 0)
1318 continue;
1319 break;
1320 default:
1321 ipseclog((LOG_DEBUG, "key_allocsa: "
1322 "unknown address family=%d.\n",
1323 family));
91447636 1324 continue;
91447636 1325 }
39236c6e 1326
1c79356b 1327#endif
91447636
A		 1328 /* check dst address */
1329 switch (family) {
39236c6e
A		 1330 case AF_INET:
1331 bzero(&sin, sizeof(sin));
1332 sin.sin_family = AF_INET;
1333 sin.sin_len = sizeof(sin);
1334 bcopy(dst, &sin.sin_addr,
1335 sizeof(sin.sin_addr));
1336 if (key_sockaddrcmp((struct sockaddr*)&sin,
1337 (struct sockaddr *)&sav->sah->saidx.dst, 0) != 0)
1338 continue;
1339
1340 break;
1341 case AF_INET6:
1342 bzero(&sin6, sizeof(sin6));
1343 sin6.sin6_family = AF_INET6;
1344 sin6.sin6_len = sizeof(sin6);
1345 bcopy(dst, &sin6.sin6_addr,
1346 sizeof(sin6.sin6_addr));
1347 if (IN6_IS_SCOPE_LINKLOCAL(&sin6.sin6_addr)) {
1348 /* kame fake scopeid */
1349 sin6.sin6_scope_id =
1350 ntohs(sin6.sin6_addr.s6_addr16[1]);
1351 sin6.sin6_addr.s6_addr16[1] = 0;
1352 }
1353 if (key_sockaddrcmp((struct sockaddr*)&sin6,
1354 (struct sockaddr *)&sav->sah->saidx.dst, 0) != 0)
1355 continue;
1356 break;
1357 default:
1358 ipseclog((LOG_DEBUG, "key_allocsa: "
1359 "unknown address family=%d.\n", family));
91447636 1360 continue;
1c79356b 1361 }
39236c6e 1362
91447636
A		 1363 match = sav;
1364 matchidx = tmpidx;
1c79356b 1365 }
91447636
A		 1366 if (match)
1367 goto found;
39236c6e 1368
1c79356b 1369 /* not found */
2d21ac55 1370 lck_mtx_unlock(sadb_mutex);
1c79356b 1371 return NULL;
39236c6e 1372
1c79356b 1373found:
2d21ac55
A		 1374 match->refcnt++;
1375 lck_mtx_unlock(sadb_mutex);
1c79356b 1376 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
39236c6e
A		 1377 printf("DP allocsa cause refcnt++:%d SA:0x%llx\n",
1378 match->refcnt, (uint64_t)VM_KERNEL_ADDRPERM(match)));
91447636 1379 return match;
1c79356b
A		 1380}
1381
2d21ac55 1382u_int16_t
6d2010ae 1383key_natt_get_translated_port(
39236c6e 1384 struct secasvar *outsav)
2d21ac55 1385{
39236c6e 1386
2d21ac55
A		 1387 struct secasindex saidx;
1388 struct secashead *sah;
1389 u_int stateidx, state;
1390 const u_int *saorder_state_valid;
1391 int arraysize;
1392
1393 /* get sa for incoming */
1394 saidx.mode = outsav->sah->saidx.mode;
1395 saidx.reqid = 0;
1396 saidx.proto = outsav->sah->saidx.proto;
1397 bcopy(&outsav->sah->saidx.src, &saidx.dst, sizeof(struct sockaddr_in));
1398 bcopy(&outsav->sah->saidx.dst, &saidx.src, sizeof(struct sockaddr_in));
1399
1400 lck_mtx_lock(sadb_mutex);
1401 LIST_FOREACH(sah, &sahtree, chain) {
1402 if (sah->state == SADB_SASTATE_DEAD)
1403 continue;
1404 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_MODE))
1405 goto found;
1406 }
1407 lck_mtx_unlock(sadb_mutex);
1408 return 0;
39236c6e 1409
2d21ac55 1410found:
39236c6e 1411 /*
2d21ac55
A		 1412 * Found sah - now go thru list of SAs and find
1413 * matching remote ike port. If found - set
1414 * sav->natt_encapsulated_src_port and return the port.
1415 */
1416 /*
1417 * search a valid state list for outbound packet.
1418 * This search order is important.
1419 */
1420 if (key_preferred_oldsa) {
1421 saorder_state_valid = saorder_state_valid_prefer_old;
1422 arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
1423 } else {
1424 saorder_state_valid = saorder_state_valid_prefer_new;
1425 arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
1426 }
39236c6e 1427
2d21ac55
A		 1428 for (stateidx = 0; stateidx < arraysize; stateidx++) {
1429 state = saorder_state_valid[stateidx];
1430 if (key_do_get_translated_port(sah, outsav, state)) {
1431 lck_mtx_unlock(sadb_mutex);
1432 return outsav->natt_encapsulated_src_port;
1433 }
1434 }
1435 lck_mtx_unlock(sadb_mutex);
1436 return 0;
1437}
1438
1439static int
6d2010ae 1440key_do_get_translated_port(
39236c6e
A		 1441 struct secashead *sah,
1442 struct secasvar *outsav,
1443 u_int state)
2d21ac55
A		 1444{
1445 struct secasvar *currsav, *nextsav, *candidate;
39236c6e
A		 1446
1447
2d21ac55
A		 1448 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
1449
1450 /* initilize */
1451 candidate = NULL;
39236c6e 1452
2d21ac55
A		 1453 for (currsav = LIST_FIRST(&sah->savtree[state]);
1454 currsav != NULL;
1455 currsav = nextsav) {
39236c6e 1456
2d21ac55 1457 nextsav = LIST_NEXT(currsav, chain);
39236c6e 1458
2d21ac55
A		 1459 /* sanity check */
1460 KEY_CHKSASTATE(currsav->state, state, "key_do_get_translated_port");
1461
1462 if ((currsav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) == 0 ||
1463 currsav->remote_ike_port != outsav->remote_ike_port)
1464 continue;
39236c6e 1465
2d21ac55
A		 1466 if (candidate == NULL) {
1467 candidate = currsav;
1468 continue;
1469 }
1470
1471 /* Which SA is the better ? */
39236c6e 1472
2d21ac55
A		 1473 /* sanity check 2 */
1474 if (candidate->lft_c == NULL || currsav->lft_c == NULL)
1475 panic("key_do_get_translated_port: "
39236c6e
A		 1476 "lifetime_current is NULL.\n");
1477
2d21ac55
A		 1478 /* What the best method is to compare ? */
1479 if (key_preferred_oldsa) {
1480 if (candidate->lft_c->sadb_lifetime_addtime >
39236c6e 1481 currsav->lft_c->sadb_lifetime_addtime) {
2d21ac55
A		 1482 candidate = currsav;
1483 }
1484 continue;
1485 /*NOTREACHED*/
1486 }
39236c6e 1487
2d21ac55
A		 1488 /* prefered new sa rather than old sa */
1489 if (candidate->lft_c->sadb_lifetime_addtime <
39236c6e 1490 currsav->lft_c->sadb_lifetime_addtime)
2d21ac55
A		 1491 candidate = currsav;
1492 }
39236c6e
A		 1493
1494 if (candidate) {
2d21ac55
A		 1495 outsav->natt_encapsulated_src_port = candidate->natt_encapsulated_src_port;
1496 return 1;
1497 }
39236c6e 1498
2d21ac55
A		 1499 return 0;
1500}
1501
1c79356b
A		 1502/*
1503 * Must be called after calling key_allocsp().
1c79356b
A		 1504 */
1505void
6d2010ae 1506key_freesp(
39236c6e
A		 1507 struct secpolicy *sp,
1508 int locked)
1c79356b 1509{
39236c6e 1510
1c79356b
A		 1511 /* sanity check */
1512 if (sp == NULL)
1513 panic("key_freesp: NULL pointer is passed.\n");
2d21ac55
A		 1514
1515 if (!locked)
1516 lck_mtx_lock(sadb_mutex);
1517 else
1518 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
1c79356b
A		 1519 sp->refcnt--;
1520 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
39236c6e
A		 1521 printf("DP freesp cause refcnt--:%d SP:0x%llx\n",
1522 sp->refcnt, (uint64_t)VM_KERNEL_ADDRPERM(sp)));
1523
1c79356b
A		 1524 if (sp->refcnt == 0)
1525 key_delsp(sp);
2d21ac55
A		 1526 if (!locked)
1527 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 1528 return;
1529}
1530
1c79356b
A		 1531/*
1532 * Must be called after calling key_allocsa().
1533 * This function is called by key_freesp() to free some SA allocated
1534 * for a policy.
1535 */
1536void
6d2010ae 1537key_freesav(
39236c6e
A		 1538 struct secasvar *sav,
1539 int locked)
1c79356b 1540{
39236c6e 1541
1c79356b
A		 1542 /* sanity check */
1543 if (sav == NULL)
1544 panic("key_freesav: NULL pointer is passed.\n");
39236c6e 1545
2d21ac55
A		 1546 if (!locked)
1547 lck_mtx_lock(sadb_mutex);
1548 else
1549 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
1c79356b
A		 1550 sav->refcnt--;
1551 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
39236c6e
A		 1552 printf("DP freesav cause refcnt--:%d SA:0x%llx SPI %u\n",
1553 sav->refcnt, (uint64_t)VM_KERNEL_ADDRPERM(sav),
1554 (u_int32_t)ntohl(sav->spi)));
1555
1c79356b
A		 1556 if (sav->refcnt == 0)
1557 key_delsav(sav);
2d21ac55
A		 1558 if (!locked)
1559 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 1560 return;
1561}
1562
1563/* %%% SPD management */
1564/*
1565 * free security policy entry.
1566 */
1567static void
6d2010ae 1568key_delsp(
39236c6e 1569 struct secpolicy *sp)
1c79356b 1570{
39236c6e 1571
1c79356b
A		 1572 /* sanity check */
1573 if (sp == NULL)
1574 panic("key_delsp: NULL pointer is passed.\n");
39236c6e 1575
2d21ac55 1576 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
1c79356b 1577 sp->state = IPSEC_SPSTATE_DEAD;
39236c6e 1578
1c79356b
A		 1579 if (sp->refcnt > 0)
1580 return; /* can't free */
39236c6e 1581
1c79356b 1582 /* remove from SP index */
2d21ac55 1583 if (__LIST_CHAINED(sp)) {
1c79356b 1584 LIST_REMOVE(sp, chain);
2d21ac55
A		 1585 ipsec_policy_count--;
1586 }
39236c6e
A		 1587
1588 if (sp->spidx.internal_if) {
1589 ifnet_release(sp->spidx.internal_if);
1590 sp->spidx.internal_if = NULL;
1591 }
1592
1593 if (sp->ipsec_if) {
1594 ifnet_release(sp->ipsec_if);
1595 sp->ipsec_if = NULL;
1596 }
1597
1598 if (sp->outgoing_if) {
1599 ifnet_release(sp->outgoing_if);
1600 sp->outgoing_if = NULL;
1601 }
1602
1c79356b 1603 {
2d21ac55 1604 struct ipsecrequest *isr = sp->req, *nextisr;
39236c6e 1605
2d21ac55
A		 1606 while (isr != NULL) {
1607 nextisr = isr->next;
1608 KFREE(isr);
1609 isr = nextisr;
1610 }
1c79356b 1611 }
1c79356b 1612 keydb_delsecpolicy(sp);
39236c6e 1613
1c79356b
A		 1614 return;
1615}
1616
1617/*
1618 * search SPD
1619 * OUT: NULL : not found
1620 * others : found, pointer to a SP.
1621 */
1622static struct secpolicy *
6d2010ae 1623key_getsp(
39236c6e 1624 struct secpolicyindex *spidx)
1c79356b
A		 1625{
1626 struct secpolicy *sp;
39236c6e 1627
91447636 1628 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 1629
1c79356b
A		 1630 /* sanity check */
1631 if (spidx == NULL)
1632 panic("key_getsp: NULL pointer is passed.\n");
39236c6e 1633
1c79356b
A		 1634 LIST_FOREACH(sp, &sptree[spidx->dir], chain) {
1635 if (sp->state == IPSEC_SPSTATE_DEAD)
1636 continue;
1637 if (key_cmpspidx_exactly(spidx, &sp->spidx)) {
1638 sp->refcnt++;
1639 return sp;
1640 }
1641 }
39236c6e 1642
1c79356b
A		 1643 return NULL;
1644}
1645
1646/*
1647 * get SP by index.
1648 * OUT: NULL : not found
1649 * others : found, pointer to a SP.
1650 */
39236c6e 1651struct secpolicy *
6d2010ae 1652key_getspbyid(
39236c6e 1653 u_int32_t id)
1c79356b
A		 1654{
1655 struct secpolicy *sp;
39236c6e
A		 1656
1657 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
1658
1659 lck_mtx_lock(sadb_mutex);
1660 sp = __key_getspbyid(id);
1661 lck_mtx_unlock(sadb_mutex);
1662
1663 return sp;
1664}
1c79356b 1665
39236c6e
A		 1666static struct secpolicy *
1667__key_getspbyid(u_int32_t id)
1668{
1669 struct secpolicy *sp;
1670
91447636 1671 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 1672
1c79356b
A		 1673 LIST_FOREACH(sp, &sptree[IPSEC_DIR_INBOUND], chain) {
1674 if (sp->state == IPSEC_SPSTATE_DEAD)
1675 continue;
1676 if (sp->id == id) {
1677 sp->refcnt++;
1678 return sp;
1679 }
1680 }
39236c6e 1681
1c79356b
A		 1682 LIST_FOREACH(sp, &sptree[IPSEC_DIR_OUTBOUND], chain) {
1683 if (sp->state == IPSEC_SPSTATE_DEAD)
1684 continue;
1685 if (sp->id == id) {
1686 sp->refcnt++;
1687 return sp;
1688 }
1689 }
39236c6e 1690
1c79356b
A		 1691 return NULL;
1692}
1693
1694struct secpolicy *
6d2010ae 1695key_newsp(void)
1c79356b
A		 1696{
1697 struct secpolicy *newsp = NULL;
2d21ac55
A		 1698
1699 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
1c79356b
A		 1700 newsp = keydb_newsecpolicy();
1701 if (!newsp)
1702 return newsp;
39236c6e 1703
1c79356b
A		 1704 newsp->refcnt = 1;
1705 newsp->req = NULL;
39236c6e 1706
1c79356b
A		 1707 return newsp;
1708}
1709
1710/*
1711 * create secpolicy structure from sadb_x_policy structure.
1712 * NOTE: `state', `secpolicyindex' in secpolicy structure are not set,
1713 * so must be set properly later.
1714 */
1715struct secpolicy *
6d2010ae 1716key_msg2sp(
39236c6e
A		 1717 struct sadb_x_policy *xpl0,
1718 size_t len,
1719 int *error)
1c79356b
A		 1720{
1721 struct secpolicy *newsp;
39236c6e 1722
2d21ac55
A		 1723 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
1724
1c79356b
A		 1725 /* sanity check */
1726 if (xpl0 == NULL)
1727 panic("key_msg2sp: NULL pointer was passed.\n");
1728 if (len < sizeof(*xpl0))
1729 panic("key_msg2sp: invalid length.\n");
1730 if (len != PFKEY_EXTLEN(xpl0)) {
55e303ae 1731 ipseclog((LOG_DEBUG, "key_msg2sp: Invalid msg length.\n"));
1c79356b
A		 1732 *error = EINVAL;
1733 return NULL;
1734 }
39236c6e 1735
1c79356b
A		 1736 if ((newsp = key_newsp()) == NULL) {
1737 *error = ENOBUFS;
1738 return NULL;
1739 }
39236c6e 1740
1c79356b
A		 1741 newsp->spidx.dir = xpl0->sadb_x_policy_dir;
1742 newsp->policy = xpl0->sadb_x_policy_type;
39236c6e 1743
1c79356b
A		 1744 /* check policy */
1745 switch (xpl0->sadb_x_policy_type) {
39236c6e 1746 case IPSEC_POLICY_DISCARD:
2d21ac55 1747 case IPSEC_POLICY_GENERATE:
39236c6e
A		 1748 case IPSEC_POLICY_NONE:
1749 case IPSEC_POLICY_ENTRUST:
1750 case IPSEC_POLICY_BYPASS:
1751 newsp->req = NULL;
1752 break;
1753
1754 case IPSEC_POLICY_IPSEC:
1c79356b 1755 {
39236c6e
A		 1756 int tlen;
1757 struct sadb_x_ipsecrequest *xisr;
1758 struct ipsecrequest **p_isr = &newsp->req;
1759
1760 /* validity check */
1761 if (PFKEY_EXTLEN(xpl0) < sizeof(*xpl0)) {
55e303ae 1762 ipseclog((LOG_DEBUG,
39236c6e 1763 "key_msg2sp: Invalid msg length.\n"));
2d21ac55 1764 key_freesp(newsp, KEY_SADB_UNLOCKED);
1c79356b
A		 1765 *error = EINVAL;
1766 return NULL;
1767 }
39236c6e
A		 1768
1769 tlen = PFKEY_EXTLEN(xpl0) - sizeof(*xpl0);
1770 xisr = (struct sadb_x_ipsecrequest *)(xpl0 + 1);
1771
1772 while (tlen > 0) {
1773
1774 /* length check */
1775 if (xisr->sadb_x_ipsecrequest_len < sizeof(*xisr)) {
1776 ipseclog((LOG_DEBUG, "key_msg2sp: "
1777 "invalid ipsecrequest length.\n"));
1778 key_freesp(newsp, KEY_SADB_UNLOCKED);
1779 *error = EINVAL;
1780 return NULL;
1781 }
1782
1783 /* allocate request buffer */
1784 KMALLOC_WAIT(*p_isr, struct ipsecrequest *, sizeof(**p_isr));
1785 if ((*p_isr) == NULL) {
55e303ae 1786 ipseclog((LOG_DEBUG,
39236c6e
A		 1787 "key_msg2sp: No more memory.\n"));
1788 key_freesp(newsp, KEY_SADB_UNLOCKED);
1789 *error = ENOBUFS;
1790 return NULL;
1c79356b 1791 }
39236c6e
A		 1792 bzero(*p_isr, sizeof(**p_isr));
1793
1794 /* set values */
1795 (*p_isr)->next = NULL;
1796
1797 switch (xisr->sadb_x_ipsecrequest_proto) {
1798 case IPPROTO_ESP:
1799 case IPPROTO_AH:
1800 case IPPROTO_IPCOMP:
1801 break;
1802 default:
1803 ipseclog((LOG_DEBUG,
1804 "key_msg2sp: invalid proto type=%u\n",
1805 xisr->sadb_x_ipsecrequest_proto));
2d21ac55 1806 key_freesp(newsp, KEY_SADB_UNLOCKED);
39236c6e 1807 *error = EPROTONOSUPPORT;
1c79356b 1808 return NULL;
1c79356b 1809 }
39236c6e
A		 1810 (*p_isr)->saidx.proto = xisr->sadb_x_ipsecrequest_proto;
1811
1812 switch (xisr->sadb_x_ipsecrequest_mode) {
1813 case IPSEC_MODE_TRANSPORT:
1814 case IPSEC_MODE_TUNNEL:
1815 break;
1816 case IPSEC_MODE_ANY:
1817 default:
1818 ipseclog((LOG_DEBUG,
1819 "key_msg2sp: invalid mode=%u\n",
1820 xisr->sadb_x_ipsecrequest_mode));
1821 key_freesp(newsp, KEY_SADB_UNLOCKED);
1822 *error = EINVAL;
1823 return NULL;
1c79356b 1824 }
39236c6e
A		 1825 (*p_isr)->saidx.mode = xisr->sadb_x_ipsecrequest_mode;
1826
1827 switch (xisr->sadb_x_ipsecrequest_level) {
1828 case IPSEC_LEVEL_DEFAULT:
1829 case IPSEC_LEVEL_USE:
1830 case IPSEC_LEVEL_REQUIRE:
1831 break;
1832 case IPSEC_LEVEL_UNIQUE:
1833 /* validity check */
1834 /*
1835 * If range violation of reqid, kernel will
1836 * update it, don't refuse it.
1837 */
1838 if (xisr->sadb_x_ipsecrequest_reqid
1839 > IPSEC_MANUAL_REQID_MAX) {
1840 ipseclog((LOG_DEBUG,
1841 "key_msg2sp: reqid=%d range "
1842 "violation, updated by kernel.\n",
1843 xisr->sadb_x_ipsecrequest_reqid));
1844 xisr->sadb_x_ipsecrequest_reqid = 0;
1845 }
1846
1847 /* allocate new reqid id if reqid is zero. */
1848 if (xisr->sadb_x_ipsecrequest_reqid == 0) {
1849 u_int32_t reqid;
1850 if ((reqid = key_newreqid()) == 0) {
1851 key_freesp(newsp, KEY_SADB_UNLOCKED);
1852 *error = ENOBUFS;
1853 return NULL;
1854 }
1855 (*p_isr)->saidx.reqid = reqid;
1856 xisr->sadb_x_ipsecrequest_reqid = reqid;
1857 } else {
1858 /* set it for manual keying. */
1859 (*p_isr)->saidx.reqid =
1860 xisr->sadb_x_ipsecrequest_reqid;
1861 }
1862 break;
1863
1864 default:
1865 ipseclog((LOG_DEBUG, "key_msg2sp: invalid level=%u\n",
1866 xisr->sadb_x_ipsecrequest_level));
1867 key_freesp(newsp, KEY_SADB_UNLOCKED);
1868 *error = EINVAL;
1869 return NULL;
1870 }
1871 (*p_isr)->level = xisr->sadb_x_ipsecrequest_level;
1872
1873 /* set IP addresses if there */
1874 if (xisr->sadb_x_ipsecrequest_len > sizeof(*xisr)) {
1875 struct sockaddr *paddr;
1876
1877 paddr = (struct sockaddr *)(xisr + 1);
1878
1879 /* validity check */
1880 if (paddr->sa_len
1881 > sizeof((*p_isr)->saidx.src)) {
1882 ipseclog((LOG_DEBUG, "key_msg2sp: invalid request "
1883 "address length.\n"));
1884 key_freesp(newsp, KEY_SADB_UNLOCKED);
1885 *error = EINVAL;
1886 return NULL;
1887 }
1888 bcopy(paddr, &(*p_isr)->saidx.src,
1889 paddr->sa_len);
1890
1891 paddr = (struct sockaddr *)((caddr_t)paddr
1892 + paddr->sa_len);
1893
1894 /* validity check */
1895 if (paddr->sa_len
1896 > sizeof((*p_isr)->saidx.dst)) {
1897 ipseclog((LOG_DEBUG, "key_msg2sp: invalid request "
1898 "address length.\n"));
1899 key_freesp(newsp, KEY_SADB_UNLOCKED);
1900 *error = EINVAL;
1901 return NULL;
1902 }
1903 bcopy(paddr, &(*p_isr)->saidx.dst,
1904 paddr->sa_len);
1905 }
1906
1907 (*p_isr)->sp = newsp;
1908
1909 /* initialization for the next. */
1910 p_isr = &(*p_isr)->next;
1911 tlen -= xisr->sadb_x_ipsecrequest_len;
1912
1c79356b 1913 /* validity check */
39236c6e
A		 1914 if (tlen < 0) {
1915 ipseclog((LOG_DEBUG, "key_msg2sp: becoming tlen < 0.\n"));
2d21ac55 1916 key_freesp(newsp, KEY_SADB_UNLOCKED);
1c79356b
A		 1917 *error = EINVAL;
1918 return NULL;
1919 }
39236c6e
A		 1920
1921 xisr = (struct sadb_x_ipsecrequest *)(void *)
316670eb 1922 ((caddr_t)xisr + xisr->sadb_x_ipsecrequest_len);
39236c6e 1923 }
1c79356b 1924 }
39236c6e
A		 1925 break;
1926 default:
1927 ipseclog((LOG_DEBUG, "key_msg2sp: invalid policy type.\n"));
1928 key_freesp(newsp, KEY_SADB_UNLOCKED);
1929 *error = EINVAL;
1930 return NULL;
1c79356b 1931 }
39236c6e 1932
1c79356b
A		 1933 *error = 0;
1934 return newsp;
1935}
1936
1937static u_int32_t
6d2010ae 1938key_newreqid(void)
1c79356b 1939{
2d21ac55 1940 lck_mtx_lock(sadb_mutex);
1c79356b 1941 static u_int32_t auto_reqid = IPSEC_MANUAL_REQID_MAX + 1;
316670eb 1942 int done = 0;
39236c6e 1943
316670eb 1944 /* The reqid must be limited to 16 bits because the PF_KEY message format only uses
39236c6e
A		 1945 16 bits for this field. Once it becomes larger than 16 bits - ipsec fails to
1946 work anymore. Changing the PF_KEY message format would introduce compatibility
1947 issues. This code now tests to see if the tentative reqid is in use */
1948
316670eb
A		 1949 while (!done) {
1950 struct secpolicy *sp;
39236c6e 1951 struct ipsecrequest *isr;
316670eb 1952 int dir;
39236c6e 1953
316670eb 1954 auto_reqid = (auto_reqid == 0xFFFF
39236c6e
A		 1955 ? IPSEC_MANUAL_REQID_MAX + 1 : auto_reqid + 1);
1956
316670eb
A		 1957 /* check for uniqueness */
1958 done = 1;
1959 for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
1960 LIST_FOREACH(sp, &sptree[dir], chain) {
1961 for (isr = sp->req; isr != NULL; isr = isr->next) {
1962 if (isr->saidx.reqid == auto_reqid) {
1963 done = 0;
1964 break;
1965 }
1966 }
1967 if (done == 0)
1968 break;
1969 }
1970 if (done == 0)
1971 break;
39236c6e 1972 }
316670eb 1973 }
39236c6e 1974
316670eb 1975 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 1976 return auto_reqid;
1977}
1978
1979/*
1980 * copy secpolicy struct to sadb_x_policy structure indicated.
1981 */
1982struct mbuf *
6d2010ae 1983key_sp2msg(
39236c6e 1984 struct secpolicy *sp)
1c79356b
A		 1985{
1986 struct sadb_x_policy *xpl;
1987 int tlen;
1988 caddr_t p;
1989 struct mbuf *m;
39236c6e 1990
1c79356b
A		 1991 /* sanity check. */
1992 if (sp == NULL)
1993 panic("key_sp2msg: NULL pointer was passed.\n");
39236c6e 1994
1c79356b 1995 tlen = key_getspreqmsglen(sp);
39236c6e 1996
9bccf70c
A		 1997 m = key_alloc_mbuf(tlen);
1998 if (!m || m->m_next) { /*XXX*/
1c79356b 1999 if (m)
9bccf70c 2000 m_freem(m);
1c79356b
A		 2001 return NULL;
2002 }
39236c6e 2003
1c79356b
A		 2004 m->m_len = tlen;
2005 m->m_next = NULL;
2006 xpl = mtod(m, struct sadb_x_policy *);
2007 bzero(xpl, tlen);
39236c6e 2008
1c79356b
A		 2009 xpl->sadb_x_policy_len = PFKEY_UNIT64(tlen);
2010 xpl->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
2011 xpl->sadb_x_policy_type = sp->policy;
2012 xpl->sadb_x_policy_dir = sp->spidx.dir;
2013 xpl->sadb_x_policy_id = sp->id;
2014 p = (caddr_t)xpl + sizeof(*xpl);
39236c6e 2015
1c79356b
A		 2016 /* if is the policy for ipsec ? */
2017 if (sp->policy == IPSEC_POLICY_IPSEC) {
2018 struct sadb_x_ipsecrequest *xisr;
2019 struct ipsecrequest *isr;
39236c6e 2020
1c79356b 2021 for (isr = sp->req; isr != NULL; isr = isr->next) {
39236c6e 2022
316670eb 2023 xisr = (struct sadb_x_ipsecrequest *)(void *)p;
39236c6e 2024
1c79356b
A		 2025 xisr->sadb_x_ipsecrequest_proto = isr->saidx.proto;
2026 xisr->sadb_x_ipsecrequest_mode = isr->saidx.mode;
2027 xisr->sadb_x_ipsecrequest_level = isr->level;
2028 xisr->sadb_x_ipsecrequest_reqid = isr->saidx.reqid;
39236c6e 2029
1c79356b
A		 2030 p += sizeof(*xisr);
2031 bcopy(&isr->saidx.src, p, isr->saidx.src.ss_len);
2032 p += isr->saidx.src.ss_len;
2033 bcopy(&isr->saidx.dst, p, isr->saidx.dst.ss_len);
2034 p += isr->saidx.src.ss_len;
39236c6e 2035
1c79356b 2036 xisr->sadb_x_ipsecrequest_len =
39236c6e
A		 2037 PFKEY_ALIGN8(sizeof(*xisr)
2038 + isr->saidx.src.ss_len
2039 + isr->saidx.dst.ss_len);
1c79356b
A		 2040 }
2041 }
39236c6e 2042
1c79356b
A		 2043 return m;
2044}
2045
9bccf70c
A		 2046/* m will not be freed nor modified */
2047static struct mbuf *
2048key_gather_mbuf(struct mbuf *m, const struct sadb_msghdr *mhp,
39236c6e 2049 int ndeep, int nitem, int *items)
9bccf70c
A		 2050{
2051 int idx;
2052 int i;
2053 struct mbuf *result = NULL, *n;
2054 int len;
39236c6e 2055
9bccf70c
A		 2056 if (m == NULL || mhp == NULL)
2057 panic("null pointer passed to key_gather");
39236c6e 2058
9bccf70c
A		 2059 for (i = 0; i < nitem; i++) {
2060 idx = items[i];
2061 if (idx < 0 || idx > SADB_EXT_MAX)
2062 goto fail;
2063 /* don't attempt to pull empty extension */
2064 if (idx == SADB_EXT_RESERVED && mhp->msg == NULL)
2065 continue;
2066 if (idx != SADB_EXT_RESERVED &&
2067 (mhp->ext[idx] == NULL || mhp->extlen[idx] == 0))
2068 continue;
39236c6e 2069
9bccf70c
A		 2070 if (idx == SADB_EXT_RESERVED) {
2071 len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
39236c6e 2072 MGETHDR(n, M_WAITOK, MT_DATA); // sadb_msg len < MHLEN - enforced by _CASSERT
9bccf70c
A		 2073 if (!n)
2074 goto fail;
2075 n->m_len = len;
2076 n->m_next = NULL;
2077 m_copydata(m, 0, sizeof(struct sadb_msg),
39236c6e 2078 mtod(n, caddr_t));
9bccf70c
A		 2079 } else if (i < ndeep) {
2080 len = mhp->extlen[idx];
2081 n = key_alloc_mbuf(len);
2082 if (!n || n->m_next) { /*XXX*/
2083 if (n)
2084 m_freem(n);
2085 goto fail;
2086 }
2087 m_copydata(m, mhp->extoff[idx], mhp->extlen[idx],
39236c6e 2088 mtod(n, caddr_t));
9bccf70c
A		 2089 } else {
2090 n = m_copym(m, mhp->extoff[idx], mhp->extlen[idx],
39236c6e 2091 M_WAITOK);
9bccf70c
A		 2092 }
2093 if (n == NULL)
2094 goto fail;
39236c6e 2095
9bccf70c
A		 2096 if (result)
2097 m_cat(result, n);
2098 else
2099 result = n;
2100 }
39236c6e 2101
9bccf70c
A		 2102 if ((result->m_flags & M_PKTHDR) != 0) {
2103 result->m_pkthdr.len = 0;
2104 for (n = result; n; n = n->m_next)
2105 result->m_pkthdr.len += n->m_len;
2106 }
39236c6e 2107
9bccf70c 2108 return result;
39236c6e 2109
9bccf70c
A		 2110fail:
2111 m_freem(result);
2112 return NULL;
2113}
2114
1c79356b
A		 2115/*
2116 * SADB_X_SPDADD, SADB_X_SPDSETIDX or SADB_X_SPDUPDATE processing
2117 * add a entry to SP database, when received
9bccf70c 2118 * <base, address(SD), (lifetime(H),) policy>
1c79356b
A		 2119 * from the user(?).
2120 * Adding to SP database,
2121 * and send
9bccf70c 2122 * <base, address(SD), (lifetime(H),) policy>
1c79356b
A		 2123 * to the socket which was send.
2124 *
2125 * SPDADD set a unique policy entry.
2126 * SPDSETIDX like SPDADD without a part of policy requests.
2127 * SPDUPDATE replace a unique policy entry.
2128 *
9bccf70c 2129 * m will always be freed.
1c79356b 2130 */
9bccf70c 2131static int
6d2010ae 2132key_spdadd(
39236c6e
A		 2133 struct socket *so,
2134 struct mbuf *m,
2135 const struct sadb_msghdr *mhp)
1c79356b 2136{
39236c6e 2137 struct sadb_address *src0, *dst0, *src1, *dst1;
9bccf70c
A		 2138 struct sadb_x_policy *xpl0, *xpl;
2139 struct sadb_lifetime *lft = NULL;
1c79356b
A		 2140 struct secpolicyindex spidx;
2141 struct secpolicy *newsp;
9bccf70c 2142 struct timeval tv;
39236c6e
A		 2143 ifnet_t internal_if = NULL;
2144 char *outgoing_if = NULL;
2145 char *ipsec_if = NULL;
2146 struct sadb_x_ipsecif *ipsecifopts = NULL;
1c79356b 2147 int error;
39236c6e
A		 2148 int use_src_range = 0;
2149 int use_dst_range = 0;
2150 int init_disabled = 0;
2151 int address_family, address_len;
2152
2d21ac55
A		 2153 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2154
1c79356b 2155 /* sanity check */
9bccf70c 2156 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 2157 panic("key_spdadd: NULL pointer is passed.\n");
39236c6e
A		 2158
2159 if (mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_START] != NULL && mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_END] != NULL) {
2160 use_src_range = 1;
2161 }
2162 if (mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_START] != NULL && mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_END] != NULL) {
2163 use_dst_range = 1;
2164 }
2165
2166 if ((!use_src_range && mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL) ||
2167 (!use_dst_range && mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) ||
9bccf70c 2168 mhp->ext[SADB_X_EXT_POLICY] == NULL) {
55e303ae 2169 ipseclog((LOG_DEBUG, "key_spdadd: invalid message is passed.\n"));
9bccf70c
A		 2170 return key_senderror(so, m, EINVAL);
2171 }
39236c6e
A		 2172 if ((use_src_range && (mhp->extlen[SADB_X_EXT_ADDR_RANGE_SRC_START] < sizeof(struct sadb_address)
2173 || mhp->extlen[SADB_X_EXT_ADDR_RANGE_SRC_END] < sizeof(struct sadb_address))) ||
2174 (!use_src_range && mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address)) ||
2175 (use_dst_range && (mhp->extlen[SADB_X_EXT_ADDR_RANGE_DST_START] < sizeof(struct sadb_address)
2176 || mhp->extlen[SADB_X_EXT_ADDR_RANGE_DST_END] < sizeof(struct sadb_address))) ||
2177 (!use_dst_range && mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) ||
9bccf70c 2178 mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
55e303ae 2179 ipseclog((LOG_DEBUG, "key_spdadd: invalid message is passed.\n"));
9bccf70c
A		 2180 return key_senderror(so, m, EINVAL);
2181 }
2182 if (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL) {
2183 if (mhp->extlen[SADB_EXT_LIFETIME_HARD]
2184 < sizeof(struct sadb_lifetime)) {
55e303ae 2185 ipseclog((LOG_DEBUG, "key_spdadd: invalid message is passed.\n"));
9bccf70c
A		 2186 return key_senderror(so, m, EINVAL);
2187 }
316670eb 2188 lft = (struct sadb_lifetime *)
39236c6e 2189 (void *)mhp->ext[SADB_EXT_LIFETIME_HARD];
1c79356b 2190 }
39236c6e
A		 2191 if (mhp->ext[SADB_X_EXT_IPSECIF] != NULL) {
2192 if (mhp->extlen[SADB_X_EXT_IPSECIF] < sizeof(struct sadb_x_ipsecif)) {
2193 ipseclog((LOG_DEBUG, "key_spdadd: invalid message is passed.\n"));
2194 return key_senderror(so, m, EINVAL);
2195 }
2196 }
2197
2198 if (use_src_range) {
2199 src0 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_START];
2200 src1 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_END];
2201 } else {
2202 src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
2203 }
2204 if (use_dst_range) {
2205 dst0 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_START];
2206 dst1 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_END];
2207 } else {
2208 dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
2209 }
316670eb 2210 xpl0 = (struct sadb_x_policy *)(void *)mhp->ext[SADB_X_EXT_POLICY];
39236c6e
A		 2211 ipsecifopts = (struct sadb_x_ipsecif *)(void *)mhp->ext[SADB_X_EXT_IPSECIF];
2212
2213 /* check addresses */
2214 address_family = ((struct sockaddr *)(src0 + 1))->sa_family;
2215 address_len = ((struct sockaddr *)(src0 + 1))->sa_len;
2216 if (use_src_range) {
2217 if (((struct sockaddr *)(src1+ 1))->sa_family != address_family ||
2218 ((struct sockaddr *)(src1+ 1))->sa_len != address_len) {
2219 return key_senderror(so, m, EINVAL);
2220 }
2221 }
2222 if (((struct sockaddr *)(dst0+ 1))->sa_family != address_family ||
2223 ((struct sockaddr *)(dst0+ 1))->sa_len != address_len) {
2224 return key_senderror(so, m, EINVAL);
2225 }
2226 if (use_dst_range) {
2227 if (((struct sockaddr *)(dst1+ 1))->sa_family != address_family ||
2228 ((struct sockaddr *)(dst1+ 1))->sa_len != address_len) {
2229 return key_senderror(so, m, EINVAL);
2230 }
2231 }
2232
fe8ab488 2233 /* checking the direction. */
1c79356b 2234 switch (xpl0->sadb_x_policy_dir) {
39236c6e
A		 2235 case IPSEC_DIR_INBOUND:
2236 case IPSEC_DIR_OUTBOUND:
2237 break;
2238 default:
2239 ipseclog((LOG_DEBUG, "key_spdadd: Invalid SP direction.\n"));
2240 mhp->msg->sadb_msg_errno = EINVAL;
2241 return 0;
2242 }
2243
2244 /* check policy */
1c79356b
A		 2245 /* key_spdadd() accepts DISCARD, NONE and IPSEC. */
2246 if (xpl0->sadb_x_policy_type == IPSEC_POLICY_ENTRUST
39236c6e 2247 || xpl0->sadb_x_policy_type == IPSEC_POLICY_BYPASS) {
55e303ae 2248 ipseclog((LOG_DEBUG, "key_spdadd: Invalid policy type.\n"));
9bccf70c 2249 return key_senderror(so, m, EINVAL);
1c79356b 2250 }
39236c6e 2251
1c79356b 2252 /* policy requests are mandatory when action is ipsec. */
39236c6e
A		 2253 if (mhp->msg->sadb_msg_type != SADB_X_SPDSETIDX
2254 && xpl0->sadb_x_policy_type == IPSEC_POLICY_IPSEC
2255 && mhp->extlen[SADB_X_EXT_POLICY] <= sizeof(*xpl0)) {
55e303ae 2256 ipseclog((LOG_DEBUG, "key_spdadd: some policy requests part required.\n"));
9bccf70c 2257 return key_senderror(so, m, EINVAL);
1c79356b 2258 }
39236c6e
A		 2259
2260 /* Process interfaces */
2261 if (ipsecifopts != NULL) {
3e170ce0 2262 if (ipsecifopts->sadb_x_ipsecif_internal_if[0]) {
39236c6e
A		 2263 ifnet_find_by_name(ipsecifopts->sadb_x_ipsecif_internal_if, &internal_if);
2264 }
3e170ce0 2265 if (ipsecifopts->sadb_x_ipsecif_outgoing_if[0]) {
39236c6e
A		 2266 outgoing_if = ipsecifopts->sadb_x_ipsecif_outgoing_if;
2267 }
3e170ce0 2268 if (ipsecifopts->sadb_x_ipsecif_ipsec_if[0]) {
39236c6e
A		 2269 ipsec_if = ipsecifopts->sadb_x_ipsecif_ipsec_if;
2270 }
2271 init_disabled = ipsecifopts->sadb_x_ipsecif_init_disabled;
2272 }
2273
2274 /* make secindex */
2275 /* XXX boundary check against sa_len */
2276 KEY_SETSECSPIDX(xpl0->sadb_x_policy_dir,
2277 src0 + 1,
2278 dst0 + 1,
2279 src0->sadb_address_prefixlen,
2280 dst0->sadb_address_prefixlen,
2281 src0->sadb_address_proto,
2282 internal_if,
2283 use_src_range ? src0 + 1 : NULL,
2284 use_src_range ? src1 + 1 : NULL,
2285 use_dst_range ? dst0 + 1 : NULL,
2286 use_dst_range ? dst1 + 1 : NULL,
2287 &spidx);
2288
1c79356b
A		 2289 /*
2290 * checking there is SP already or not.
55e303ae
A		 2291 * SPDUPDATE doesn't depend on whether there is a SP or not.
2292 * If the type is either SPDADD or SPDSETIDX AND a SP is found,
2293 * then error.
1c79356b 2294 */
2d21ac55 2295 lck_mtx_lock(sadb_mutex);
1c79356b 2296 newsp = key_getsp(&spidx);
9bccf70c 2297 if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) {
55e303ae
A		 2298 if (newsp) {
2299 newsp->state = IPSEC_SPSTATE_DEAD;
2d21ac55 2300 key_freesp(newsp, KEY_SADB_LOCKED);
1c79356b 2301 }
1c79356b
A		 2302 } else {
2303 if (newsp != NULL) {
2d21ac55 2304 key_freesp(newsp, KEY_SADB_LOCKED);
55e303ae 2305 ipseclog((LOG_DEBUG, "key_spdadd: a SP entry exists already.\n"));
2d21ac55 2306 lck_mtx_unlock(sadb_mutex);
39236c6e
A		 2307 if (internal_if) {
2308 ifnet_release(internal_if);
2309 internal_if = NULL;
2310 }
9bccf70c 2311 return key_senderror(so, m, EEXIST);
1c79356b
A		 2312 }
2313 }
2d21ac55 2314 lck_mtx_unlock(sadb_mutex);
39236c6e 2315
1c79356b
A		 2316 /* allocation new SP entry */
2317 if ((newsp = key_msg2sp(xpl0, PFKEY_EXTLEN(xpl0), &error)) == NULL) {
39236c6e
A		 2318 if (internal_if) {
2319 ifnet_release(internal_if);
2320 internal_if = NULL;
2321 }
9bccf70c 2322 return key_senderror(so, m, error);
1c79356b 2323 }
39236c6e 2324
1c79356b 2325 if ((newsp->id = key_getnewspid()) == 0) {
1c79356b 2326 keydb_delsecpolicy(newsp);
39236c6e
A		 2327 if (internal_if) {
2328 ifnet_release(internal_if);
2329 internal_if = NULL;
2330 }
9bccf70c 2331 return key_senderror(so, m, ENOBUFS);
1c79356b 2332 }
39236c6e 2333
9bccf70c 2334 /* XXX boundary check against sa_len */
1c79356b
A		 2335 KEY_SETSECSPIDX(xpl0->sadb_x_policy_dir,
2336 src0 + 1,
2337 dst0 + 1,
2338 src0->sadb_address_prefixlen,
2339 dst0->sadb_address_prefixlen,
2340 src0->sadb_address_proto,
39236c6e
A		 2341 internal_if,
2342 use_src_range ? src0 + 1 : NULL,
2343 use_src_range ? src1 + 1 : NULL,
2344 use_dst_range ? dst0 + 1 : NULL,
2345 use_dst_range ? dst1 + 1 : NULL,
1c79356b 2346 &newsp->spidx);
39236c6e 2347
1c79356b 2348#if 1
39236c6e 2349 /*
490019cf 2350 * allow IPv6 over IPv4 or IPv4 over IPv6 tunnels using ESP -
39236c6e 2351 * otherwise reject if inner and outer address families not equal
2d21ac55 2352 */
1c79356b
A		 2353 if (newsp->req && newsp->req->saidx.src.ss_family) {
2354 struct sockaddr *sa;
2355 sa = (struct sockaddr *)(src0 + 1);
2356 if (sa->sa_family != newsp->req->saidx.src.ss_family) {
490019cf 2357 if (newsp->req->saidx.mode != IPSEC_MODE_TUNNEL || newsp->req->saidx.proto != IPPROTO_ESP) {
2d21ac55 2358 keydb_delsecpolicy(newsp);
39236c6e
A		 2359 if (internal_if) {
2360 ifnet_release(internal_if);
2361 internal_if = NULL;
2362 }
2d21ac55
A		 2363 return key_senderror(so, m, EINVAL);
2364 }
1c79356b
A		 2365 }
2366 }
2367 if (newsp->req && newsp->req->saidx.dst.ss_family) {
2368 struct sockaddr *sa;
2369 sa = (struct sockaddr *)(dst0 + 1);
2370 if (sa->sa_family != newsp->req->saidx.dst.ss_family) {
490019cf 2371 if (newsp->req->saidx.mode != IPSEC_MODE_TUNNEL || newsp->req->saidx.proto != IPPROTO_ESP) {
2d21ac55 2372 keydb_delsecpolicy(newsp);
39236c6e
A		 2373 if (internal_if) {
2374 ifnet_release(internal_if);
2375 internal_if = NULL;
2376 }
2d21ac55
A		 2377 return key_senderror(so, m, EINVAL);
2378 }
1c79356b
A		 2379 }
2380 }
2381#endif
39236c6e 2382
9bccf70c
A		 2383 microtime(&tv);
2384 newsp->created = tv.tv_sec;
2385 newsp->lastused = tv.tv_sec;
2386 newsp->lifetime = lft ? lft->sadb_lifetime_addtime : 0;
2387 newsp->validtime = lft ? lft->sadb_lifetime_usetime : 0;
39236c6e
A		 2388
2389 if (outgoing_if != NULL) {
2390 ifnet_find_by_name(outgoing_if, &newsp->outgoing_if);
2391 }
2392 if (ipsec_if != NULL) {
2393 ifnet_find_by_name(ipsec_if, &newsp->ipsec_if);
2394 }
2395 if (init_disabled > 0) {
2396 newsp->disabled = 1;
2397 }
2398
1c79356b
A		 2399 newsp->refcnt = 1; /* do not reclaim until I say I do */
2400 newsp->state = IPSEC_SPSTATE_ALIVE;
2d21ac55
A		 2401 lck_mtx_lock(sadb_mutex);
2402 /*
2403 * policies of type generate should be at the end of the SPD
2404 * because they function as default discard policies
39236c6e
A		 2405 * Don't start timehandler for generate policies
2406 */
2407 if (newsp->policy == IPSEC_POLICY_GENERATE)
2d21ac55
A		 2408 LIST_INSERT_TAIL(&sptree[newsp->spidx.dir], newsp, secpolicy, chain);
2409 else { /* XXX until we have policy ordering in the kernel */
2410 struct secpolicy *tmpsp;
39236c6e 2411
2d21ac55 2412 LIST_FOREACH(tmpsp, &sptree[newsp->spidx.dir], chain)
39236c6e
A		 2413 if (tmpsp->policy == IPSEC_POLICY_GENERATE)
2414 break;
2d21ac55
A		 2415 if (tmpsp)
2416 LIST_INSERT_BEFORE(tmpsp, newsp, chain);
2417 else
2418 LIST_INSERT_TAIL(&sptree[newsp->spidx.dir], newsp, secpolicy, chain);
39236c6e 2419 key_start_timehandler();
2d21ac55 2420 }
39236c6e 2421
2d21ac55 2422 ipsec_policy_count++;
9bccf70c
A		 2423 /* Turn off the ipsec bypass */
2424 if (ipsec_bypass != 0)
2425 ipsec_bypass = 0;
39236c6e 2426
1c79356b 2427 /* delete the entry in spacqtree */
9bccf70c 2428 if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) {
1c79356b
A		 2429 struct secspacq *spacq;
2430 if ((spacq = key_getspacq(&spidx)) != NULL) {
9bccf70c
A		 2431 /* reset counter in order to deletion by timehandler. */
2432 microtime(&tv);
2433 spacq->created = tv.tv_sec;
1c79356b
A		 2434 spacq->count = 0;
2435 }
2d21ac55
A		 2436 }
2437 lck_mtx_unlock(sadb_mutex);
39236c6e 2438
1c79356b 2439 {
39236c6e
A		 2440 struct mbuf *n, *mpolicy;
2441 struct sadb_msg *newmsg;
2442 int off;
2443
2444 /* create new sadb_msg to reply. */
2445 if (lft) {
2446 int mbufItems[] = {SADB_EXT_RESERVED, SADB_X_EXT_POLICY,
2447 SADB_EXT_LIFETIME_HARD, SADB_EXT_ADDRESS_SRC,
2448 SADB_EXT_ADDRESS_DST, SADB_X_EXT_ADDR_RANGE_SRC_START, SADB_X_EXT_ADDR_RANGE_SRC_END,
2449 SADB_X_EXT_ADDR_RANGE_DST_START, SADB_X_EXT_ADDR_RANGE_DST_END};
2450 n = key_gather_mbuf(m, mhp, 2, sizeof(mbufItems)/sizeof(int), mbufItems);
2451 } else {
2452 int mbufItems[] = {SADB_EXT_RESERVED, SADB_X_EXT_POLICY,
2453 SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST,
2454 SADB_X_EXT_ADDR_RANGE_SRC_START, SADB_X_EXT_ADDR_RANGE_SRC_END,
2455 SADB_X_EXT_ADDR_RANGE_DST_START, SADB_X_EXT_ADDR_RANGE_DST_END};
2456 n = key_gather_mbuf(m, mhp, 2, sizeof(mbufItems)/sizeof(int), mbufItems);
2457 }
9bccf70c
A		 2458 if (!n)
2459 return key_senderror(so, m, ENOBUFS);
39236c6e
A		 2460
2461 if (n->m_len < sizeof(*newmsg)) {
2462 n = m_pullup(n, sizeof(*newmsg));
2463 if (!n)
2464 return key_senderror(so, m, ENOBUFS);
2465 }
2466 newmsg = mtod(n, struct sadb_msg *);
2467 newmsg->sadb_msg_errno = 0;
2468 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2469
2470 off = 0;
2471 mpolicy = m_pulldown(n, PFKEY_ALIGN8(sizeof(struct sadb_msg)),
2472 sizeof(*xpl), &off);
2473 if (mpolicy == NULL) {
2474 /* n is already freed */
2475 return key_senderror(so, m, ENOBUFS);
2476 }
2477 xpl = (struct sadb_x_policy *)(void *)(mtod(mpolicy, caddr_t) + off);
2478 if (xpl->sadb_x_policy_exttype != SADB_X_EXT_POLICY) {
2479 m_freem(n);
2480 return key_senderror(so, m, EINVAL);
2481 }
2482 xpl->sadb_x_policy_id = newsp->id;
2483
2484 m_freem(m);
2485 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
1c79356b
A		 2486 }
2487}
2488
2489/*
2490 * get new policy id.
2491 * OUT:
2492 * 0: failure.
2493 * others: success.
2494 */
2495static u_int32_t
6d2010ae 2496key_getnewspid(void)
1c79356b
A		 2497{
2498 u_int32_t newid = 0;
2499 int count = key_spi_trycnt; /* XXX */
2500 struct secpolicy *sp;
2d21ac55 2501
1c79356b 2502 /* when requesting to allocate spi ranged */
2d21ac55 2503 lck_mtx_lock(sadb_mutex);
1c79356b 2504 while (count--) {
55e303ae 2505 newid = (policy_id = (policy_id == ~0 ? 1 : policy_id + 1));
39236c6e
A		 2506
2507 if ((sp = __key_getspbyid(newid)) == NULL)
1c79356b 2508 break;
39236c6e 2509
2d21ac55 2510 key_freesp(sp, KEY_SADB_LOCKED);
1c79356b 2511 }
2d21ac55 2512 lck_mtx_unlock(sadb_mutex);
1c79356b 2513 if (count == 0 || newid == 0) {
55e303ae 2514 ipseclog((LOG_DEBUG, "key_getnewspid: to allocate policy id is failed.\n"));
1c79356b
A		 2515 return 0;
2516 }
39236c6e 2517
1c79356b
A		 2518 return newid;
2519}
2520
2521/*
2522 * SADB_SPDDELETE processing
2523 * receive
2524 * <base, address(SD), policy(*)>
2525 * from the user(?), and set SADB_SASTATE_DEAD,
2526 * and send,
2527 * <base, address(SD), policy(*)>
2528 * to the ikmpd.
2529 * policy(*) including direction of policy.
2530 *
9bccf70c 2531 * m will always be freed.
1c79356b 2532 */
9bccf70c 2533static int
6d2010ae 2534key_spddelete(
39236c6e
A		 2535 struct socket *so,
2536 struct mbuf *m,
2537 const struct sadb_msghdr *mhp)
1c79356b 2538{
39236c6e 2539 struct sadb_address *src0, *dst0, *src1, *dst1;
1c79356b
A		 2540 struct sadb_x_policy *xpl0;
2541 struct secpolicyindex spidx;
2542 struct secpolicy *sp;
39236c6e
A		 2543 ifnet_t internal_if = NULL;
2544 struct sadb_x_ipsecif *ipsecifopts = NULL;
2545 int use_src_range = 0;
2546 int use_dst_range = 0;
2d21ac55 2547
39236c6e
A		 2548 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2549
1c79356b 2550 /* sanity check */
9bccf70c 2551 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 2552 panic("key_spddelete: NULL pointer is passed.\n");
39236c6e
A		 2553
2554 if (mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_START] != NULL && mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_END] != NULL) {
2555 use_src_range = 1;
2556 }
2557 if (mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_START] != NULL && mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_END] != NULL) {
2558 use_dst_range = 1;
2559 }
2560
2561 if ((!use_src_range && mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL) ||
2562 (!use_dst_range && mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) ||
9bccf70c 2563 mhp->ext[SADB_X_EXT_POLICY] == NULL) {
55e303ae 2564 ipseclog((LOG_DEBUG, "key_spddelete: invalid message is passed.\n"));
9bccf70c
A		 2565 return key_senderror(so, m, EINVAL);
2566 }
39236c6e
A		 2567 if ((use_src_range && (mhp->extlen[SADB_X_EXT_ADDR_RANGE_SRC_START] < sizeof(struct sadb_address)
2568 || mhp->extlen[SADB_X_EXT_ADDR_RANGE_SRC_END] < sizeof(struct sadb_address))) ||
2569 (!use_src_range && mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address)) ||
2570 (use_dst_range && (mhp->extlen[SADB_X_EXT_ADDR_RANGE_DST_START] < sizeof(struct sadb_address)
2571 || mhp->extlen[SADB_X_EXT_ADDR_RANGE_DST_END] < sizeof(struct sadb_address))) ||
2572 (!use_dst_range && mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) ||
9bccf70c 2573 mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
55e303ae 2574 ipseclog((LOG_DEBUG, "key_spddelete: invalid message is passed.\n"));
9bccf70c 2575 return key_senderror(so, m, EINVAL);
1c79356b 2576 }
39236c6e
A		 2577
2578 if (use_src_range) {
2579 src0 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_START];
2580 src1 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_SRC_END];
2581 } else {
2582 src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
2583 }
2584 if (use_dst_range) {
2585 dst0 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_START];
2586 dst1 = (struct sadb_address *)mhp->ext[SADB_X_EXT_ADDR_RANGE_DST_END];
2587 } else {
2588 dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
2589 }
316670eb 2590 xpl0 = (struct sadb_x_policy *)(void *)mhp->ext[SADB_X_EXT_POLICY];
39236c6e
A		 2591 ipsecifopts = (struct sadb_x_ipsecif *)(void *)mhp->ext[SADB_X_EXT_IPSECIF];
2592
fe8ab488 2593 /* checking the direction. */
39236c6e
A		 2594 switch (xpl0->sadb_x_policy_dir) {
2595 case IPSEC_DIR_INBOUND:
2596 case IPSEC_DIR_OUTBOUND:
2597 break;
2598 default:
2599 ipseclog((LOG_DEBUG, "key_spddelete: Invalid SP direction.\n"));
2600 return key_senderror(so, m, EINVAL);
2601 }
2602
2603 /* Process interfaces */
2604 if (ipsecifopts != NULL) {
3e170ce0 2605 if (ipsecifopts->sadb_x_ipsecif_internal_if[0]) {
39236c6e
A		 2606 ifnet_find_by_name(ipsecifopts->sadb_x_ipsecif_internal_if, &internal_if);
2607 }
2608 }
2609
1c79356b 2610 /* make secindex */
9bccf70c 2611 /* XXX boundary check against sa_len */
1c79356b
A		 2612 KEY_SETSECSPIDX(xpl0->sadb_x_policy_dir,
2613 src0 + 1,
2614 dst0 + 1,
2615 src0->sadb_address_prefixlen,
2616 dst0->sadb_address_prefixlen,
2617 src0->sadb_address_proto,
39236c6e
A		 2618 internal_if,
2619 use_src_range ? src0 + 1 : NULL,
2620 use_src_range ? src1 + 1 : NULL,
2621 use_dst_range ? dst0 + 1 : NULL,
2622 use_dst_range ? dst1 + 1 : NULL,
1c79356b 2623 &spidx);
39236c6e 2624
1c79356b 2625 /* Is there SP in SPD ? */
2d21ac55 2626 lck_mtx_lock(sadb_mutex);
1c79356b 2627 if ((sp = key_getsp(&spidx)) == NULL) {
55e303ae 2628 ipseclog((LOG_DEBUG, "key_spddelete: no SP found.\n"));
2d21ac55 2629 lck_mtx_unlock(sadb_mutex);
39236c6e
A		 2630 if (internal_if) {
2631 ifnet_release(internal_if);
2632 internal_if = NULL;
2633 }
9bccf70c 2634 return key_senderror(so, m, EINVAL);
1c79356b 2635 }
39236c6e
A		 2636
2637 if (internal_if) {
2638 ifnet_release(internal_if);
2639 internal_if = NULL;
2640 }
2641
1c79356b
A		 2642 /* save policy id to buffer to be returned. */
2643 xpl0->sadb_x_policy_id = sp->id;
39236c6e 2644
1c79356b 2645 sp->state = IPSEC_SPSTATE_DEAD;
2d21ac55
A		 2646 key_freesp(sp, KEY_SADB_LOCKED);
2647 lck_mtx_unlock(sadb_mutex);
39236c6e
A		 2648
2649
1c79356b 2650 {
39236c6e
A		 2651 struct mbuf *n;
2652 struct sadb_msg *newmsg;
2653 int mbufItems[] = {SADB_EXT_RESERVED, SADB_X_EXT_POLICY,
2654 SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST,
2655 SADB_X_EXT_ADDR_RANGE_SRC_START, SADB_X_EXT_ADDR_RANGE_SRC_END,
2656 SADB_X_EXT_ADDR_RANGE_DST_START, SADB_X_EXT_ADDR_RANGE_DST_END};
2657
2658 /* create new sadb_msg to reply. */
2659 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
2660 if (!n)
2661 return key_senderror(so, m, ENOBUFS);
2662
2663 newmsg = mtod(n, struct sadb_msg *);
2664 newmsg->sadb_msg_errno = 0;
2665 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2666
2667 m_freem(m);
2668 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
1c79356b
A		 2669 }
2670}
2671
2672/*
2673 * SADB_SPDDELETE2 processing
2674 * receive
2675 * <base, policy(*)>
2676 * from the user(?), and set SADB_SASTATE_DEAD,
2677 * and send,
2678 * <base, policy(*)>
2679 * to the ikmpd.
2680 * policy(*) including direction of policy.
2681 *
9bccf70c 2682 * m will always be freed.
1c79356b 2683 */
9bccf70c 2684static int
6d2010ae 2685key_spddelete2(
39236c6e
A		 2686 struct socket *so,
2687 struct mbuf *m,
2688 const struct sadb_msghdr *mhp)
1c79356b 2689{
1c79356b
A		 2690 u_int32_t id;
2691 struct secpolicy *sp;
39236c6e 2692
2d21ac55
A		 2693 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2694
1c79356b 2695 /* sanity check */
9bccf70c 2696 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 2697 panic("key_spddelete2: NULL pointer is passed.\n");
39236c6e 2698
9bccf70c
A		 2699 if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2700 mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
55e303ae 2701 ipseclog((LOG_DEBUG, "key_spddelete2: invalid message is passed.\n"));
9bccf70c
A		 2702 key_senderror(so, m, EINVAL);
2703 return 0;
1c79356b 2704 }
39236c6e 2705
316670eb 2706 id = ((struct sadb_x_policy *)
39236c6e
A		 2707 (void *)mhp->ext[SADB_X_EXT_POLICY])->sadb_x_policy_id;
2708
1c79356b 2709 /* Is there SP in SPD ? */
2d21ac55 2710 lck_mtx_lock(sadb_mutex);
39236c6e 2711 if ((sp = __key_getspbyid(id)) == NULL) {
2d21ac55 2712 lck_mtx_unlock(sadb_mutex);
55e303ae 2713 ipseclog((LOG_DEBUG, "key_spddelete2: no SP found id:%u.\n", id));
2d21ac55 2714 return key_senderror(so, m, EINVAL);
1c79356b 2715 }
39236c6e 2716
1c79356b 2717 sp->state = IPSEC_SPSTATE_DEAD;
2d21ac55
A		 2718 key_freesp(sp, KEY_SADB_LOCKED);
2719 lck_mtx_unlock(sadb_mutex);
39236c6e 2720
1c79356b 2721 {
39236c6e
A		 2722 struct mbuf *n, *nn;
2723 struct sadb_msg *newmsg;
2724 int off, len;
2725
2726 /* create new sadb_msg to reply. */
2727 len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
2728
2729 if (len > MCLBYTES)
2730 return key_senderror(so, m, ENOBUFS);
2731 MGETHDR(n, M_WAITOK, MT_DATA);
2732 if (n && len > MHLEN) {
2733 MCLGET(n, M_WAITOK);
2734 if ((n->m_flags & M_EXT) == 0) {
2735 m_freem(n);
2736 n = NULL;
2737 }
9bccf70c 2738 }
39236c6e
A		 2739 if (!n)
2740 return key_senderror(so, m, ENOBUFS);
2741
2742 n->m_len = len;
2743 n->m_next = NULL;
2744 off = 0;
2745
2746 m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, caddr_t) + off);
2747 off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
2748
9bccf70c 2749#if DIAGNOSTIC
39236c6e
A		 2750 if (off != len)
2751 panic("length inconsistency in key_spddelete2");
1c79356b 2752#endif
39236c6e
A		 2753
2754 n->m_next = m_copym(m, mhp->extoff[SADB_X_EXT_POLICY],
2755 mhp->extlen[SADB_X_EXT_POLICY], M_WAITOK);
2756 if (!n->m_next) {
2757 m_freem(n);
2758 return key_senderror(so, m, ENOBUFS);
2759 }
2760
2761 n->m_pkthdr.len = 0;
2762 for (nn = n; nn; nn = nn->m_next)
2763 n->m_pkthdr.len += nn->m_len;
2764
2765 newmsg = mtod(n, struct sadb_msg *);
2766 newmsg->sadb_msg_errno = 0;
2767 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2768
2769 m_freem(m);
2770 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2771 }
2772}
9bccf70c 2773
39236c6e
A		 2774static int
2775key_spdenable(
2776 struct socket *so,
2777 struct mbuf *m,
2778 const struct sadb_msghdr *mhp)
2779{
2780 u_int32_t id;
2781 struct secpolicy *sp;
2782
2783 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2784
2785 /* sanity check */
2786 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
2787 panic("key_spdenable: NULL pointer is passed.\n");
2788
2789 if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2790 mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2791 ipseclog((LOG_DEBUG, "key_spdenable: invalid message is passed.\n"));
2792 key_senderror(so, m, EINVAL);
2793 return 0;
2794 }
2795
2796 id = ((struct sadb_x_policy *)
2797 (void *)mhp->ext[SADB_X_EXT_POLICY])->sadb_x_policy_id;
2798
2799 /* Is there SP in SPD ? */
2800 lck_mtx_lock(sadb_mutex);
2801 if ((sp = __key_getspbyid(id)) == NULL) {
2802 lck_mtx_unlock(sadb_mutex);
2803 ipseclog((LOG_DEBUG, "key_spdenable: no SP found id:%u.\n", id));
2804 return key_senderror(so, m, EINVAL);
2805 }
2806
2807 sp->disabled = 0;
2808 lck_mtx_unlock(sadb_mutex);
2809
2810 {
2811 struct mbuf *n;
2812 struct sadb_msg *newmsg;
2813 int mbufItems[] = {SADB_EXT_RESERVED, SADB_X_EXT_POLICY};
2814
2815 /* create new sadb_msg to reply. */
2816 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
2817 if (!n)
2818 return key_senderror(so, m, ENOBUFS);
2819
2820 if (n->m_len < sizeof(struct sadb_msg)) {
2821 n = m_pullup(n, sizeof(struct sadb_msg));
2822 if (n == NULL)
2823 return key_senderror(so, m, ENOBUFS);
2824 }
2825 newmsg = mtod(n, struct sadb_msg *);
2826 newmsg->sadb_msg_errno = 0;
2827 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2828
2829 m_freem(m);
2830 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2831 }
2832}
1c79356b 2833
39236c6e
A		 2834static int
2835key_spddisable(
2836 struct socket *so,
2837 struct mbuf *m,
2838 const struct sadb_msghdr *mhp)
2839{
2840 u_int32_t id;
2841 struct secpolicy *sp;
2842
2843 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2844
2845 /* sanity check */
2846 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
2847 panic("key_spddisable: NULL pointer is passed.\n");
2848
2849 if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2850 mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2851 ipseclog((LOG_DEBUG, "key_spddisable: invalid message is passed.\n"));
2852 key_senderror(so, m, EINVAL);
2853 return 0;
2854 }
2855
2856 id = ((struct sadb_x_policy *)
2857 (void *)mhp->ext[SADB_X_EXT_POLICY])->sadb_x_policy_id;
2858
2859 /* Is there SP in SPD ? */
2860 lck_mtx_lock(sadb_mutex);
2861 if ((sp = __key_getspbyid(id)) == NULL) {
2862 lck_mtx_unlock(sadb_mutex);
2863 ipseclog((LOG_DEBUG, "key_spddisable: no SP found id:%u.\n", id));
2864 return key_senderror(so, m, EINVAL);
2865 }
2866
2867 sp->disabled = 1;
2868 lck_mtx_unlock(sadb_mutex);
2869
2870 {
2871 struct mbuf *n;
2872 struct sadb_msg *newmsg;
2873 int mbufItems[] = {SADB_EXT_RESERVED, SADB_X_EXT_POLICY};
2874
2875 /* create new sadb_msg to reply. */
2876 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
2877 if (!n)
2878 return key_senderror(so, m, ENOBUFS);
2879
2880 if (n->m_len < sizeof(struct sadb_msg)) {
2881 n = m_pullup(n, sizeof(struct sadb_msg));
2882 if (n == NULL)
2883 return key_senderror(so, m, ENOBUFS);
2884 }
2885 newmsg = mtod(n, struct sadb_msg *);
2886 newmsg->sadb_msg_errno = 0;
2887 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2888
2889 m_freem(m);
2890 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
1c79356b
A		 2891 }
2892}
2893
2894/*
2895 * SADB_X_GET processing
2896 * receive
2897 * <base, policy(*)>
2898 * from the user(?),
2899 * and send,
2900 * <base, address(SD), policy>
2901 * to the ikmpd.
2902 * policy(*) including direction of policy.
2903 *
9bccf70c 2904 * m will always be freed.
1c79356b
A		 2905 */
2906static int
6d2010ae 2907key_spdget(
39236c6e
A		 2908 struct socket *so,
2909 struct mbuf *m,
2910 const struct sadb_msghdr *mhp)
1c79356b 2911{
1c79356b
A		 2912 u_int32_t id;
2913 struct secpolicy *sp;
9bccf70c 2914 struct mbuf *n;
39236c6e 2915
2d21ac55
A		 2916 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2917
1c79356b 2918 /* sanity check */
9bccf70c 2919 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 2920 panic("key_spdget: NULL pointer is passed.\n");
39236c6e 2921
9bccf70c
A		 2922 if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2923 mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
55e303ae 2924 ipseclog((LOG_DEBUG, "key_spdget: invalid message is passed.\n"));
9bccf70c 2925 return key_senderror(so, m, EINVAL);
1c79356b 2926 }
39236c6e 2927
316670eb 2928 id = ((struct sadb_x_policy *)
39236c6e
A		 2929 (void *)mhp->ext[SADB_X_EXT_POLICY])->sadb_x_policy_id;
2930
1c79356b 2931 /* Is there SP in SPD ? */
2d21ac55 2932 lck_mtx_lock(sadb_mutex);
39236c6e 2933 if ((sp = __key_getspbyid(id)) == NULL) {
55e303ae 2934 ipseclog((LOG_DEBUG, "key_spdget: no SP found id:%u.\n", id));
2d21ac55 2935 lck_mtx_unlock(sadb_mutex);
9bccf70c 2936 return key_senderror(so, m, ENOENT);
1c79356b 2937 }
2d21ac55 2938 lck_mtx_unlock(sadb_mutex);
9bccf70c
A		 2939 n = key_setdumpsp(sp, SADB_X_SPDGET, 0, mhp->msg->sadb_msg_pid);
2940 if (n != NULL) {
2941 m_freem(m);
2942 return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
2943 } else
2944 return key_senderror(so, m, ENOBUFS);
1c79356b
A		 2945}
2946
2947/*
2948 * SADB_X_SPDACQUIRE processing.
2949 * Acquire policy and SA(s) for a *OUTBOUND* packet.
2950 * send
2951 * <base, policy(*)>
2952 * to KMD, and expect to receive
91447636 2953 * <base> with SADB_X_SPDACQUIRE if error occurred,
1c79356b
A		 2954 * or
2955 * <base, policy>
2956 * with SADB_X_SPDUPDATE from KMD by PF_KEY.
2957 * policy(*) is without policy requests.
2958 *
2959 * 0 : succeed
2960 * others: error number
2961 */
2962int
6d2010ae 2963key_spdacquire(
39236c6e 2964 struct secpolicy *sp)
1c79356b 2965{
9bccf70c 2966 struct mbuf *result = NULL, *m;
1c79356b
A		 2967 struct secspacq *newspacq;
2968 int error;
39236c6e 2969
2d21ac55
A		 2970 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
2971
1c79356b
A		 2972 /* sanity check */
2973 if (sp == NULL)
2974 panic("key_spdacquire: NULL pointer is passed.\n");
2975 if (sp->req != NULL)
2976 panic("key_spdacquire: called but there is request.\n");
2977 if (sp->policy != IPSEC_POLICY_IPSEC)
2978 panic("key_spdacquire: policy mismathed. IPsec is expected.\n");
39236c6e 2979
1c79356b 2980 /* get a entry to check whether sent message or not. */
2d21ac55 2981 lck_mtx_lock(sadb_mutex);
1c79356b
A		 2982 if ((newspacq = key_getspacq(&sp->spidx)) != NULL) {
2983 if (key_blockacq_count < newspacq->count) {
2984 /* reset counter and do send message. */
2985 newspacq->count = 0;
2986 } else {
2987 /* increment counter and do nothing. */
2988 newspacq->count++;
2d21ac55 2989 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 2990 return 0;
2991 }
2992 } else {
2993 /* make new entry for blocking to send SADB_ACQUIRE. */
2d21ac55
A		 2994 if ((newspacq = key_newspacq(&sp->spidx)) == NULL) {
2995 lck_mtx_unlock(sadb_mutex);
1c79356b 2996 return ENOBUFS;
2d21ac55 2997 }
1c79356b
A		 2998 /* add to acqtree */
2999 LIST_INSERT_HEAD(&spacqtree, newspacq, chain);
39236c6e 3000 key_start_timehandler();
1c79356b 3001 }
2d21ac55 3002 lck_mtx_unlock(sadb_mutex);
1c79356b 3003 /* create new sadb_msg to reply. */
9bccf70c
A		 3004 m = key_setsadbmsg(SADB_X_SPDACQUIRE, 0, 0, 0, 0, 0);
3005 if (!m) {
3006 error = ENOBUFS;
3007 goto fail;
1c79356b 3008 }
9bccf70c 3009 result = m;
39236c6e 3010
9bccf70c
A		 3011 result->m_pkthdr.len = 0;
3012 for (m = result; m; m = m->m_next)
3013 result->m_pkthdr.len += m->m_len;
39236c6e 3014
9bccf70c 3015 mtod(result, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 3016 PFKEY_UNIT64(result->m_pkthdr.len);
3017
9bccf70c 3018 return key_sendup_mbuf(NULL, m, KEY_SENDUP_REGISTERED);
39236c6e 3019
9bccf70c
A		 3020fail:
3021 if (result)
3022 m_freem(result);
3023 return error;
3024}
3025
3026/*
1c79356b
A		 3027 * SADB_SPDFLUSH processing
3028 * receive
3029 * <base>
3030 * from the user, and free all entries in secpctree.
3031 * and send,
3032 * <base>
3033 * to the user.
3034 * NOTE: what to do is only marking SADB_SASTATE_DEAD.
3035 *
9bccf70c 3036 * m will always be freed.
1c79356b 3037 */
9bccf70c 3038static int
6d2010ae 3039key_spdflush(
39236c6e
A		 3040 struct socket *so,
3041 struct mbuf *m,
3042 const struct sadb_msghdr *mhp)
1c79356b 3043{
9bccf70c 3044 struct sadb_msg *newmsg;
1c79356b
A		 3045 struct secpolicy *sp;
3046 u_int dir;
2d21ac55 3047
1c79356b 3048 /* sanity check */
9bccf70c 3049 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 3050 panic("key_spdflush: NULL pointer is passed.\n");
39236c6e 3051
9bccf70c
A		 3052 if (m->m_len != PFKEY_ALIGN8(sizeof(struct sadb_msg)))
3053 return key_senderror(so, m, EINVAL);
39236c6e 3054
2d21ac55 3055 lck_mtx_lock(sadb_mutex);
1c79356b
A		 3056 for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
3057 LIST_FOREACH(sp, &sptree[dir], chain) {
3058 sp->state = IPSEC_SPSTATE_DEAD;
3059 }
3060 }
2d21ac55
A		 3061 lck_mtx_unlock(sadb_mutex);
3062
9bccf70c 3063 if (sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
55e303ae 3064 ipseclog((LOG_DEBUG, "key_spdflush: No more memory.\n"));
9bccf70c 3065 return key_senderror(so, m, ENOBUFS);
1c79356b 3066 }
39236c6e 3067
9bccf70c
A		 3068 if (m->m_next)
3069 m_freem(m->m_next);
3070 m->m_next = NULL;
3071 m->m_pkthdr.len = m->m_len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
3072 newmsg = mtod(m, struct sadb_msg *);
1c79356b 3073 newmsg->sadb_msg_errno = 0;
9bccf70c 3074 newmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
39236c6e 3075
9bccf70c 3076 return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
1c79356b
A		 3077}
3078
3079/*
3080 * SADB_SPDDUMP processing
3081 * receive
3082 * <base>
3083 * from the user, and dump all SP leaves
3084 * and send,
3085 * <base> .....
3086 * to the ikmpd.
3087 *
9bccf70c 3088 * m will always be freed.
1c79356b 3089 */
39236c6e 3090
1c79356b 3091static int
6d2010ae 3092key_spddump(
39236c6e
A		 3093 struct socket *so,
3094 struct mbuf *m,
3095 const struct sadb_msghdr *mhp)
1c79356b 3096{
2d21ac55
A		 3097 struct secpolicy *sp, **spbuf = NULL, **sp_ptr;
3098 int cnt = 0, bufcount;
1c79356b 3099 u_int dir;
9bccf70c 3100 struct mbuf *n;
2d21ac55
A		 3101 int error = 0;
3102
1c79356b 3103 /* sanity check */
9bccf70c 3104 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 3105 panic("key_spddump: NULL pointer is passed.\n");
39236c6e 3106
2d21ac55
A		 3107 if ((bufcount = ipsec_policy_count) == 0) {
3108 error = ENOENT;
3109 goto end;
3110 }
3111 bufcount += 256; /* extra */
3112 KMALLOC_WAIT(spbuf, struct secpolicy**, bufcount * sizeof(struct secpolicy*));
3113 if (spbuf == NULL) {
3114 ipseclog((LOG_DEBUG, "key_spddump: No more memory.\n"));
3115 error = ENOMEM;
3116 goto end;
3117 }
3118 lck_mtx_lock(sadb_mutex);
3119 /* search SPD entry, make list. */
3120 sp_ptr = spbuf;
1c79356b
A		 3121 for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
3122 LIST_FOREACH(sp, &sptree[dir], chain) {
39236c6e 3123 if (cnt == bufcount)
2d21ac55
A		 3124 break; /* buffer full */
3125 *sp_ptr++ = sp;
3126 sp->refcnt++;
1c79356b
A		 3127 cnt++;
3128 }
3129 }
2d21ac55 3130 lck_mtx_unlock(sadb_mutex);
39236c6e 3131
2d21ac55
A		 3132 if (cnt == 0) {
3133 error = ENOENT;
3134 goto end;
3135 }
3136
3137 sp_ptr = spbuf;
3138 while (cnt) {
3139 --cnt;
3140 n = key_setdumpsp(*sp_ptr++, SADB_X_SPDDUMP, cnt,
39236c6e
A		 3141 mhp->msg->sadb_msg_pid);
3142
2d21ac55
A		 3143 if (n)
3144 key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
1c79356b 3145 }
2d21ac55
A		 3146
3147 lck_mtx_lock(sadb_mutex);
3148 while (sp_ptr > spbuf)
3149 key_freesp(*(--sp_ptr), KEY_SADB_LOCKED);
3150 lck_mtx_unlock(sadb_mutex);
3151
39236c6e 3152end:
2d21ac55
A		 3153 if (spbuf)
3154 KFREE(spbuf);
3155 if (error)
3156 return key_senderror(so, m, error);
39236c6e 3157
9bccf70c 3158 m_freem(m);
1c79356b 3159 return 0;
39236c6e 3160
1c79356b
A		 3161}
3162
3163static struct mbuf *
6d2010ae 3164key_setdumpsp(
39236c6e
A		 3165 struct secpolicy *sp,
3166 u_int8_t type,
3167 u_int32_t seq,
3168 u_int32_t pid)
1c79356b 3169{
9bccf70c 3170 struct mbuf *result = NULL, *m;
39236c6e 3171
9bccf70c
A		 3172 m = key_setsadbmsg(type, 0, SADB_SATYPE_UNSPEC, seq, pid, sp->refcnt);
3173 if (!m)
3174 goto fail;
3175 result = m;
39236c6e
A		 3176
3177 if (sp->spidx.src_range.start.ss_len > 0) {
3178 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_SRC_START,
3179 (struct sockaddr *)&sp->spidx.src_range.start, sp->spidx.prefs,
3180 sp->spidx.ul_proto);
3181 if (!m)
3182 goto fail;
3183 m_cat(result, m);
3184
3185 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_SRC_END,
3186 (struct sockaddr *)&sp->spidx.src_range.end, sp->spidx.prefs,
3187 sp->spidx.ul_proto);
3188 if (!m)
3189 goto fail;
3190 m_cat(result, m);
3191 } else {
3192 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
3193 (struct sockaddr *)&sp->spidx.src, sp->spidx.prefs,
3194 sp->spidx.ul_proto);
3195 if (!m)
3196 goto fail;
3197 m_cat(result, m);
3198 }
3199
3200 if (sp->spidx.dst_range.start.ss_len > 0) {
3201 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_DST_START,
3202 (struct sockaddr *)&sp->spidx.dst_range.start, sp->spidx.prefd,
3203 sp->spidx.ul_proto);
3204 if (!m)
3205 goto fail;
3206 m_cat(result, m);
3207
3208 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_DST_END,
3209 (struct sockaddr *)&sp->spidx.dst_range.end, sp->spidx.prefd,
3210 sp->spidx.ul_proto);
3211 if (!m)
3212 goto fail;
3213 m_cat(result, m);
3214 } else {
3215 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
3216 (struct sockaddr *)&sp->spidx.dst, sp->spidx.prefd,
3217 sp->spidx.ul_proto);
3218 if (!m)
3219 goto fail;
3220 m_cat(result, m);
3221 }
3222
3223 if (sp->spidx.internal_if || sp->outgoing_if || sp->ipsec_if || sp->disabled) {
3224 m = key_setsadbipsecif(sp->spidx.internal_if, sp->outgoing_if, sp->ipsec_if, sp->disabled);
3225 if (!m)
3226 goto fail;
3227 m_cat(result, m);
3228 }
3229
9bccf70c
A		 3230 m = key_sp2msg(sp);
3231 if (!m)
3232 goto fail;
3233 m_cat(result, m);
39236c6e 3234
9bccf70c
A		 3235 if ((result->m_flags & M_PKTHDR) == 0)
3236 goto fail;
39236c6e 3237
9bccf70c
A		 3238 if (result->m_len < sizeof(struct sadb_msg)) {
3239 result = m_pullup(result, sizeof(struct sadb_msg));
3240 if (result == NULL)
3241 goto fail;
1c79356b 3242 }
39236c6e 3243
9bccf70c
A		 3244 result->m_pkthdr.len = 0;
3245 for (m = result; m; m = m->m_next)
3246 result->m_pkthdr.len += m->m_len;
39236c6e 3247
9bccf70c 3248 mtod(result, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 3249 PFKEY_UNIT64(result->m_pkthdr.len);
3250
9bccf70c 3251 return result;
39236c6e 3252
9bccf70c
A		 3253fail:
3254 m_freem(result);
3255 return NULL;
1c79356b
A		 3256}
3257
3258/*
3259 * get PFKEY message length for security policy and request.
3260 */
3261static u_int
6d2010ae 3262key_getspreqmsglen(
39236c6e 3263 struct secpolicy *sp)
1c79356b
A		 3264{
3265 u_int tlen;
39236c6e 3266
1c79356b 3267 tlen = sizeof(struct sadb_x_policy);
39236c6e 3268
1c79356b
A		 3269 /* if is the policy for ipsec ? */
3270 if (sp->policy != IPSEC_POLICY_IPSEC)
3271 return tlen;
39236c6e 3272
1c79356b
A		 3273 /* get length of ipsec requests */
3274 {
39236c6e
A		 3275 struct ipsecrequest *isr;
3276 int len;
3277
3278 for (isr = sp->req; isr != NULL; isr = isr->next) {
3279 len = sizeof(struct sadb_x_ipsecrequest)
1c79356b
A		 3280 + isr->saidx.src.ss_len
3281 + isr->saidx.dst.ss_len;
39236c6e
A		 3282
3283 tlen += PFKEY_ALIGN8(len);
3284 }
1c79356b 3285 }
39236c6e 3286
1c79356b
A		 3287 return tlen;
3288}
3289
9bccf70c
A		 3290/*
3291 * SADB_SPDEXPIRE processing
3292 * send
3293 * <base, address(SD), lifetime(CH), policy>
3294 * to KMD by PF_KEY.
3295 *
3296 * OUT: 0 : succeed
3297 * others : error number
3298 */
3299static int
6d2010ae 3300key_spdexpire(
39236c6e 3301 struct secpolicy *sp)
9bccf70c 3302{
9bccf70c
A		 3303 struct mbuf *result = NULL, *m;
3304 int len;
6d2010ae 3305 int error = EINVAL;
9bccf70c 3306 struct sadb_lifetime *lt;
39236c6e 3307
2d21ac55
A		 3308 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
3309
9bccf70c
A		 3310 /* sanity check */
3311 if (sp == NULL)
3312 panic("key_spdexpire: NULL pointer is passed.\n");
39236c6e 3313
9bccf70c
A		 3314 /* set msg header */
3315 m = key_setsadbmsg(SADB_X_SPDEXPIRE, 0, 0, 0, 0, 0);
3316 if (!m) {
3317 error = ENOBUFS;
3318 goto fail;
3319 }
3320 result = m;
39236c6e 3321
9bccf70c
A		 3322 /* create lifetime extension (current and hard) */
3323 len = PFKEY_ALIGN8(sizeof(*lt)) * 2;
3324 m = key_alloc_mbuf(len);
3325 if (!m || m->m_next) { /*XXX*/
3326 if (m)
3327 m_freem(m);
3328 error = ENOBUFS;
3329 goto fail;
3330 }
3331 bzero(mtod(m, caddr_t), len);
3332 lt = mtod(m, struct sadb_lifetime *);
3333 lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
3334 lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
3335 lt->sadb_lifetime_allocations = 0;
3336 lt->sadb_lifetime_bytes = 0;
3337 lt->sadb_lifetime_addtime = sp->created;
3338 lt->sadb_lifetime_usetime = sp->lastused;
316670eb 3339 lt = (struct sadb_lifetime *)(void *)(mtod(m, caddr_t) + len / 2);
9bccf70c
A		 3340 lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
3341 lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
3342 lt->sadb_lifetime_allocations = 0;
3343 lt->sadb_lifetime_bytes = 0;
3344 lt->sadb_lifetime_addtime = sp->lifetime;
3345 lt->sadb_lifetime_usetime = sp->validtime;
3346 m_cat(result, m);
39236c6e
A		 3347
3348 /* set sadb_address(es) for source */
3349 if (sp->spidx.src_range.start.ss_len > 0) {
3350 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_SRC_START,
3351 (struct sockaddr *)&sp->spidx.src_range.start, sp->spidx.prefs,
3352 sp->spidx.ul_proto);
3353 if (!m) {
3354 error = ENOBUFS;
3355 goto fail;
3356 }
3357 m_cat(result, m);
3358
3359 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_SRC_END,
3360 (struct sockaddr *)&sp->spidx.src_range.end, sp->spidx.prefs,
3361 sp->spidx.ul_proto);
3362 if (!m) {
3363 error = ENOBUFS;
3364 goto fail;
3365 }
3366 m_cat(result, m);
3367 } else {
3368 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
3369 (struct sockaddr *)&sp->spidx.src, sp->spidx.prefs,
3370 sp->spidx.ul_proto);
3371 if (!m) {
3372 error = ENOBUFS;
3373 goto fail;
3374 }
3375 m_cat(result, m);
3376 }
3377
3378 /* set sadb_address(es) for dest */
3379 if (sp->spidx.dst_range.start.ss_len > 0) {
3380 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_DST_START,
3381 (struct sockaddr *)&sp->spidx.dst_range.start, sp->spidx.prefd,
3382 sp->spidx.ul_proto);
3383 if (!m) {
3384 error = ENOBUFS;
3385 goto fail;
3386 }
3387 m_cat(result, m);
3388
3389 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_DST_END,
3390 (struct sockaddr *)&sp->spidx.dst_range.end, sp->spidx.prefd,
3391 sp->spidx.ul_proto);
3392 if (!m) {
3393 error = ENOBUFS;
3394 goto fail;
3395 }
3396 m_cat(result, m);
3397 } else {
3398 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
3399 (struct sockaddr *)&sp->spidx.dst, sp->spidx.prefd,
3400 sp->spidx.ul_proto);
3401 if (!m) {
3402 error = ENOBUFS;
3403 goto fail;
3404 }
3405 m_cat(result, m);
3406 }
3407
9bccf70c
A		 3408 /* set secpolicy */
3409 m = key_sp2msg(sp);
3410 if (!m) {
3411 error = ENOBUFS;
3412 goto fail;
3413 }
3414 m_cat(result, m);
39236c6e 3415
9bccf70c
A		 3416 if ((result->m_flags & M_PKTHDR) == 0) {
3417 error = EINVAL;
3418 goto fail;
3419 }
39236c6e 3420
9bccf70c
A		 3421 if (result->m_len < sizeof(struct sadb_msg)) {
3422 result = m_pullup(result, sizeof(struct sadb_msg));
3423 if (result == NULL) {
3424 error = ENOBUFS;
3425 goto fail;
3426 }
3427 }
39236c6e 3428
9bccf70c
A		 3429 result->m_pkthdr.len = 0;
3430 for (m = result; m; m = m->m_next)
3431 result->m_pkthdr.len += m->m_len;
39236c6e 3432
9bccf70c 3433 mtod(result, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 3434 PFKEY_UNIT64(result->m_pkthdr.len);
3435
9bccf70c 3436 return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
39236c6e
A		 3437
3438fail:
9bccf70c
A		 3439 if (result)
3440 m_freem(result);
9bccf70c
A		 3441 return error;
3442}
3443
1c79356b
A		 3444/* %%% SAD management */
3445/*
3446 * allocating a memory for new SA head, and copy from the values of mhp.
3447 * OUT: NULL : failure due to the lack of memory.
3448 * others : pointer to new SA head.
3449 */
3450static struct secashead *
fe8ab488
A		 3451key_newsah(struct secasindex *saidx,
3452 ifnet_t ipsec_if,
3453 u_int outgoing_if,
3454 u_int8_t dir)
1c79356b
A		 3455{
3456 struct secashead *newsah;
39236c6e 3457
1c79356b
A		 3458 /* sanity check */
3459 if (saidx == NULL)
3460 panic("key_newsaidx: NULL pointer is passed.\n");
39236c6e 3461
1c79356b
A		 3462 newsah = keydb_newsecashead();
3463 if (newsah == NULL)
3464 return NULL;
39236c6e 3465
1c79356b 3466 bcopy(saidx, &newsah->saidx, sizeof(newsah->saidx));
2d21ac55
A		 3467
3468 /* remove the ports */
3469 switch (saidx->src.ss_family) {
39236c6e 3470 case AF_INET:
2d21ac55
A		 3471 ((struct sockaddr_in *)(&newsah->saidx.src))->sin_port = IPSEC_PORT_ANY;
3472 break;
39236c6e
A		 3473 case AF_INET6:
3474 ((struct sockaddr_in6 *)(&newsah->saidx.src))->sin6_port = IPSEC_PORT_ANY;
2d21ac55 3475 break;
39236c6e 3476 default:
2d21ac55
A		 3477 break;
3478 }
3479 switch (saidx->dst.ss_family) {
39236c6e
A		 3480 case AF_INET:
3481 ((struct sockaddr_in *)(&newsah->saidx.dst))->sin_port = IPSEC_PORT_ANY;
2d21ac55 3482 break;
39236c6e 3483 case AF_INET6:
2d21ac55
A		 3484 ((struct sockaddr_in6 *)(&newsah->saidx.dst))->sin6_port = IPSEC_PORT_ANY;
3485 break;
39236c6e 3486 default:
2d21ac55 3487 break;
39236c6e
A		 3488 }
3489
fe8ab488
A		 3490 newsah->outgoing_if = outgoing_if;
3491 if (ipsec_if) {
3492 ifnet_reference(ipsec_if);
3493 newsah->ipsec_if = ipsec_if;
3494 }
b0d623f7 3495 newsah->dir = dir;
1c79356b
A		 3496 /* add to saidxtree */
3497 newsah->state = SADB_SASTATE_MATURE;
3498 LIST_INSERT_HEAD(&sahtree, newsah, chain);
39236c6e 3499 key_start_timehandler();
fe8ab488 3500
1c79356b
A		 3501 return(newsah);
3502}
3503
3504/*
3505 * delete SA index and all SA registerd.
3506 */
316670eb 3507void
6d2010ae 3508key_delsah(
39236c6e 3509 struct secashead *sah)
1c79356b
A		 3510{
3511 struct secasvar *sav, *nextsav;
3512 u_int stateidx, state;
1c79356b 3513 int zombie = 0;
39236c6e 3514
91447636 3515 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 3516
1c79356b
A		 3517 /* sanity check */
3518 if (sah == NULL)
3519 panic("key_delsah: NULL pointer is passed.\n");
39236c6e 3520
1c79356b
A		 3521 /* searching all SA registerd in the secindex. */
3522 for (stateidx = 0;
3523 stateidx < _ARRAYLEN(saorder_state_any);
3524 stateidx++) {
39236c6e 3525
1c79356b
A		 3526 state = saorder_state_any[stateidx];
3527 for (sav = (struct secasvar *)LIST_FIRST(&sah->savtree[state]);
3528 sav != NULL;
3529 sav = nextsav) {
39236c6e 3530
1c79356b 3531 nextsav = LIST_NEXT(sav, chain);
39236c6e 3532
1c79356b
A		 3533 if (sav->refcnt > 0) {
3534 /* give up to delete this sa */
3535 zombie++;
3536 continue;
3537 }
39236c6e 3538
1c79356b
A		 3539 /* sanity check */
3540 KEY_CHKSASTATE(state, sav->state, "key_delsah");
39236c6e 3541
2d21ac55 3542 key_freesav(sav, KEY_SADB_LOCKED);
39236c6e 3543
1c79356b
A		 3544 /* remove back pointer */
3545 sav->sah = NULL;
3546 sav = NULL;
3547 }
3548 }
39236c6e 3549
1c79356b 3550 /* don't delete sah only if there are savs. */
2d21ac55 3551 if (zombie)
1c79356b 3552 return;
39236c6e
A		 3553
3554 ROUTE_RELEASE(&sah->sa_route);
3555
fe8ab488
A		 3556 if (sah->ipsec_if) {
3557 ifnet_release(sah->ipsec_if);
3558 sah->ipsec_if = NULL;
3559 }
3560
39236c6e
A		 3561 if (sah->idents) {
3562 KFREE(sah->idents);
3563 }
3564
3565 if (sah->identd) {
3566 KFREE(sah->identd);
3567 }
3568
1c79356b
A		 3569 /* remove from tree of SA index */
3570 if (__LIST_CHAINED(sah))
3571 LIST_REMOVE(sah, chain);
39236c6e 3572
1c79356b 3573 KFREE(sah);
39236c6e 3574
1c79356b
A		 3575 return;
3576}
3577
3578/*
3579 * allocating a new SA with LARVAL state. key_add() and key_getspi() call,
3580 * and copy the values of mhp into new buffer.
3581 * When SAD message type is GETSPI:
3582 * to set sequence number from acq_seq++,
3583 * to set zero to SPI.
3584 * not to call key_setsava().
3585 * OUT: NULL : fail
3586 * others : pointer to new secasvar.
9bccf70c
A		 3587 *
3588 * does not modify mbuf. does not free mbuf on error.
1c79356b
A		 3589 */
3590static struct secasvar *
6d2010ae 3591key_newsav(
39236c6e
A		 3592 struct mbuf *m,
3593 const struct sadb_msghdr *mhp,
3594 struct secashead *sah,
fe8ab488
A		 3595 int *errp,
3596 struct socket *so)
1c79356b
A		 3597{
3598 struct secasvar *newsav;
9bccf70c 3599 const struct sadb_sa *xsa;
39236c6e 3600
91447636 3601 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 3602
1c79356b 3603 /* sanity check */
9bccf70c 3604 if (m == NULL || mhp == NULL || mhp->msg == NULL || sah == NULL)
1c79356b 3605 panic("key_newsa: NULL pointer is passed.\n");
39236c6e 3606
2d21ac55 3607 KMALLOC_NOWAIT(newsav, struct secasvar *, sizeof(struct secasvar));
1c79356b 3608 if (newsav == NULL) {
2d21ac55
A		 3609 lck_mtx_unlock(sadb_mutex);
3610 KMALLOC_WAIT(newsav, struct secasvar *, sizeof(struct secasvar));
3611 lck_mtx_lock(sadb_mutex);
3612 if (newsav == NULL) {
3613 ipseclog((LOG_DEBUG, "key_newsa: No more memory.\n"));
3614 *errp = ENOBUFS;
3615 return NULL;
3616 }
1c79356b
A		 3617 }
3618 bzero((caddr_t)newsav, sizeof(struct secasvar));
39236c6e 3619
9bccf70c 3620 switch (mhp->msg->sadb_msg_type) {
39236c6e
A		 3621 case SADB_GETSPI:
3622 key_setspi(newsav, 0);
3623
1c79356b 3624#if IPSEC_DOSEQCHECK
39236c6e
A		 3625 /* sync sequence number */
3626 if (mhp->msg->sadb_msg_seq == 0)
3627 newsav->seq =
1c79356b 3628 (acq_seq = (acq_seq == ~0 ? 1 : ++acq_seq));
39236c6e 3629 else
1c79356b 3630#endif
39236c6e
A		 3631 newsav->seq = mhp->msg->sadb_msg_seq;
3632 break;
3633
3634 case SADB_ADD:
3635 /* sanity check */
3636 if (mhp->ext[SADB_EXT_SA] == NULL) {
fe8ab488 3637 key_delsav(newsav);
39236c6e
A		 3638 ipseclog((LOG_DEBUG, "key_newsa: invalid message is passed.\n"));
3639 *errp = EINVAL;
3640 return NULL;
3641 }
3642 xsa = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
3643 key_setspi(newsav, xsa->sadb_sa_spi);
9bccf70c 3644 newsav->seq = mhp->msg->sadb_msg_seq;
39236c6e
A		 3645 break;
3646 default:
fe8ab488 3647 key_delsav(newsav);
9bccf70c 3648 *errp = EINVAL;
1c79356b 3649 return NULL;
1c79356b 3650 }
39236c6e
A		 3651
3652 if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
3653 if (((struct sadb_x_sa2 *)(void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_alwaysexpire)
3654 newsav->always_expire = 1;
fe8ab488
A		 3655 newsav->flags2 = ((struct sadb_x_sa2 *)(void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_flags;
3656 if (newsav->flags2 & SADB_X_EXT_SA2_DELETE_ON_DETACH) {
3657 newsav->so = so;
3658 }
39236c6e
A		 3659 }
3660
1c79356b 3661 /* copy sav values */
9bccf70c
A		 3662 if (mhp->msg->sadb_msg_type != SADB_GETSPI) {
3663 *errp = key_setsaval(newsav, m, mhp);
3664 if (*errp) {
fe8ab488 3665 key_delsav(newsav);
9bccf70c
A		 3666 return NULL;
3667 }
39236c6e
A		 3668 } else {
3669 /* For get SPI, if has a hard lifetime, apply */
3670 const struct sadb_lifetime *lft0;
3671 struct timeval tv;
3672
3673 lft0 = (struct sadb_lifetime *)(void *)mhp->ext[SADB_EXT_LIFETIME_HARD];
3674 if (lft0 != NULL) {
3675 /* make lifetime for CURRENT */
3676 KMALLOC_NOWAIT(newsav->lft_c, struct sadb_lifetime *,
3677 sizeof(struct sadb_lifetime));
3678 if (newsav->lft_c == NULL) {
3679 lck_mtx_unlock(sadb_mutex);
3680 KMALLOC_WAIT(newsav->lft_c, struct sadb_lifetime *,
3681 sizeof(struct sadb_lifetime));
3682 lck_mtx_lock(sadb_mutex);
3683 if (newsav->lft_c == NULL) {
3684 ipseclog((LOG_DEBUG, "key_newsa: No more memory.\n"));
fe8ab488 3685 key_delsav(newsav);
39236c6e
A		 3686 *errp = ENOBUFS;
3687 return NULL;
3688 }
3689 }
3690
3691 microtime(&tv);
3692
3693 newsav->lft_c->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
3694 newsav->lft_c->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
3695 newsav->lft_c->sadb_lifetime_allocations = 0;
3696 newsav->lft_c->sadb_lifetime_bytes = 0;
3697 newsav->lft_c->sadb_lifetime_addtime = tv.tv_sec;
3698 newsav->lft_c->sadb_lifetime_usetime = 0;
3699
3700 if (mhp->extlen[SADB_EXT_LIFETIME_HARD] < sizeof(*lft0)) {
3701 ipseclog((LOG_DEBUG, "key_newsa: invalid hard lifetime ext len.\n"));
fe8ab488 3702 key_delsav(newsav);
39236c6e
A		 3703 *errp = EINVAL;
3704 return NULL;
3705 }
3706 newsav->lft_h = (struct sadb_lifetime *)key_newbuf(lft0, sizeof(*lft0));
3707 if (newsav->lft_h == NULL) {
3708 ipseclog((LOG_DEBUG, "key_newsa: No more memory.\n"));
fe8ab488 3709 key_delsav(newsav);
39236c6e
A		 3710 *errp = ENOBUFS;
3711 return NULL;
3712 }
3713 }
1c79356b 3714 }
39236c6e 3715
9bccf70c
A		 3716 /* reset created */
3717 {
39236c6e
A		 3718 struct timeval tv;
3719 microtime(&tv);
3720 newsav->created = tv.tv_sec;
9bccf70c 3721 }
39236c6e 3722
9bccf70c 3723 newsav->pid = mhp->msg->sadb_msg_pid;
39236c6e 3724
1c79356b
A		 3725 /* add to satree */
3726 newsav->sah = sah;
3727 newsav->refcnt = 1;
3728 newsav->state = SADB_SASTATE_LARVAL;
3729 LIST_INSERT_TAIL(&sah->savtree[SADB_SASTATE_LARVAL], newsav,
39236c6e 3730 secasvar, chain);
2d21ac55 3731 ipsec_sav_count++;
39236c6e 3732
1c79356b
A		 3733 return newsav;
3734}
3735
316670eb
A		 3736/*
3737 * allocating a new SA with LARVAL state. key_add() and key_getspi() call,
3738 * and copy the values passed into new buffer.
3739 * When SAD message type is GETSPI:
3740 * to set sequence number from acq_seq++,
3741 * to set zero to SPI.
3742 * not to call key_setsava().
3743 * OUT: NULL : fail
3744 * others : pointer to new secasvar.
3745 */
3746struct secasvar *
3747key_newsav2(struct secashead *sah,
3748 u_int8_t satype,
3749 u_int8_t alg_auth,
3750 u_int8_t alg_enc,
3751 u_int32_t flags,
3752 u_int8_t replay,
3753 struct sadb_key *key_auth,
3754 u_int16_t key_auth_len,
3755 struct sadb_key *key_enc,
3756 u_int16_t key_enc_len,
3757 u_int16_t natt_port,
3758 u_int32_t seq,
3759 u_int32_t spi,
3760 u_int32_t pid,
3761 struct sadb_lifetime *lifetime_hard,
3762 struct sadb_lifetime *lifetime_soft)
3763{
3764 struct secasvar *newsav;
3765
3766 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
3767
3768 /* sanity check */
3769 if (sah == NULL)
3770 panic("key_newsa: NULL pointer is passed.\n");
3771
3772 KMALLOC_NOWAIT(newsav, struct secasvar *, sizeof(struct secasvar));
3773 if (newsav == NULL) {
3774 lck_mtx_unlock(sadb_mutex);
3775 KMALLOC_WAIT(newsav, struct secasvar *, sizeof(struct secasvar));
3776 lck_mtx_lock(sadb_mutex);
3777 if (newsav == NULL) {
3778 ipseclog((LOG_DEBUG, "key_newsa: No more memory.\n"));
3779 return NULL;
3780 }
3781 }
3782 bzero((caddr_t)newsav, sizeof(struct secasvar));
39236c6e 3783
316670eb
A		 3784#if IPSEC_DOSEQCHECK
3785 /* sync sequence number */
3786 if (seq == 0)
3787 newsav->seq = (acq_seq = (acq_seq == ~0 ? 1 : ++acq_seq));
3788 else
3789#endif
3790 newsav->seq = seq;
3791 key_setspi(newsav, spi);
39236c6e 3792
316670eb
A		 3793 if (key_setsaval2(newsav,
3794 satype,
3795 alg_auth,
3796 alg_enc,
3797 flags,
3798 replay,
3799 key_auth,
3800 key_auth_len,
3801 key_enc,
3802 key_enc_len,
3803 natt_port,
3804 seq,
3805 spi,
3806 pid,
3807 lifetime_hard,
3808 lifetime_soft)) {
fe8ab488 3809 key_delsav(newsav);
316670eb
A		 3810 return NULL;
3811 }
3812
3813 /* reset created */
3814 {
3815 struct timeval tv;
3816 microtime(&tv);
3817 newsav->created = tv.tv_sec;
3818 }
3819
3820 newsav->pid = pid;
3821
3822 /* add to satree */
3823 newsav->sah = sah;
3824 newsav->refcnt = 1;
3825 if (spi && key_auth && key_auth_len && key_enc && key_enc_len) {
3826 newsav->state = SADB_SASTATE_MATURE;
3827 LIST_INSERT_TAIL(&sah->savtree[SADB_SASTATE_MATURE], newsav,
3828 secasvar, chain);
3829 } else {
3830 newsav->state = SADB_SASTATE_LARVAL;
3831 LIST_INSERT_TAIL(&sah->savtree[SADB_SASTATE_LARVAL], newsav,
3832 secasvar, chain);
3833 }
3834 ipsec_sav_count++;
3835
3836 return newsav;
3837}
3838
3e170ce0
A		 3839static int
3840key_migratesav(struct secasvar *sav,
3841 struct secashead *newsah)
3842{
3843 if (sav == NULL || newsah == NULL || sav->state != SADB_SASTATE_MATURE) {
3844 return EINVAL;
3845 }
3846
3847 /* remove from SA header */
3848 if (__LIST_CHAINED(sav))
3849 LIST_REMOVE(sav, chain);
3850
3851 sav->sah = newsah;
3852 LIST_INSERT_TAIL(&newsah->savtree[SADB_SASTATE_MATURE], sav, secasvar, chain);
3853 return 0;
3854}
3855
1c79356b
A		 3856/*
3857 * free() SA variable entry.
3858 */
316670eb 3859void
6d2010ae 3860key_delsav(
39236c6e 3861 struct secasvar *sav)
1c79356b 3862{
39236c6e 3863
2d21ac55
A		 3864 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
3865
1c79356b
A		 3866 /* sanity check */
3867 if (sav == NULL)
3868 panic("key_delsav: NULL pointer is passed.\n");
39236c6e 3869
1c79356b
A		 3870 if (sav->refcnt > 0)
3871 return; /* can't free */
2d21ac55 3872
1c79356b
A		 3873 /* remove from SA header */
3874 if (__LIST_CHAINED(sav))
3875 LIST_REMOVE(sav, chain);
2d21ac55 3876 ipsec_sav_count--;
39236c6e 3877
91447636
A		 3878 if (sav->spihash.le_prev || sav->spihash.le_next)
3879 LIST_REMOVE(sav, spihash);
39236c6e 3880
9bccf70c
A		 3881 if (sav->key_auth != NULL) {
3882 bzero(_KEYBUF(sav->key_auth), _KEYLEN(sav->key_auth));
1c79356b 3883 KFREE(sav->key_auth);
9bccf70c
A		 3884 sav->key_auth = NULL;
3885 }
3886 if (sav->key_enc != NULL) {
3887 bzero(_KEYBUF(sav->key_enc), _KEYLEN(sav->key_enc));
1c79356b 3888 KFREE(sav->key_enc);
9bccf70c
A		 3889 sav->key_enc = NULL;
3890 }
3891 if (sav->sched) {
3892 bzero(sav->sched, sav->schedlen);
3893 KFREE(sav->sched);
3894 sav->sched = NULL;
3895 }
3896 if (sav->replay != NULL) {
1c79356b 3897 keydb_delsecreplay(sav->replay);
9bccf70c
A		 3898 sav->replay = NULL;
3899 }
3900 if (sav->lft_c != NULL) {
1c79356b 3901 KFREE(sav->lft_c);
9bccf70c
A		 3902 sav->lft_c = NULL;
3903 }
3904 if (sav->lft_h != NULL) {
1c79356b 3905 KFREE(sav->lft_h);
9bccf70c
A		 3906 sav->lft_h = NULL;
3907 }
3908 if (sav->lft_s != NULL) {
1c79356b 3909 KFREE(sav->lft_s);
9bccf70c
A		 3910 sav->lft_s = NULL;
3911 }
3912 if (sav->iv != NULL) {
1c79356b 3913 KFREE(sav->iv);
9bccf70c
A		 3914 sav->iv = NULL;
3915 }
39236c6e 3916
1c79356b 3917 KFREE(sav);
39236c6e 3918
1c79356b
A		 3919 return;
3920}
3921
3922/*
3923 * search SAD.
3924 * OUT:
3925 * NULL : not found
3926 * others : found, pointer to a SA.
3927 */
3928static struct secashead *
fe8ab488 3929key_getsah(struct secasindex *saidx)
1c79356b
A		 3930{
3931 struct secashead *sah;
39236c6e 3932
91447636 3933 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 3934
1c79356b
A		 3935 LIST_FOREACH(sah, &sahtree, chain) {
3936 if (sah->state == SADB_SASTATE_DEAD)
3937 continue;
55e303ae 3938 if (key_cmpsaidx(&sah->saidx, saidx, CMP_REQID))
9bccf70c 3939 return sah;
1c79356b 3940 }
39236c6e 3941
1c79356b
A		 3942 return NULL;
3943}
3944
316670eb
A		 3945struct secashead *
3946key_newsah2 (struct secasindex *saidx,
3947 u_int8_t dir)
3948{
3949 struct secashead *sah;
39236c6e 3950
316670eb 3951 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 3952
316670eb
A		 3953 sah = key_getsah(saidx);
3954 if (!sah) {
fe8ab488 3955 return(key_newsah(saidx, NULL, 0, dir));
316670eb
A		 3956 }
3957 return sah;
3958}
3959
1c79356b
A		 3960/*
3961 * check not to be duplicated SPI.
3962 * NOTE: this function is too slow due to searching all SAD.
3963 * OUT:
3964 * NULL : not found
3965 * others : found, pointer to a SA.
3966 */
3967static struct secasvar *
6d2010ae 3968key_checkspidup(
39236c6e
A		 3969 struct secasindex *saidx,
3970 u_int32_t spi)
1c79356b 3971{
1c79356b 3972 struct secasvar *sav;
91447636
A		 3973 u_int stateidx, state;
3974
3975 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 3976
1c79356b
A		 3977 /* check address family */
3978 if (saidx->src.ss_family != saidx->dst.ss_family) {
55e303ae 3979 ipseclog((LOG_DEBUG, "key_checkspidup: address family mismatched.\n"));
1c79356b
A		 3980 return NULL;
3981 }
39236c6e 3982
1c79356b 3983 /* check all SAD */
91447636
A		 3984 LIST_FOREACH(sav, &spihash[SPIHASH(spi)], spihash) {
3985 if (sav->spi != spi)
1c79356b 3986 continue;
91447636
A		 3987 for (stateidx = 0;
3988 stateidx < _ARRAYLEN(saorder_state_alive);
3989 stateidx++) {
3990 state = saorder_state_alive[stateidx];
3991 if (sav->state == state &&
3992 key_ismyaddr((struct sockaddr *)&sav->sah->saidx.dst))
3993 return sav;
3994 }
1c79356b 3995 }
39236c6e 3996
1c79356b
A		 3997 return NULL;
3998}
3999
91447636 4000static void
6d2010ae 4001key_setspi(
39236c6e
A		 4002 struct secasvar *sav,
4003 u_int32_t spi)
91447636 4004{
2d21ac55 4005 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
91447636
A		 4006 sav->spi = spi;
4007 if (sav->spihash.le_prev || sav->spihash.le_next)
4008 LIST_REMOVE(sav, spihash);
4009 LIST_INSERT_HEAD(&spihash[SPIHASH(spi)], sav, spihash);
4010}
4011
4012
1c79356b
A		 4013/*
4014 * search SAD litmited alive SA, protocol, SPI.
4015 * OUT:
4016 * NULL : not found
4017 * others : found, pointer to a SA.
4018 */
4019static struct secasvar *
6d2010ae 4020key_getsavbyspi(
39236c6e
A		 4021 struct secashead *sah,
4022 u_int32_t spi)
1c79356b 4023{
91447636
A		 4024 struct secasvar *sav, *match;
4025 u_int stateidx, state, matchidx;
39236c6e 4026
2d21ac55 4027 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
91447636
A		 4028 match = NULL;
4029 matchidx = _ARRAYLEN(saorder_state_alive);
4030 LIST_FOREACH(sav, &spihash[SPIHASH(spi)], spihash) {
4031 if (sav->spi != spi)
4032 continue;
4033 if (sav->sah != sah)
4034 continue;
4035 for (stateidx = 0; stateidx < matchidx; stateidx++) {
4036 state = saorder_state_alive[stateidx];
4037 if (sav->state == state) {
4038 match = sav;
4039 matchidx = stateidx;
4040 break;
1c79356b 4041 }
1c79356b
A		 4042 }
4043 }
39236c6e 4044
91447636 4045 return match;
1c79356b
A		 4046}
4047
4048/*
4049 * copy SA values from PF_KEY message except *SPI, SEQ, PID, STATE and TYPE*.
4050 * You must update these if need.
4051 * OUT: 0: success.
9bccf70c
A		 4052 * !0: failure.
4053 *
4054 * does not modify mbuf. does not free mbuf on error.
1c79356b
A		 4055 */
4056static int
6d2010ae 4057key_setsaval(
39236c6e
A		 4058 struct secasvar *sav,
4059 struct mbuf *m,
4060 const struct sadb_msghdr *mhp)
1c79356b 4061{
9bccf70c
A		 4062#if IPSEC_ESP
4063 const struct esp_algorithm *algo;
4064#endif
1c79356b 4065 int error = 0;
9bccf70c 4066 struct timeval tv;
39236c6e 4067
91447636 4068 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 4069
1c79356b 4070 /* sanity check */
9bccf70c 4071 if (m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 4072 panic("key_setsaval: NULL pointer is passed.\n");
39236c6e 4073
1c79356b
A		 4074 /* initialization */
4075 sav->replay = NULL;
4076 sav->key_auth = NULL;
4077 sav->key_enc = NULL;
9bccf70c
A		 4078 sav->sched = NULL;
4079 sav->schedlen = 0;
1c79356b
A		 4080 sav->iv = NULL;
4081 sav->lft_c = NULL;
4082 sav->lft_h = NULL;
4083 sav->lft_s = NULL;
55e303ae
A		 4084 sav->remote_ike_port = 0;
4085 sav->natt_last_activity = natt_now;
2d21ac55 4086 sav->natt_encapsulated_src_port = 0;
39236c6e 4087
1c79356b 4088 /* SA */
9bccf70c
A		 4089 if (mhp->ext[SADB_EXT_SA] != NULL) {
4090 const struct sadb_sa *sa0;
39236c6e 4091
316670eb 4092 sa0 = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
9bccf70c 4093 if (mhp->extlen[SADB_EXT_SA] < sizeof(*sa0)) {
3a60a9f5 4094 ipseclog((LOG_DEBUG, "key_setsaval: invalid message size.\n"));
9bccf70c
A		 4095 error = EINVAL;
4096 goto fail;
4097 }
39236c6e 4098
1c79356b
A		 4099 sav->alg_auth = sa0->sadb_sa_auth;
4100 sav->alg_enc = sa0->sadb_sa_encrypt;
4101 sav->flags = sa0->sadb_sa_flags;
55e303ae
A		 4102
4103 /*
4104 * Verify that a nat-traversal port was specified if
4105 * the nat-traversal flag is set.
4106 */
4107 if ((sav->flags & SADB_X_EXT_NATT) != 0) {
4108 if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa_2) ||
39236c6e 4109 ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_port == 0) {
3a60a9f5 4110 ipseclog((LOG_DEBUG, "key_setsaval: natt port not set.\n"));
55e303ae
A		 4111 error = EINVAL;
4112 goto fail;
4113 }
b0d623f7 4114 sav->remote_ike_port = ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_port;
fe8ab488 4115 sav->natt_interval = ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_interval;
3e170ce0 4116 sav->natt_offload_interval = ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_offload_interval;
55e303ae 4117 }
2d21ac55
A		 4118
4119 /*
4120 * Verify if SADB_X_EXT_NATT_MULTIPLEUSERS flag is set that
39236c6e 4121 * SADB_X_EXT_NATT is set and SADB_X_EXT_NATT_KEEPALIVE is not
2d21ac55
A		 4122 * set (we're not behind nat) - otherwise clear it.
4123 */
4124 if ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0)
4125 if ((sav->flags & SADB_X_EXT_NATT) == 0 ||
4126 (sav->flags & SADB_X_EXT_NATT_KEEPALIVE) != 0)
4127 sav->flags &= ~SADB_X_EXT_NATT_MULTIPLEUSERS;
39236c6e 4128
1c79356b
A		 4129 /* replay window */
4130 if ((sa0->sadb_sa_flags & SADB_X_EXT_OLD) == 0) {
4131 sav->replay = keydb_newsecreplay(sa0->sadb_sa_replay);
4132 if (sav->replay == NULL) {
55e303ae 4133 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
1c79356b 4134 error = ENOBUFS;
9bccf70c 4135 goto fail;
1c79356b
A		 4136 }
4137 }
4138 }
39236c6e 4139
1c79356b 4140 /* Authentication keys */
9bccf70c
A		 4141 if (mhp->ext[SADB_EXT_KEY_AUTH] != NULL) {
4142 const struct sadb_key *key0;
4143 int len;
39236c6e 4144
9bccf70c
A		 4145 key0 = (const struct sadb_key *)mhp->ext[SADB_EXT_KEY_AUTH];
4146 len = mhp->extlen[SADB_EXT_KEY_AUTH];
39236c6e 4147
1c79356b 4148 error = 0;
9bccf70c 4149 if (len < sizeof(*key0)) {
3a60a9f5 4150 ipseclog((LOG_DEBUG, "key_setsaval: invalid auth key ext len. len = %d\n", len));
1c79356b 4151 error = EINVAL;
9bccf70c
A		 4152 goto fail;
4153 }
4154 switch (mhp->msg->sadb_msg_satype) {
39236c6e
A		 4155 case SADB_SATYPE_AH:
4156 case SADB_SATYPE_ESP:
4157 if (len == PFKEY_ALIGN8(sizeof(struct sadb_key)) &&
4158 sav->alg_auth != SADB_X_AALG_NULL)
4159 error = EINVAL;
4160 break;
4161 case SADB_X_SATYPE_IPCOMP:
4162 default:
1c79356b 4163 error = EINVAL;
39236c6e 4164 break;
1c79356b
A		 4165 }
4166 if (error) {
55e303ae 4167 ipseclog((LOG_DEBUG, "key_setsaval: invalid key_auth values.\n"));
9bccf70c 4168 goto fail;
1c79356b 4169 }
39236c6e 4170
1c79356b
A		 4171 sav->key_auth = (struct sadb_key *)key_newbuf(key0, len);
4172 if (sav->key_auth == NULL) {
55e303ae 4173 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
1c79356b 4174 error = ENOBUFS;
9bccf70c 4175 goto fail;
1c79356b 4176 }
1c79356b 4177 }
39236c6e 4178
1c79356b 4179 /* Encryption key */
9bccf70c
A		 4180 if (mhp->ext[SADB_EXT_KEY_ENCRYPT] != NULL) {
4181 const struct sadb_key *key0;
4182 int len;
39236c6e 4183
9bccf70c
A		 4184 key0 = (const struct sadb_key *)mhp->ext[SADB_EXT_KEY_ENCRYPT];
4185 len = mhp->extlen[SADB_EXT_KEY_ENCRYPT];
39236c6e 4186
1c79356b 4187 error = 0;
9bccf70c 4188 if (len < sizeof(*key0)) {
3a60a9f5 4189 ipseclog((LOG_DEBUG, "key_setsaval: invalid encryption key ext len. len = %d\n", len));
1c79356b 4190 error = EINVAL;
9bccf70c
A		 4191 goto fail;
4192 }
4193 switch (mhp->msg->sadb_msg_satype) {
39236c6e
A		 4194 case SADB_SATYPE_ESP:
4195 if (len == PFKEY_ALIGN8(sizeof(struct sadb_key)) &&
4196 sav->alg_enc != SADB_EALG_NULL) {
4197 ipseclog((LOG_DEBUG, "key_setsaval: invalid ESP algorithm.\n"));
4198 error = EINVAL;
4199 break;
4200 }
4201 sav->key_enc = (struct sadb_key *)key_newbuf(key0, len);
4202 if (sav->key_enc == NULL) {
4203 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4204 error = ENOBUFS;
4205 goto fail;
4206 }
9bccf70c 4207 break;
39236c6e
A		 4208 case SADB_X_SATYPE_IPCOMP:
4209 if (len != PFKEY_ALIGN8(sizeof(struct sadb_key)))
4210 error = EINVAL;
4211 sav->key_enc = NULL; /*just in case*/
4212 break;
4213 case SADB_SATYPE_AH:
4214 default:
9bccf70c 4215 error = EINVAL;
39236c6e 4216 break;
1c79356b
A		 4217 }
4218 if (error) {
3a60a9f5 4219 ipseclog((LOG_DEBUG, "key_setsaval: invalid key_enc value.\n"));
9bccf70c 4220 goto fail;
1c79356b 4221 }
1c79356b 4222 }
39236c6e 4223
1c79356b
A		 4224 /* set iv */
4225 sav->ivlen = 0;
39236c6e 4226
9bccf70c 4227 switch (mhp->msg->sadb_msg_satype) {
39236c6e 4228 case SADB_SATYPE_ESP:
1c79356b 4229#if IPSEC_ESP
39236c6e
A		 4230 algo = esp_algorithm_lookup(sav->alg_enc);
4231 if (algo && algo->ivlen)
4232 sav->ivlen = (*algo->ivlen)(algo, sav);
4233 if (sav->ivlen == 0)
4234 break;
4235 KMALLOC_NOWAIT(sav->iv, caddr_t, sav->ivlen);
2d21ac55 4236 if (sav->iv == 0) {
39236c6e
A		 4237 lck_mtx_unlock(sadb_mutex);
4238 KMALLOC_WAIT(sav->iv, caddr_t, sav->ivlen);
4239 lck_mtx_lock(sadb_mutex);
4240 if (sav->iv == 0) {
4241 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4242 error = ENOBUFS;
4243 goto fail;
4244 }
2d21ac55 4245 }
39236c6e
A		 4246
4247 /* initialize */
d190cdc3
A		 4248 if (sav->alg_enc == SADB_X_EALG_AES_GCM) {
4249 bzero(sav->iv, sav->ivlen);
4250 } else {
4251 key_randomfill(sav->iv, sav->ivlen);
4252 }
1c79356b 4253#endif
39236c6e
A		 4254 break;
4255 case SADB_SATYPE_AH:
4256 case SADB_X_SATYPE_IPCOMP:
4257 break;
4258 default:
4259 ipseclog((LOG_DEBUG, "key_setsaval: invalid SA type.\n"));
4260 error = EINVAL;
4261 goto fail;
1c79356b 4262 }
39236c6e 4263
9bccf70c
A		 4264 /* reset created */
4265 microtime(&tv);
4266 sav->created = tv.tv_sec;
39236c6e 4267
1c79356b 4268 /* make lifetime for CURRENT */
2d21ac55 4269 KMALLOC_NOWAIT(sav->lft_c, struct sadb_lifetime *,
39236c6e 4270 sizeof(struct sadb_lifetime));
1c79356b 4271 if (sav->lft_c == NULL) {
2d21ac55
A		 4272 lck_mtx_unlock(sadb_mutex);
4273 KMALLOC_WAIT(sav->lft_c, struct sadb_lifetime *,
39236c6e 4274 sizeof(struct sadb_lifetime));
2d21ac55
A		 4275 lck_mtx_lock(sadb_mutex);
4276 if (sav->lft_c == NULL) {
4277 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4278 error = ENOBUFS;
4279 goto fail;
4280 }
1c79356b 4281 }
39236c6e 4282
1c79356b 4283 microtime(&tv);
39236c6e 4284
1c79356b 4285 sav->lft_c->sadb_lifetime_len =
39236c6e 4286 PFKEY_UNIT64(sizeof(struct sadb_lifetime));
1c79356b
A		 4287 sav->lft_c->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
4288 sav->lft_c->sadb_lifetime_allocations = 0;
4289 sav->lft_c->sadb_lifetime_bytes = 0;
4290 sav->lft_c->sadb_lifetime_addtime = tv.tv_sec;
4291 sav->lft_c->sadb_lifetime_usetime = 0;
39236c6e 4292
1c79356b
A		 4293 /* lifetimes for HARD and SOFT */
4294 {
39236c6e
A		 4295 const struct sadb_lifetime *lft0;
4296
4297 lft0 = (struct sadb_lifetime *)
316670eb 4298 (void *)mhp->ext[SADB_EXT_LIFETIME_HARD];
39236c6e
A		 4299 if (lft0 != NULL) {
4300 if (mhp->extlen[SADB_EXT_LIFETIME_HARD] < sizeof(*lft0)) {
4301 ipseclog((LOG_DEBUG, "key_setsaval: invalid hard lifetime ext len.\n"));
4302 error = EINVAL;
4303 goto fail;
4304 }
4305 sav->lft_h = (struct sadb_lifetime *)key_newbuf(lft0,
4306 sizeof(*lft0));
4307 if (sav->lft_h == NULL) {
4308 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4309 error = ENOBUFS;
4310 goto fail;
4311 }
4312 /* to be initialize ? */
1c79356b 4313 }
39236c6e
A		 4314
4315 lft0 = (struct sadb_lifetime *)
316670eb 4316 (void *)mhp->ext[SADB_EXT_LIFETIME_SOFT];
39236c6e
A		 4317 if (lft0 != NULL) {
4318 if (mhp->extlen[SADB_EXT_LIFETIME_SOFT] < sizeof(*lft0)) {
4319 ipseclog((LOG_DEBUG, "key_setsaval: invalid soft lifetime ext len.\n"));
4320 error = EINVAL;
4321 goto fail;
4322 }
4323 sav->lft_s = (struct sadb_lifetime *)key_newbuf(lft0,
4324 sizeof(*lft0));
4325 if (sav->lft_s == NULL) {
4326 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4327 error = ENOBUFS;
4328 goto fail;
4329 }
4330 /* to be initialize ? */
1c79356b 4331 }
1c79356b 4332 }
39236c6e 4333
1c79356b 4334 return 0;
39236c6e
A		 4335
4336fail:
1c79356b 4337 /* initialization */
9bccf70c 4338 if (sav->replay != NULL) {
1c79356b 4339 keydb_delsecreplay(sav->replay);
9bccf70c
A		 4340 sav->replay = NULL;
4341 }
4342 if (sav->key_auth != NULL) {
55e303ae 4343 bzero(_KEYBUF(sav->key_auth), _KEYLEN(sav->key_auth));
1c79356b 4344 KFREE(sav->key_auth);
9bccf70c
A		 4345 sav->key_auth = NULL;
4346 }
4347 if (sav->key_enc != NULL) {
55e303ae 4348 bzero(_KEYBUF(sav->key_enc), _KEYLEN(sav->key_enc));
1c79356b 4349 KFREE(sav->key_enc);
9bccf70c
A		 4350 sav->key_enc = NULL;
4351 }
4352 if (sav->sched) {
55e303ae 4353 bzero(sav->sched, sav->schedlen);
9bccf70c
A		 4354 KFREE(sav->sched);
4355 sav->sched = NULL;
4356 }
4357 if (sav->iv != NULL) {
1c79356b 4358 KFREE(sav->iv);
9bccf70c
A		 4359 sav->iv = NULL;
4360 }
4361 if (sav->lft_c != NULL) {
1c79356b 4362 KFREE(sav->lft_c);
9bccf70c
A		 4363 sav->lft_c = NULL;
4364 }
4365 if (sav->lft_h != NULL) {
1c79356b 4366 KFREE(sav->lft_h);
9bccf70c
A		 4367 sav->lft_h = NULL;
4368 }
4369 if (sav->lft_s != NULL) {
1c79356b 4370 KFREE(sav->lft_s);
9bccf70c
A		 4371 sav->lft_s = NULL;
4372 }
39236c6e 4373
9bccf70c 4374 return error;
1c79356b
A		 4375}
4376
316670eb
A		 4377/*
4378 * copy SA values from PF_KEY message except *SPI, SEQ, PID, STATE and TYPE*.
4379 * You must update these if need.
4380 * OUT: 0: success.
4381 * !0: failure.
4382 *
4383 * does not modify mbuf. does not free mbuf on error.
4384 */
4385int
4386key_setsaval2(struct secasvar *sav,
4387 u_int8_t satype,
4388 u_int8_t alg_auth,
4389 u_int8_t alg_enc,
4390 u_int32_t flags,
4391 u_int8_t replay,
4392 struct sadb_key *key_auth,
4393 u_int16_t key_auth_len,
4394 struct sadb_key *key_enc,
4395 u_int16_t key_enc_len,
4396 u_int16_t natt_port,
4397 u_int32_t seq,
4398 u_int32_t spi,
4399 u_int32_t pid,
4400 struct sadb_lifetime *lifetime_hard,
4401 struct sadb_lifetime *lifetime_soft)
4402{
4403#if IPSEC_ESP
4404 const struct esp_algorithm *algo;
4405#endif
4406 int error = 0;
4407 struct timeval tv;
39236c6e 4408
316670eb 4409 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 4410
316670eb
A		 4411 /* initialization */
4412 sav->replay = NULL;
4413 sav->key_auth = NULL;
4414 sav->key_enc = NULL;
4415 sav->sched = NULL;
4416 sav->schedlen = 0;
4417 sav->iv = NULL;
4418 sav->lft_c = NULL;
4419 sav->lft_h = NULL;
4420 sav->lft_s = NULL;
4421 sav->remote_ike_port = 0;
4422 sav->natt_last_activity = natt_now;
4423 sav->natt_encapsulated_src_port = 0;
39236c6e 4424
316670eb
A		 4425 sav->alg_auth = alg_auth;
4426 sav->alg_enc = alg_enc;
4427 sav->flags = flags;
4428 sav->pid = pid;
4429 sav->seq = seq;
4430 key_setspi(sav, htonl(spi));
39236c6e 4431
316670eb
A		 4432 /*
4433 * Verify that a nat-traversal port was specified if
4434 * the nat-traversal flag is set.
4435 */
4436 if ((sav->flags & SADB_X_EXT_NATT) != 0) {
4437 if (natt_port == 0) {
4438 ipseclog((LOG_DEBUG, "key_setsaval2: natt port not set.\n"));
4439 error = EINVAL;
4440 goto fail;
4441 }
4442 sav->remote_ike_port = natt_port;
4443 }
39236c6e 4444
316670eb
A		 4445 /*
4446 * Verify if SADB_X_EXT_NATT_MULTIPLEUSERS flag is set that
39236c6e 4447 * SADB_X_EXT_NATT is set and SADB_X_EXT_NATT_KEEPALIVE is not
316670eb
A		 4448 * set (we're not behind nat) - otherwise clear it.
4449 */
4450 if ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0)
4451 if ((sav->flags & SADB_X_EXT_NATT) == 0 ||
4452 (sav->flags & SADB_X_EXT_NATT_KEEPALIVE) != 0)
4453 sav->flags &= ~SADB_X_EXT_NATT_MULTIPLEUSERS;
39236c6e 4454
316670eb
A		 4455 /* replay window */
4456 if ((flags & SADB_X_EXT_OLD) == 0) {
4457 sav->replay = keydb_newsecreplay(replay);
4458 if (sav->replay == NULL) {
4459 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4460 error = ENOBUFS;
4461 goto fail;
4462 }
4463 }
4464
4465 /* Authentication keys */
4466 sav->key_auth = (__typeof__(sav->key_auth))key_newbuf(key_auth, key_auth_len);
4467 if (sav->key_auth == NULL) {
4468 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4469 error = ENOBUFS;
4470 goto fail;
4471 }
4472
4473 /* Encryption key */
4474 sav->key_enc = (__typeof__(sav->key_enc))key_newbuf(key_enc, key_enc_len);
4475 if (sav->key_enc == NULL) {
4476 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4477 error = ENOBUFS;
4478 goto fail;
4479 }
4480
4481 /* set iv */
4482 sav->ivlen = 0;
39236c6e 4483
316670eb
A		 4484 if (satype == SADB_SATYPE_ESP) {
4485#if IPSEC_ESP
4486 algo = esp_algorithm_lookup(sav->alg_enc);
4487 if (algo && algo->ivlen)
4488 sav->ivlen = (*algo->ivlen)(algo, sav);
4489 if (sav->ivlen != 0) {
4490 KMALLOC_NOWAIT(sav->iv, caddr_t, sav->ivlen);
4491 if (sav->iv == 0) {
4492 lck_mtx_unlock(sadb_mutex);
4493 KMALLOC_WAIT(sav->iv, caddr_t, sav->ivlen);
4494 lck_mtx_lock(sadb_mutex);
4495 if (sav->iv == 0) {
4496 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4497 error = ENOBUFS;
4498 goto fail;
4499 }
4500 }
4501 /* initialize */
d190cdc3
A		 4502 if (sav->alg_enc == SADB_X_EALG_AES_GCM) {
4503 bzero(sav->iv, sav->ivlen);
4504 } else {
4505 key_randomfill(sav->iv, sav->ivlen);
4506 }
316670eb
A		 4507 }
4508#endif
4509 }
39236c6e 4510
316670eb
A		 4511 /* reset created */
4512 microtime(&tv);
4513 sav->created = tv.tv_sec;
4514
4515 /* make lifetime for CURRENT */
4516 KMALLOC_NOWAIT(sav->lft_c, struct sadb_lifetime *,
4517 sizeof(struct sadb_lifetime));
4518 if (sav->lft_c == NULL) {
4519 lck_mtx_unlock(sadb_mutex);
4520 KMALLOC_WAIT(sav->lft_c, struct sadb_lifetime *,
4521 sizeof(struct sadb_lifetime));
4522 lck_mtx_lock(sadb_mutex);
4523 if (sav->lft_c == NULL) {
4524 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4525 error = ENOBUFS;
4526 goto fail;
4527 }
4528 }
4529
4530 microtime(&tv);
4531
4532 sav->lft_c->sadb_lifetime_len =
4533 PFKEY_UNIT64(sizeof(struct sadb_lifetime));
4534 sav->lft_c->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
4535 sav->lft_c->sadb_lifetime_allocations = 0;
4536 sav->lft_c->sadb_lifetime_bytes = 0;
4537 sav->lft_c->sadb_lifetime_addtime = tv.tv_sec;
4538 sav->lft_c->sadb_lifetime_usetime = 0;
4539
4540 /* lifetimes for HARD and SOFT */
4541 sav->lft_h = (__typeof__(sav->lft_h))key_newbuf(lifetime_hard,
4542 sizeof(*lifetime_hard));
4543 if (sav->lft_h == NULL) {
4544 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4545 error = ENOBUFS;
4546 goto fail;
4547 }
4548 sav->lft_s = (__typeof__(sav->lft_s))key_newbuf(lifetime_soft,
4549 sizeof(*lifetime_soft));
4550 if (sav->lft_s == NULL) {
4551 ipseclog((LOG_DEBUG, "key_setsaval: No more memory.\n"));
4552 error = ENOBUFS;
4553 goto fail;
4554 }
4555
4556 return 0;
4557
4558fail:
4559 /* initialization */
4560 if (sav->replay != NULL) {
4561 keydb_delsecreplay(sav->replay);
4562 sav->replay = NULL;
4563 }
4564 if (sav->key_auth != NULL) {
4565 bzero(_KEYBUF(sav->key_auth), _KEYLEN(sav->key_auth));
4566 KFREE(sav->key_auth);
4567 sav->key_auth = NULL;
4568 }
4569 if (sav->key_enc != NULL) {
4570 bzero(_KEYBUF(sav->key_enc), _KEYLEN(sav->key_enc));
4571 KFREE(sav->key_enc);
4572 sav->key_enc = NULL;
4573 }
4574 if (sav->sched) {
4575 bzero(sav->sched, sav->schedlen);
4576 KFREE(sav->sched);
4577 sav->sched = NULL;
4578 }
4579 if (sav->iv != NULL) {
4580 KFREE(sav->iv);
4581 sav->iv = NULL;
4582 }
4583 if (sav->lft_c != NULL) {
4584 KFREE(sav->lft_c);
4585 sav->lft_c = NULL;
4586 }
4587 if (sav->lft_h != NULL) {
4588 KFREE(sav->lft_h);
4589 sav->lft_h = NULL;
4590 }
4591 if (sav->lft_s != NULL) {
4592 KFREE(sav->lft_s);
4593 sav->lft_s = NULL;
4594 }
4595
4596 return error;
4597}
4598
1c79356b
A		 4599/*
4600 * validation with a secasvar entry, and set SADB_SATYPE_MATURE.
4601 * OUT: 0: valid
4602 * other: errno
4603 */
4604static int
6d2010ae 4605key_mature(
39236c6e 4606 struct secasvar *sav)
1c79356b
A		 4607{
4608 int mature;
4609 int checkmask = 0; /* 2^0: ealg 2^1: aalg 2^2: calg */
4610 int mustmask = 0; /* 2^0: ealg 2^1: aalg 2^2: calg */
39236c6e 4611
1c79356b 4612 mature = 0;
39236c6e 4613
91447636 4614 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 4615
1c79356b 4616 /* check SPI value */
9bccf70c 4617 switch (sav->sah->saidx.proto) {
39236c6e
A		 4618 case IPPROTO_ESP:
4619 case IPPROTO_AH:
4620
4621 /* No reason to test if this is >= 0, because ntohl(sav->spi) is unsigned. */
4622 if (ntohl(sav->spi) <= 255) {
4623 ipseclog((LOG_DEBUG,
4624 "key_mature: illegal range of SPI %u.\n",
4625 (u_int32_t)ntohl(sav->spi)));
4626 return EINVAL;
4627 }
4628 break;
1c79356b 4629 }
39236c6e 4630
1c79356b
A		 4631 /* check satype */
4632 switch (sav->sah->saidx.proto) {
39236c6e
A		 4633 case IPPROTO_ESP:
4634 /* check flags */
4635 if ((sav->flags & SADB_X_EXT_OLD)
4636 && (sav->flags & SADB_X_EXT_DERIV)) {
4637 ipseclog((LOG_DEBUG, "key_mature: "
4638 "invalid flag (derived) given to old-esp.\n"));
4639 return EINVAL;
4640 }
4641 if (sav->alg_auth == SADB_AALG_NONE)
4642 checkmask = 1;
4643 else
4644 checkmask = 3;
4645 mustmask = 1;
4646 break;
4647 case IPPROTO_AH:
4648 /* check flags */
4649 if (sav->flags & SADB_X_EXT_DERIV) {
4650 ipseclog((LOG_DEBUG, "key_mature: "
4651 "invalid flag (derived) given to AH SA.\n"));
4652 return EINVAL;
4653 }
4654 if (sav->alg_enc != SADB_EALG_NONE) {
4655 ipseclog((LOG_DEBUG, "key_mature: "
4656 "protocol and algorithm mismated.\n"));
4657 return(EINVAL);
4658 }
4659 checkmask = 2;
4660 mustmask = 2;
4661 break;
4662 case IPPROTO_IPCOMP:
4663 if (sav->alg_auth != SADB_AALG_NONE) {
4664 ipseclog((LOG_DEBUG, "key_mature: "
4665 "protocol and algorithm mismated.\n"));
4666 return(EINVAL);
4667 }
4668 if ((sav->flags & SADB_X_EXT_RAWCPI) == 0
4669 && ntohl(sav->spi) >= 0x10000) {
4670 ipseclog((LOG_DEBUG, "key_mature: invalid cpi for IPComp.\n"));
4671 return(EINVAL);
4672 }
4673 checkmask = 4;
4674 mustmask = 4;
4675 break;
4676 default:
4677 ipseclog((LOG_DEBUG, "key_mature: Invalid satype.\n"));
4678 return EPROTONOSUPPORT;
1c79356b 4679 }
39236c6e 4680
1c79356b
A		 4681 /* check authentication algorithm */
4682 if ((checkmask & 2) != 0) {
9bccf70c 4683 const struct ah_algorithm *algo;
1c79356b 4684 int keylen;
39236c6e 4685
9bccf70c
A		 4686 algo = ah_algorithm_lookup(sav->alg_auth);
4687 if (!algo) {
55e303ae 4688 ipseclog((LOG_DEBUG,"key_mature: "
39236c6e 4689 "unknown authentication algorithm.\n"));
1c79356b
A		 4690 return EINVAL;
4691 }
39236c6e 4692
1c79356b 4693 /* algorithm-dependent check */
1c79356b
A		 4694 if (sav->key_auth)
4695 keylen = sav->key_auth->sadb_key_bits;
4696 else
4697 keylen = 0;
4698 if (keylen < algo->keymin || algo->keymax < keylen) {
55e303ae 4699 ipseclog((LOG_DEBUG,
39236c6e
A		 4700 "key_mature: invalid AH key length %d "
4701 "(%d-%d allowed)\n",
4702 keylen, algo->keymin, algo->keymax));
1c79356b
A		 4703 return EINVAL;
4704 }
39236c6e 4705
1c79356b
A		 4706 if (algo->mature) {
4707 if ((*algo->mature)(sav)) {
4708 /* message generated in per-algorithm function*/
4709 return EINVAL;
4710 } else
4711 mature = SADB_SATYPE_AH;
4712 }
39236c6e 4713
1c79356b 4714 if ((mustmask & 2) != 0 && mature != SADB_SATYPE_AH) {
55e303ae 4715 ipseclog((LOG_DEBUG, "key_mature: no satisfy algorithm for AH\n"));
1c79356b
A		 4716 return EINVAL;
4717 }
4718 }
39236c6e 4719
1c79356b
A		 4720 /* check encryption algorithm */
4721 if ((checkmask & 1) != 0) {
4722#if IPSEC_ESP
9bccf70c 4723 const struct esp_algorithm *algo;
1c79356b 4724 int keylen;
39236c6e 4725
9bccf70c
A		 4726 algo = esp_algorithm_lookup(sav->alg_enc);
4727 if (!algo) {
55e303ae 4728 ipseclog((LOG_DEBUG, "key_mature: unknown encryption algorithm.\n"));
1c79356b
A		 4729 return EINVAL;
4730 }
39236c6e 4731
1c79356b 4732 /* algorithm-dependent check */
1c79356b
A		 4733 if (sav->key_enc)
4734 keylen = sav->key_enc->sadb_key_bits;
4735 else
4736 keylen = 0;
4737 if (keylen < algo->keymin || algo->keymax < keylen) {
55e303ae 4738 ipseclog((LOG_DEBUG,
39236c6e
A		 4739 "key_mature: invalid ESP key length %d "
4740 "(%d-%d allowed)\n",
4741 keylen, algo->keymin, algo->keymax));
1c79356b
A		 4742 return EINVAL;
4743 }
39236c6e 4744
1c79356b
A		 4745 if (algo->mature) {
4746 if ((*algo->mature)(sav)) {
4747 /* message generated in per-algorithm function*/
4748 return EINVAL;
4749 } else
4750 mature = SADB_SATYPE_ESP;
4751 }
39236c6e 4752
1c79356b 4753 if ((mustmask & 1) != 0 && mature != SADB_SATYPE_ESP) {
55e303ae 4754 ipseclog((LOG_DEBUG, "key_mature: no satisfy algorithm for ESP\n"));
1c79356b
A		 4755 return EINVAL;
4756 }
4757#else /*IPSEC_ESP*/
55e303ae 4758 ipseclog((LOG_DEBUG, "key_mature: ESP not supported in this configuration\n"));
1c79356b
A		 4759 return EINVAL;
4760#endif
4761 }
39236c6e 4762
1c79356b
A		 4763 /* check compression algorithm */
4764 if ((checkmask & 4) != 0) {
9bccf70c 4765 const struct ipcomp_algorithm *algo;
39236c6e 4766
9bccf70c
A		 4767 /* algorithm-dependent check */
4768 algo = ipcomp_algorithm_lookup(sav->alg_enc);
4769 if (!algo) {
55e303ae 4770 ipseclog((LOG_DEBUG, "key_mature: unknown compression algorithm.\n"));
1c79356b
A		 4771 return EINVAL;
4772 }
4773 }
39236c6e 4774
1c79356b 4775 key_sa_chgstate(sav, SADB_SASTATE_MATURE);
39236c6e 4776
1c79356b
A		 4777 return 0;
4778}
4779
4780/*
4781 * subroutine for SADB_GET and SADB_DUMP.
1c79356b 4782 */
9bccf70c 4783static struct mbuf *
6d2010ae 4784key_setdumpsa(
39236c6e
A		 4785 struct secasvar *sav,
4786 u_int8_t type,
4787 u_int8_t satype,
4788 u_int32_t seq,
4789 u_int32_t pid)
1c79356b 4790{
9bccf70c
A		 4791 struct mbuf *result = NULL, *tres = NULL, *m;
4792 int l = 0;
1c79356b 4793 int i;
9bccf70c
A		 4794 void *p;
4795 int dumporder[] = {
4796 SADB_EXT_SA, SADB_X_EXT_SA2,
4797 SADB_EXT_LIFETIME_HARD, SADB_EXT_LIFETIME_SOFT,
4798 SADB_EXT_LIFETIME_CURRENT, SADB_EXT_ADDRESS_SRC,
4799 SADB_EXT_ADDRESS_DST, SADB_EXT_ADDRESS_PROXY, SADB_EXT_KEY_AUTH,
4800 SADB_EXT_KEY_ENCRYPT, SADB_EXT_IDENTITY_SRC,
4801 SADB_EXT_IDENTITY_DST, SADB_EXT_SENSITIVITY,
4802 };
2d21ac55 4803
9bccf70c
A		 4804 m = key_setsadbmsg(type, 0, satype, seq, pid, sav->refcnt);
4805 if (m == NULL)
4806 goto fail;
4807 result = m;
39236c6e 4808
9bccf70c
A		 4809 for (i = sizeof(dumporder)/sizeof(dumporder[0]) - 1; i >= 0; i--) {
4810 m = NULL;
4811 p = NULL;
4812 switch (dumporder[i]) {
39236c6e
A		 4813 case SADB_EXT_SA:
4814 m = key_setsadbsa(sav);
4815 if (!m)
4816 goto fail;
4817 break;
4818
4819 case SADB_X_EXT_SA2:
4820 m = key_setsadbxsa2(sav->sah->saidx.mode,
4821 sav->replay ? sav->replay->count : 0,
fe8ab488
A		 4822 sav->sah->saidx.reqid,
4823 sav->flags2);
39236c6e
A		 4824 if (!m)
4825 goto fail;
4826 break;
4827
4828 case SADB_EXT_ADDRESS_SRC:
4829 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
4830 (struct sockaddr *)&sav->sah->saidx.src,
4831 FULLMASK, IPSEC_ULPROTO_ANY);
4832 if (!m)
4833 goto fail;
4834 break;
4835
4836 case SADB_EXT_ADDRESS_DST:
4837 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
4838 (struct sockaddr *)&sav->sah->saidx.dst,
4839 FULLMASK, IPSEC_ULPROTO_ANY);
4840 if (!m)
4841 goto fail;
4842 break;
4843
4844 case SADB_EXT_KEY_AUTH:
4845 if (!sav->key_auth)
4846 continue;
4847 l = PFKEY_UNUNIT64(sav->key_auth->sadb_key_len);
4848 p = sav->key_auth;
4849 break;
4850
4851 case SADB_EXT_KEY_ENCRYPT:
4852 if (!sav->key_enc)
4853 continue;
4854 l = PFKEY_UNUNIT64(sav->key_enc->sadb_key_len);
4855 p = sav->key_enc;
4856 break;
4857
4858 case SADB_EXT_LIFETIME_CURRENT:
4859 if (!sav->lft_c)
4860 continue;
4861 l = PFKEY_UNUNIT64(((struct sadb_ext *)sav->lft_c)->sadb_ext_len);
4862 p = sav->lft_c;
4863 break;
4864
4865 case SADB_EXT_LIFETIME_HARD:
4866 if (!sav->lft_h)
4867 continue;
4868 l = PFKEY_UNUNIT64(((struct sadb_ext *)sav->lft_h)->sadb_ext_len);
4869 p = sav->lft_h;
4870 break;
4871
4872 case SADB_EXT_LIFETIME_SOFT:
4873 if (!sav->lft_s)
4874 continue;
4875 l = PFKEY_UNUNIT64(((struct sadb_ext *)sav->lft_s)->sadb_ext_len);
4876 p = sav->lft_s;
4877 break;
4878
4879 case SADB_EXT_ADDRESS_PROXY:
4880 case SADB_EXT_IDENTITY_SRC:
4881 case SADB_EXT_IDENTITY_DST:
4882 /* XXX: should we brought from SPD ? */
4883 case SADB_EXT_SENSITIVITY:
4884 default:
9bccf70c 4885 continue;
9bccf70c 4886 }
39236c6e 4887
9bccf70c
A		 4888 if ((!m && !p) || (m && p))
4889 goto fail;
4890 if (p && tres) {
3e170ce0 4891 M_PREPEND(tres, l, M_WAITOK, 1);
9bccf70c
A		 4892 if (!tres)
4893 goto fail;
4894 bcopy(p, mtod(tres, caddr_t), l);
4895 continue;
1c79356b 4896 }
9bccf70c
A		 4897 if (p) {
4898 m = key_alloc_mbuf(l);
4899 if (!m)
4900 goto fail;
4901 m_copyback(m, 0, l, p);
4902 }
39236c6e 4903
9bccf70c
A		 4904 if (tres)
4905 m_cat(m, tres);
4906 tres = m;
1c79356b 4907 }
39236c6e 4908
9bccf70c 4909 m_cat(result, tres);
39236c6e 4910
fe8ab488
A		 4911 if (sav->sah && (sav->sah->outgoing_if || sav->sah->ipsec_if)) {
4912 m = key_setsadbipsecif(NULL, ifindex2ifnet[sav->sah->outgoing_if], sav->sah->ipsec_if, 0);
4913 if (!m)
4914 goto fail;
4915 m_cat(result, m);
4916 }
4917
9bccf70c
A		 4918 if (result->m_len < sizeof(struct sadb_msg)) {
4919 result = m_pullup(result, sizeof(struct sadb_msg));
4920 if (result == NULL)
4921 goto fail;
4922 }
39236c6e 4923
9bccf70c
A		 4924 result->m_pkthdr.len = 0;
4925 for (m = result; m; m = m->m_next)
4926 result->m_pkthdr.len += m->m_len;
39236c6e 4927
9bccf70c 4928 mtod(result, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 4929 PFKEY_UNIT64(result->m_pkthdr.len);
4930
9bccf70c 4931 return result;
39236c6e 4932
9bccf70c
A		 4933fail:
4934 m_freem(result);
4935 m_freem(tres);
4936 return NULL;
1c79356b 4937}
1c79356b
A		 4938
4939/*
4940 * set data into sadb_msg.
1c79356b 4941 */
9bccf70c 4942static struct mbuf *
6d2010ae 4943key_setsadbmsg(
39236c6e
A		 4944 u_int8_t type,
4945 u_int16_t tlen,
4946 u_int8_t satype,
4947 u_int32_t seq,
4948 pid_t pid,
4949 u_int16_t reserved)
1c79356b 4950{
9bccf70c 4951 struct mbuf *m;
1c79356b 4952 struct sadb_msg *p;
9bccf70c 4953 int len;
39236c6e 4954
9bccf70c
A		 4955 len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
4956 if (len > MCLBYTES)
4957 return NULL;
4958 MGETHDR(m, M_DONTWAIT, MT_DATA);
4959 if (m && len > MHLEN) {
4960 MCLGET(m, M_DONTWAIT);
4961 if ((m->m_flags & M_EXT) == 0) {
4962 m_freem(m);
4963 m = NULL;
4964 }
4965 }
4966 if (!m)
4967 return NULL;
4968 m->m_pkthdr.len = m->m_len = len;
4969 m->m_next = NULL;
39236c6e 4970
9bccf70c 4971 p = mtod(m, struct sadb_msg *);
39236c6e 4972
1c79356b
A		 4973 bzero(p, len);
4974 p->sadb_msg_version = PF_KEY_V2;
4975 p->sadb_msg_type = type;
4976 p->sadb_msg_errno = 0;
4977 p->sadb_msg_satype = satype;
4978 p->sadb_msg_len = PFKEY_UNIT64(tlen);
9bccf70c 4979 p->sadb_msg_reserved = reserved;
1c79356b
A		 4980 p->sadb_msg_seq = seq;
4981 p->sadb_msg_pid = (u_int32_t)pid;
39236c6e 4982
9bccf70c 4983 return m;
1c79356b
A		 4984}
4985
4986/*
4987 * copy secasvar data into sadb_address.
1c79356b 4988 */
9bccf70c 4989static struct mbuf *
6d2010ae 4990key_setsadbsa(
39236c6e 4991 struct secasvar *sav)
1c79356b 4992{
9bccf70c 4993 struct mbuf *m;
1c79356b 4994 struct sadb_sa *p;
9bccf70c 4995 int len;
39236c6e 4996
9bccf70c
A		 4997 len = PFKEY_ALIGN8(sizeof(struct sadb_sa));
4998 m = key_alloc_mbuf(len);
4999 if (!m || m->m_next) { /*XXX*/
5000 if (m)
5001 m_freem(m);
5002 return NULL;
5003 }
39236c6e 5004
9bccf70c 5005 p = mtod(m, struct sadb_sa *);
39236c6e 5006
1c79356b
A		 5007 bzero(p, len);
5008 p->sadb_sa_len = PFKEY_UNIT64(len);
5009 p->sadb_sa_exttype = SADB_EXT_SA;
5010 p->sadb_sa_spi = sav->spi;
5011 p->sadb_sa_replay = (sav->replay != NULL ? sav->replay->wsize : 0);
5012 p->sadb_sa_state = sav->state;
5013 p->sadb_sa_auth = sav->alg_auth;
5014 p->sadb_sa_encrypt = sav->alg_enc;
5015 p->sadb_sa_flags = sav->flags;
39236c6e 5016
9bccf70c 5017 return m;
1c79356b 5018}
1c79356b
A		 5019
5020/*
5021 * set data into sadb_address.
1c79356b 5022 */
9bccf70c 5023static struct mbuf *
6d2010ae 5024key_setsadbaddr(
39236c6e
A		 5025 u_int16_t exttype,
5026 struct sockaddr *saddr,
5027 u_int8_t prefixlen,
5028 u_int16_t ul_proto)
1c79356b 5029{
9bccf70c 5030 struct mbuf *m;
1c79356b
A		 5031 struct sadb_address *p;
5032 size_t len;
39236c6e 5033
9bccf70c 5034 len = PFKEY_ALIGN8(sizeof(struct sadb_address)) +
39236c6e 5035 PFKEY_ALIGN8(saddr->sa_len);
9bccf70c
A		 5036 m = key_alloc_mbuf(len);
5037 if (!m || m->m_next) { /*XXX*/
5038 if (m)
5039 m_freem(m);
5040 return NULL;
5041 }
39236c6e 5042
9bccf70c 5043 p = mtod(m, struct sadb_address *);
39236c6e 5044
1c79356b
A		 5045 bzero(p, len);
5046 p->sadb_address_len = PFKEY_UNIT64(len);
5047 p->sadb_address_exttype = exttype;
5048 p->sadb_address_proto = ul_proto;
55e303ae
A		 5049 if (prefixlen == FULLMASK) {
5050 switch (saddr->sa_family) {
39236c6e
A		 5051 case AF_INET:
5052 prefixlen = sizeof(struct in_addr) << 3;
5053 break;
5054 case AF_INET6:
5055 prefixlen = sizeof(struct in6_addr) << 3;
5056 break;
5057 default:
5058 ; /*XXX*/
55e303ae
A		 5059 }
5060 }
1c79356b
A		 5061 p->sadb_address_prefixlen = prefixlen;
5062 p->sadb_address_reserved = 0;
39236c6e 5063
9bccf70c 5064 bcopy(saddr,
39236c6e
A		 5065 mtod(m, caddr_t) + PFKEY_ALIGN8(sizeof(struct sadb_address)),
5066 saddr->sa_len);
5067
5068 return m;
5069}
1c79356b 5070
39236c6e
A		 5071static struct mbuf *
5072key_setsadbipsecif(ifnet_t internal_if,
5073 ifnet_t outgoing_if,
5074 ifnet_t ipsec_if,
5075 int init_disabled)
5076{
5077 struct mbuf *m;
5078 struct sadb_x_ipsecif *p;
5079 size_t len;
5080
5081 len = PFKEY_ALIGN8(sizeof(struct sadb_x_ipsecif));
5082 m = key_alloc_mbuf(len);
5083 if (!m || m->m_next) { /*XXX*/
5084 if (m)
5085 m_freem(m);
5086 return NULL;
5087 }
5088
5089 p = mtod(m, struct sadb_x_ipsecif *);
5090
5091 bzero(p, len);
5092 p->sadb_x_ipsecif_len = PFKEY_UNIT64(len);
5093 p->sadb_x_ipsecif_exttype = SADB_X_EXT_IPSECIF;
5094
5095 if (internal_if && internal_if->if_xname)
fe8ab488 5096 strlcpy(p->sadb_x_ipsecif_internal_if, internal_if->if_xname, IFXNAMSIZ);
39236c6e 5097 if (outgoing_if && outgoing_if->if_xname)
fe8ab488 5098 strlcpy(p->sadb_x_ipsecif_outgoing_if, outgoing_if->if_xname, IFXNAMSIZ);
39236c6e 5099 if (ipsec_if && ipsec_if->if_xname)
fe8ab488 5100 strlcpy(p->sadb_x_ipsecif_ipsec_if, ipsec_if->if_xname, IFXNAMSIZ);
39236c6e
A		 5101
5102 p->sadb_x_ipsecif_init_disabled = init_disabled;
5103
9bccf70c 5104 return m;
1c79356b
A		 5105}
5106
b0d623f7
A		 5107/*
5108 * set data into sadb_session_id
5109 */
5110static struct mbuf *
5111key_setsadbsession_id (u_int64_t session_ids[])
5112{
5113 struct mbuf *m;
5114 struct sadb_session_id *p;
5115 size_t len;
39236c6e 5116
b0d623f7
A		 5117 len = PFKEY_ALIGN8(sizeof(*p));
5118 m = key_alloc_mbuf(len);
5119 if (!m || m->m_next) { /*XXX*/
5120 if (m)
5121 m_freem(m);
5122 return NULL;
5123 }
39236c6e 5124
b0d623f7 5125 p = mtod(m, __typeof__(p));
39236c6e 5126
b0d623f7
A		 5127 bzero(p, len);
5128 p->sadb_session_id_len = PFKEY_UNIT64(len);
5129 p->sadb_session_id_exttype = SADB_EXT_SESSION_ID;
5130 p->sadb_session_id_v[0] = session_ids[0];
5131 p->sadb_session_id_v[1] = session_ids[1];
39236c6e 5132
b0d623f7
A		 5133 return m;
5134}
5135
5136/*
5137 * copy stats data into sadb_sastat type.
5138 */
5139static struct mbuf *
5140key_setsadbsastat (u_int32_t dir,
39236c6e
A		 5141 struct sastat *stats,
5142 u_int32_t max_stats)
b0d623f7
A		 5143{
5144 struct mbuf *m;
5145 struct sadb_sastat *p;
5146 int list_len, len;
39236c6e 5147
b0d623f7 5148 if (!stats) {
39236c6e 5149 return NULL;
b0d623f7 5150 }
39236c6e 5151
b0d623f7
A		 5152 list_len = sizeof(*stats) * max_stats;
5153 len = PFKEY_ALIGN8(sizeof(*p)) + PFKEY_ALIGN8(list_len);
5154 m = key_alloc_mbuf(len);
5155 if (!m || m->m_next) { /*XXX*/
5156 if (m)
5157 m_freem(m);
5158 return NULL;
5159 }
39236c6e 5160
b0d623f7 5161 p = mtod(m, __typeof__(p));
39236c6e 5162
b0d623f7
A		 5163 bzero(p, len);
5164 p->sadb_sastat_len = PFKEY_UNIT64(len);
5165 p->sadb_sastat_exttype = SADB_EXT_SASTAT;
5166 p->sadb_sastat_dir = dir;
5167 p->sadb_sastat_list_len = max_stats;
5168 if (list_len) {
39236c6e 5169 bcopy(stats,
b0d623f7
A		 5170 mtod(m, caddr_t) + PFKEY_ALIGN8(sizeof(*p)),
5171 list_len);
5172 }
39236c6e 5173
b0d623f7
A		 5174 return m;
5175}
5176
9bccf70c 5177#if 0
1c79356b
A		 5178/*
5179 * set data into sadb_ident.
1c79356b 5180 */
9bccf70c 5181static struct mbuf *
6d2010ae 5182key_setsadbident(
39236c6e
A		 5183 u_int16_t exttype,
5184 u_int16_t idtype,
5185 caddr_t string,
5186 int stringlen,
5187 u_int64_t id)
1c79356b 5188{
9bccf70c 5189 struct mbuf *m;
1c79356b 5190 struct sadb_ident *p;
9bccf70c 5191 size_t len;
39236c6e 5192
9bccf70c
A		 5193 len = PFKEY_ALIGN8(sizeof(struct sadb_ident)) + PFKEY_ALIGN8(stringlen);
5194 m = key_alloc_mbuf(len);
5195 if (!m || m->m_next) { /*XXX*/
5196 if (m)
5197 m_freem(m);
5198 return NULL;
5199 }
39236c6e 5200
9bccf70c 5201 p = mtod(m, struct sadb_ident *);
39236c6e 5202
1c79356b
A		 5203 bzero(p, len);
5204 p->sadb_ident_len = PFKEY_UNIT64(len);
5205 p->sadb_ident_exttype = exttype;
5206 p->sadb_ident_type = idtype;
5207 p->sadb_ident_reserved = 0;
5208 p->sadb_ident_id = id;
39236c6e 5209
9bccf70c 5210 bcopy(string,
39236c6e
A		 5211 mtod(m, caddr_t) + PFKEY_ALIGN8(sizeof(struct sadb_ident)),
5212 stringlen);
5213
9bccf70c
A		 5214 return m;
5215}
5216#endif
5217
5218/*
5219 * set data into sadb_x_sa2.
5220 */
5221static struct mbuf *
6d2010ae 5222key_setsadbxsa2(
39236c6e
A		 5223 u_int8_t mode,
5224 u_int32_t seq,
fe8ab488
A		 5225 u_int32_t reqid,
5226 u_int16_t flags)
9bccf70c
A		 5227{
5228 struct mbuf *m;
5229 struct sadb_x_sa2 *p;
5230 size_t len;
39236c6e 5231
9bccf70c
A		 5232 len = PFKEY_ALIGN8(sizeof(struct sadb_x_sa2));
5233 m = key_alloc_mbuf(len);
5234 if (!m || m->m_next) { /*XXX*/
5235 if (m)
5236 m_freem(m);
5237 return NULL;
5238 }
39236c6e 5239
9bccf70c 5240 p = mtod(m, struct sadb_x_sa2 *);
39236c6e 5241
9bccf70c
A		 5242 bzero(p, len);
5243 p->sadb_x_sa2_len = PFKEY_UNIT64(len);
5244 p->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
5245 p->sadb_x_sa2_mode = mode;
5246 p->sadb_x_sa2_reserved1 = 0;
5247 p->sadb_x_sa2_reserved2 = 0;
55e303ae 5248 p->sadb_x_sa2_sequence = seq;
9bccf70c 5249 p->sadb_x_sa2_reqid = reqid;
fe8ab488 5250 p->sadb_x_sa2_flags = flags;
39236c6e 5251
9bccf70c 5252 return m;
1c79356b
A		 5253}
5254
5255/*
5256 * set data into sadb_x_policy
1c79356b 5257 */
9bccf70c 5258static struct mbuf *
6d2010ae 5259key_setsadbxpolicy(
39236c6e
A		 5260 u_int16_t type,
5261 u_int8_t dir,
5262 u_int32_t id)
1c79356b 5263{
9bccf70c 5264 struct mbuf *m;
1c79356b 5265 struct sadb_x_policy *p;
9bccf70c 5266 size_t len;
39236c6e 5267
9bccf70c
A		 5268 len = PFKEY_ALIGN8(sizeof(struct sadb_x_policy));
5269 m = key_alloc_mbuf(len);
5270 if (!m || m->m_next) { /*XXX*/
5271 if (m)
5272 m_freem(m);
5273 return NULL;
5274 }
39236c6e 5275
9bccf70c 5276 p = mtod(m, struct sadb_x_policy *);
39236c6e 5277
1c79356b
A		 5278 bzero(p, len);
5279 p->sadb_x_policy_len = PFKEY_UNIT64(len);
5280 p->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
5281 p->sadb_x_policy_type = type;
5282 p->sadb_x_policy_dir = dir;
5283 p->sadb_x_policy_id = id;
39236c6e 5284
9bccf70c 5285 return m;
1c79356b
A		 5286}
5287
5288/* %%% utilities */
5289/*
5290 * copy a buffer into the new buffer allocated.
5291 */
5292static void *
6d2010ae 5293key_newbuf(
39236c6e
A		 5294 const void *src,
5295 u_int len)
1c79356b
A		 5296{
5297 caddr_t new;
39236c6e 5298
2d21ac55
A		 5299 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
5300 KMALLOC_NOWAIT(new, caddr_t, len);
1c79356b 5301 if (new == NULL) {
2d21ac55
A		 5302 lck_mtx_unlock(sadb_mutex);
5303 KMALLOC_WAIT(new, caddr_t, len);
5304 lck_mtx_lock(sadb_mutex);
5305 if (new == NULL) {
5306 ipseclog((LOG_DEBUG, "key_newbuf: No more memory.\n"));
5307 return NULL;
5308 }
1c79356b 5309 }
9bccf70c 5310 bcopy(src, new, len);
39236c6e 5311
1c79356b
A		 5312 return new;
5313}
5314
5315/* compare my own address
5316 * OUT: 1: true, i.e. my address.
5317 * 0: false
5318 */
5319int
6d2010ae 5320key_ismyaddr(
39236c6e 5321 struct sockaddr *sa)
1c79356b 5322{
9bccf70c
A		 5323#if INET
5324 struct sockaddr_in *sin;
5325 struct in_ifaddr *ia;
5326#endif
39236c6e 5327
1c79356b 5328 /* sanity check */
9bccf70c 5329 if (sa == NULL)
1c79356b 5330 panic("key_ismyaddr: NULL pointer is passed.\n");
39236c6e 5331
9bccf70c
A		 5332 switch (sa->sa_family) {
5333#if INET
39236c6e
A		 5334 case AF_INET:
5335 lck_rw_lock_shared(in_ifaddr_rwlock);
5336 sin = (struct sockaddr_in *)(void *)sa;
5337 for (ia = in_ifaddrhead.tqh_first; ia;
5338 ia = ia->ia_link.tqe_next) {
5339 IFA_LOCK_SPIN(&ia->ia_ifa);
5340 if (sin->sin_family == ia->ia_addr.sin_family &&
5341 sin->sin_len == ia->ia_addr.sin_len &&
5342 sin->sin_addr.s_addr == ia->ia_addr.sin_addr.s_addr)
5343 {
5344 IFA_UNLOCK(&ia->ia_ifa);
5345 lck_rw_done(in_ifaddr_rwlock);
5346 return 1;
5347 }
6d2010ae 5348 IFA_UNLOCK(&ia->ia_ifa);
9bccf70c 5349 }
39236c6e
A		 5350 lck_rw_done(in_ifaddr_rwlock);
5351 break;
9bccf70c 5352#endif
1c79356b 5353#if INET6
39236c6e
A		 5354 case AF_INET6:
5355 return key_ismyaddr6((struct sockaddr_in6 *)(void *)sa);
1c79356b
A		 5356#endif
5357 }
39236c6e 5358
1c79356b
A		 5359 return 0;
5360}
5361
5362#if INET6
5363/*
5364 * compare my own address for IPv6.
5365 * 1: ours
5366 * 0: other
5367 * NOTE: derived ip6_input() in KAME. This is necessary to modify more.
5368 */
5369#include <netinet6/in6_var.h>
5370
5371static int
6d2010ae 5372key_ismyaddr6(
39236c6e 5373 struct sockaddr_in6 *sin6)
1c79356b 5374{
1c79356b 5375 struct in6_ifaddr *ia;
9bccf70c 5376 struct in6_multi *in6m;
39236c6e 5377
6d2010ae 5378 lck_rw_lock_shared(&in6_ifaddr_rwlock);
91447636 5379 for (ia = in6_ifaddrs; ia; ia = ia->ia_next) {
6d2010ae 5380 IFA_LOCK(&ia->ia_ifa);
9bccf70c 5381 if (key_sockaddrcmp((struct sockaddr *)&sin6,
39236c6e 5382 (struct sockaddr *)&ia->ia_addr, 0) == 0) {
6d2010ae
A		 5383 IFA_UNLOCK(&ia->ia_ifa);
5384 lck_rw_done(&in6_ifaddr_rwlock);
1c79356b 5385 return 1;
91447636 5386 }
6d2010ae 5387 IFA_UNLOCK(&ia->ia_ifa);
39236c6e 5388
9bccf70c
A		 5389 /*
5390 * XXX Multicast
5391 * XXX why do we care about multlicast here while we don't care
5392 * about IPv4 multicast??
5393 * XXX scope
5394 */
5395 in6m = NULL;
6d2010ae
A		 5396 in6_multihead_lock_shared();
5397 IN6_LOOKUP_MULTI(&sin6->sin6_addr, ia->ia_ifp, in6m);
5398 in6_multihead_lock_done();
5399 if (in6m != NULL) {
5400 lck_rw_done(&in6_ifaddr_rwlock);
5401 IN6M_REMREF(in6m);
1c79356b 5402 return 1;
91447636 5403 }
1c79356b 5404 }
6d2010ae 5405 lck_rw_done(&in6_ifaddr_rwlock);
39236c6e 5406
1c79356b 5407 /* loopback, just for safety */
9bccf70c 5408 if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
1c79356b 5409 return 1;
39236c6e 5410
1c79356b
A		 5411 return 0;
5412}
5413#endif /*INET6*/
5414
1c79356b 5415/*
55e303ae
A		 5416 * compare two secasindex structure.
5417 * flag can specify to compare 2 saidxes.
5418 * compare two secasindex structure without both mode and reqid.
9bccf70c 5419 * don't compare port.
39236c6e 5420 * IN:
55e303ae
A		 5421 * saidx0: source, it can be in SAD.
5422 * saidx1: object.
39236c6e 5423 * OUT:
55e303ae
A		 5424 * 1 : equal
5425 * 0 : not equal
1c79356b
A		 5426 */
5427static int
6d2010ae 5428key_cmpsaidx(
39236c6e
A		 5429 struct secasindex *saidx0,
5430 struct secasindex *saidx1,
5431 int flag)
1c79356b
A		 5432{
5433 /* sanity */
9bccf70c 5434 if (saidx0 == NULL && saidx1 == NULL)
1c79356b 5435 return 1;
39236c6e 5436
9bccf70c 5437 if (saidx0 == NULL || saidx1 == NULL)
1c79356b 5438 return 0;
39236c6e 5439
fe8ab488
A		 5440 if (saidx0->ipsec_ifindex != 0 && saidx0->ipsec_ifindex != saidx1->ipsec_ifindex)
5441 return 0;
5442
9bccf70c
A		 5443 if (saidx0->proto != saidx1->proto)
5444 return 0;
39236c6e 5445
55e303ae
A		 5446 if (flag == CMP_EXACTLY) {
5447 if (saidx0->mode != saidx1->mode)
5448 return 0;
5449 if (saidx0->reqid != saidx1->reqid)
5450 return 0;
5451 if (bcmp(&saidx0->src, &saidx1->src, saidx0->src.ss_len) != 0 ||
5452 bcmp(&saidx0->dst, &saidx1->dst, saidx0->dst.ss_len) != 0)
5453 return 0;
5454 } else {
39236c6e 5455
55e303ae 5456 /* CMP_MODE_REQID, CMP_REQID, CMP_HEAD */
2d21ac55 5457 if (flag & CMP_REQID) {
55e303ae
A		 5458 /*
5459 * If reqid of SPD is non-zero, unique SA is required.
5460 * The result must be of same reqid in this case.
5461 */
5462 if (saidx1->reqid != 0 && saidx0->reqid != saidx1->reqid)
5463 return 0;
5464 }
39236c6e 5465
2d21ac55 5466 if (flag & CMP_MODE) {
55e303ae 5467 if (saidx0->mode != IPSEC_MODE_ANY
39236c6e 5468 && saidx0->mode != saidx1->mode)
55e303ae
A		 5469 return 0;
5470 }
39236c6e 5471
55e303ae 5472 if (key_sockaddrcmp((struct sockaddr *)&saidx0->src,
39236c6e 5473 (struct sockaddr *)&saidx1->src, flag & CMP_PORT ? 1 : 0) != 0) {
55e303ae
A		 5474 return 0;
5475 }
5476 if (key_sockaddrcmp((struct sockaddr *)&saidx0->dst,
39236c6e 5477 (struct sockaddr *)&saidx1->dst, flag & CMP_PORT ? 1 : 0) != 0) {
55e303ae
A		 5478 return 0;
5479 }
9bccf70c 5480 }
39236c6e 5481
9bccf70c
A		 5482 return 1;
5483}
5484
5485/*
5486 * compare two secindex structure exactly.
5487 * IN:
5488 * spidx0: source, it is often in SPD.
5489 * spidx1: object, it is often from PFKEY message.
5490 * OUT:
5491 * 1 : equal
5492 * 0 : not equal
5493 */
5494static int
6d2010ae 5495key_cmpspidx_exactly(
39236c6e
A		 5496 struct secpolicyindex *spidx0,
5497 struct secpolicyindex *spidx1)
9bccf70c
A		 5498{
5499 /* sanity */
5500 if (spidx0 == NULL && spidx1 == NULL)
5501 return 1;
39236c6e 5502
9bccf70c
A		 5503 if (spidx0 == NULL || spidx1 == NULL)
5504 return 0;
39236c6e 5505
9bccf70c 5506 if (spidx0->prefs != spidx1->prefs
39236c6e
A		 5507 || spidx0->prefd != spidx1->prefd
5508 || spidx0->ul_proto != spidx1->ul_proto
5509 || spidx0->internal_if != spidx1->internal_if)
9bccf70c 5510 return 0;
39236c6e 5511
9bccf70c 5512 if (key_sockaddrcmp((struct sockaddr *)&spidx0->src,
39236c6e 5513 (struct sockaddr *)&spidx1->src, 1) != 0) {
1c79356b 5514 return 0;
9bccf70c
A		 5515 }
5516 if (key_sockaddrcmp((struct sockaddr *)&spidx0->dst,
39236c6e 5517 (struct sockaddr *)&spidx1->dst, 1) != 0) {
9bccf70c
A		 5518 return 0;
5519 }
39236c6e
A		 5520
5521 if (key_sockaddrcmp((struct sockaddr *)&spidx0->src_range.start,
5522 (struct sockaddr *)&spidx1->src_range.start, 1) != 0) {
5523 return 0;
5524 }
5525 if (key_sockaddrcmp((struct sockaddr *)&spidx0->src_range.end,
5526 (struct sockaddr *)&spidx1->src_range.end, 1) != 0) {
5527 return 0;
5528 }
5529 if (key_sockaddrcmp((struct sockaddr *)&spidx0->dst_range.start,
5530 (struct sockaddr *)&spidx1->dst_range.start, 1) != 0) {
5531 return 0;
5532 }
5533 if (key_sockaddrcmp((struct sockaddr *)&spidx0->dst_range.end,
5534 (struct sockaddr *)&spidx1->dst_range.end, 1) != 0) {
5535 return 0;
5536 }
5537
9bccf70c
A		 5538 return 1;
5539}
5540
5541/*
5542 * compare two secindex structure with mask.
5543 * IN:
5544 * spidx0: source, it is often in SPD.
5545 * spidx1: object, it is often from IP header.
5546 * OUT:
5547 * 1 : equal
5548 * 0 : not equal
5549 */
5550static int
6d2010ae 5551key_cmpspidx_withmask(
39236c6e
A		 5552 struct secpolicyindex *spidx0,
5553 struct secpolicyindex *spidx1)
9bccf70c 5554{
39236c6e
A		 5555 int spidx0_src_is_range = 0;
5556 int spidx0_dst_is_range = 0;
5557
9bccf70c
A		 5558 /* sanity */
5559 if (spidx0 == NULL && spidx1 == NULL)
5560 return 1;
39236c6e 5561
9bccf70c 5562 if (spidx0 == NULL || spidx1 == NULL)
1c79356b 5563 return 0;
39236c6e
A		 5564
5565 if (spidx0->src_range.start.ss_len > 0)
5566 spidx0_src_is_range = 1;
5567
5568 if (spidx0->dst_range.start.ss_len > 0)
5569 spidx0_dst_is_range = 1;
5570
5571 if ((spidx0_src_is_range ? spidx0->src_range.start.ss_family : spidx0->src.ss_family) != spidx1->src.ss_family ||
5572 (spidx0_dst_is_range ? spidx0->dst_range.start.ss_family : spidx0->dst.ss_family) != spidx1->dst.ss_family ||
5573 (spidx0_src_is_range ? spidx0->src_range.start.ss_len : spidx0->src.ss_len) != spidx1->src.ss_len ||
5574 (spidx0_dst_is_range ? spidx0->dst_range.start.ss_len : spidx0->dst.ss_len) != spidx1->dst.ss_len)
1c79356b 5575 return 0;
39236c6e 5576
9bccf70c
A		 5577 /* if spidx.ul_proto == IPSEC_ULPROTO_ANY, ignore. */
5578 if (spidx0->ul_proto != (u_int16_t)IPSEC_ULPROTO_ANY
39236c6e 5579 && spidx0->ul_proto != spidx1->ul_proto)
1c79356b 5580 return 0;
39236c6e
A		 5581
5582 /* If spidx1 specifies interface, ignore src addr */
5583 if (spidx1->internal_if != NULL) {
5584 if (spidx0->internal_if == NULL
5585 || spidx0->internal_if != spidx1->internal_if)
5586 return 0;
5587
5588 /* Still check ports */
5589 switch (spidx0->src.ss_family) {
5590 case AF_INET:
5591 if (spidx0_src_is_range &&
5592 (satosin(&spidx1->src)->sin_port < satosin(&spidx0->src_range.start)->sin_port
5593 || satosin(&spidx1->src)->sin_port > satosin(&spidx0->src_range.end)->sin_port))
5594 return 0;
5595 else if (satosin(&spidx0->src)->sin_port != IPSEC_PORT_ANY
5596 && satosin(&spidx0->src)->sin_port !=
5597 satosin(&spidx1->src)->sin_port)
5598 return 0;
5599 break;
5600 case AF_INET6:
5601 if (spidx0_src_is_range &&
5602 (satosin6(&spidx1->src)->sin6_port < satosin6(&spidx0->src_range.start)->sin6_port
5603 || satosin6(&spidx1->src)->sin6_port > satosin6(&spidx0->src_range.end)->sin6_port))
5604 return 0;
5605 else if (satosin6(&spidx0->src)->sin6_port != IPSEC_PORT_ANY
5606 && satosin6(&spidx0->src)->sin6_port !=
5607 satosin6(&spidx1->src)->sin6_port)
5608 return 0;
5609 break;
5610 default:
5611 break;
5612 }
5613 } else if (spidx0_src_is_range) {
5614 if (!key_is_addr_in_range(&spidx1->src, &spidx0->src_range))
5615 return 0;
5616 } else {
5617 switch (spidx0->src.ss_family) {
5618 case AF_INET:
5619 if (satosin(&spidx0->src)->sin_port != IPSEC_PORT_ANY
5620 && satosin(&spidx0->src)->sin_port !=
5621 satosin(&spidx1->src)->sin_port)
5622 return 0;
5623 if (!key_bbcmp((caddr_t)&satosin(&spidx0->src)->sin_addr,
5624 (caddr_t)&satosin(&spidx1->src)->sin_addr, spidx0->prefs))
5625 return 0;
5626 break;
5627 case AF_INET6:
5628 if (satosin6(&spidx0->src)->sin6_port != IPSEC_PORT_ANY
5629 && satosin6(&spidx0->src)->sin6_port !=
5630 satosin6(&spidx1->src)->sin6_port)
5631 return 0;
5632 /*
5633 * scope_id check. if sin6_scope_id is 0, we regard it
5634 * as a wildcard scope, which matches any scope zone ID.
5635 */
5636 if (satosin6(&spidx0->src)->sin6_scope_id &&
5637 satosin6(&spidx1->src)->sin6_scope_id &&
5638 satosin6(&spidx0->src)->sin6_scope_id !=
5639 satosin6(&spidx1->src)->sin6_scope_id)
5640 return 0;
5641 if (!key_bbcmp((caddr_t)&satosin6(&spidx0->src)->sin6_addr,
5642 (caddr_t)&satosin6(&spidx1->src)->sin6_addr, spidx0->prefs))
5643 return 0;
5644 break;
5645 default:
5646 /* XXX */
5647 if (bcmp(&spidx0->src, &spidx1->src, spidx0->src.ss_len) != 0)
5648 return 0;
5649 break;
5650 }
5651 }
5652
5653 if (spidx0_dst_is_range) {
5654 if (!key_is_addr_in_range(&spidx1->dst, &spidx0->dst_range))
5655 return 0;
5656 } else {
5657 switch (spidx0->dst.ss_family) {
5658 case AF_INET:
5659 if (satosin(&spidx0->dst)->sin_port != IPSEC_PORT_ANY
5660 && satosin(&spidx0->dst)->sin_port !=
5661 satosin(&spidx1->dst)->sin_port)
5662 return 0;
5663 if (!key_bbcmp((caddr_t)&satosin(&spidx0->dst)->sin_addr,
5664 (caddr_t)&satosin(&spidx1->dst)->sin_addr, spidx0->prefd))
5665 return 0;
5666 break;
5667 case AF_INET6:
5668 if (satosin6(&spidx0->dst)->sin6_port != IPSEC_PORT_ANY
5669 && satosin6(&spidx0->dst)->sin6_port !=
5670 satosin6(&spidx1->dst)->sin6_port)
5671 return 0;
5672 /*
5673 * scope_id check. if sin6_scope_id is 0, we regard it
5674 * as a wildcard scope, which matches any scope zone ID.
5675 */
5676 if (satosin6(&spidx0->src)->sin6_scope_id &&
5677 satosin6(&spidx1->src)->sin6_scope_id &&
5678 satosin6(&spidx0->dst)->sin6_scope_id !=
5679 satosin6(&spidx1->dst)->sin6_scope_id)
5680 return 0;
5681 if (!key_bbcmp((caddr_t)&satosin6(&spidx0->dst)->sin6_addr,
5682 (caddr_t)&satosin6(&spidx1->dst)->sin6_addr, spidx0->prefd))
5683 return 0;
5684 break;
5685 default:
5686 /* XXX */
5687 if (bcmp(&spidx0->dst, &spidx1->dst, spidx0->dst.ss_len) != 0)
5688 return 0;
5689 break;
5690 }
5691 }
5692
9bccf70c 5693 /* XXX Do we check other field ? e.g. flowinfo */
39236c6e 5694
1c79356b
A		 5695 return 1;
5696}
5697
39236c6e
A		 5698static int
5699key_is_addr_in_range(struct sockaddr_storage *addr, struct secpolicyaddrrange *addr_range)
5700{
5701 int cmp = 0;
5702
5703 if (addr == NULL || addr_range == NULL)
5704 return 0;
5705
5706 /* Must be greater than or equal to start */
5707 cmp = key_sockaddrcmp((struct sockaddr *)addr, (struct sockaddr *)&addr_range->start, 1);
5708 if (cmp != 0 && cmp != 1)
5709 return 0;
5710
5711 /* Must be less than or equal to end */
5712 cmp = key_sockaddrcmp((struct sockaddr *)addr, (struct sockaddr *)&addr_range->end, 1);
5713 if (cmp != 0 && cmp != -1)
5714 return 0;
5715
5716 return 1;
5717}
5718
5719/*
5720 Return values:
5721 -1: sa1 < sa2
5722 0: sa1 == sa2
5723 1: sa1 > sa2
5724 2: Not comparable or error
5725 */
9bccf70c 5726static int
6d2010ae 5727key_sockaddrcmp(
39236c6e
A		 5728 struct sockaddr *sa1,
5729 struct sockaddr *sa2,
5730 int port)
9bccf70c 5731{
39236c6e
A		 5732 int result = 0;
5733 int port_result = 0;
5734
9bccf70c 5735 if (sa1->sa_family != sa2->sa_family || sa1->sa_len != sa2->sa_len)
39236c6e
A		 5736 return 2;
5737
5738 if (sa1->sa_len == 0)
5739 return 0;
5740
9bccf70c 5741 switch (sa1->sa_family) {
39236c6e
A		 5742 case AF_INET:
5743 if (sa1->sa_len != sizeof(struct sockaddr_in))
5744 return 2;
5745
5746 result = memcmp(&satosin(sa1)->sin_addr.s_addr, &satosin(sa2)->sin_addr.s_addr, sizeof(satosin(sa1)->sin_addr.s_addr));
5747
5748 if (port) {
5749 if (satosin(sa1)->sin_port < satosin(sa2)->sin_port) {
5750 port_result = -1;
5751 } else if (satosin(sa1)->sin_port > satosin(sa2)->sin_port) {
5752 port_result = 1;
5753 }
5754
5755 if (result == 0)
5756 result = port_result;
5757 else if ((result > 0 && port_result < 0) || (result < 0 && port_result > 0))
5758 return 2;
5759 }
5760
5761 break;
5762 case AF_INET6:
5763 if (sa1->sa_len != sizeof(struct sockaddr_in6))
5764 return 2; /*EINVAL*/
5765
5766 if (satosin6(sa1)->sin6_scope_id !=
5767 satosin6(sa2)->sin6_scope_id) {
5768 return 2;
5769 }
5770
5771 result = memcmp(&satosin6(sa1)->sin6_addr.s6_addr[0], &satosin6(sa2)->sin6_addr.s6_addr[0], sizeof(struct in6_addr));
5772
5773 if (port) {
5774 if (satosin6(sa1)->sin6_port < satosin6(sa2)->sin6_port) {
5775 port_result = -1;
5776 } else if (satosin6(sa1)->sin6_port > satosin6(sa2)->sin6_port) {
5777 port_result = 1;
5778 }
5779
5780 if (result == 0)
5781 result = port_result;
5782 else if ((result > 0 && port_result < 0) || (result < 0 && port_result > 0))
5783 return 2;
5784 }
5785
5786 break;
5787 default:
5788 result = memcmp(sa1, sa2, sa1->sa_len);
5789 break;
9bccf70c 5790 }
39236c6e
A		 5791
5792 if (result < 0) result = -1;
5793 else if (result > 0) result = 1;
5794
5795 return result;
9bccf70c
A		 5796}
5797
1c79356b
A		 5798/*
5799 * compare two buffers with mask.
5800 * IN:
5801 * addr1: source
5802 * addr2: object
5803 * bits: Number of bits to compare
5804 * OUT:
5805 * 1 : equal
5806 * 0 : not equal
5807 */
5808static int
6d2010ae 5809key_bbcmp(
39236c6e
A		 5810 caddr_t p1,
5811 caddr_t p2,
5812 u_int bits)
1c79356b
A		 5813{
5814 u_int8_t mask;
39236c6e 5815
1c79356b
A		 5816 /* XXX: This could be considerably faster if we compare a word
5817 * at a time, but it is complicated on LSB Endian machines */
39236c6e 5818
1c79356b
A		 5819 /* Handle null pointers */
5820 if (p1 == NULL || p2 == NULL)
5821 return (p1 == p2);
39236c6e 5822
1c79356b
A		 5823 while (bits >= 8) {
5824 if (*p1++ != *p2++)
5825 return 0;
5826 bits -= 8;
5827 }
39236c6e 5828
1c79356b
A		 5829 if (bits > 0) {
5830 mask = ~((1<<(8-bits))-1);
5831 if ((*p1 & mask) != (*p2 & mask))
5832 return 0;
5833 }
5834 return 1; /* Match! */
5835}
5836
5837/*
5838 * time handler.
5839 * scanning SPD and SAD to check status for each entries,
5840 * and do to remove or to expire.
9bccf70c 5841 * XXX: year 2038 problem may remain.
1c79356b 5842 */
e2fac8b1
A		 5843int key_timehandler_debug = 0;
5844u_int32_t spd_count = 0, sah_count = 0, dead_sah_count = 0, empty_sah_count = 0, larval_sav_count = 0, mature_sav_count = 0, dying_sav_count = 0, dead_sav_count = 0;
5845u_int64_t total_sav_count = 0;
1c79356b
A		 5846void
5847key_timehandler(void)
5848{
5849 u_int dir;
9bccf70c 5850 struct timeval tv;
2d21ac55
A		 5851 struct secpolicy **spbuf = NULL, **spptr = NULL;
5852 struct secasvar **savexbuf = NULL, **savexptr = NULL;
5853 struct secasvar **savkabuf = NULL, **savkaptr = NULL;
5854 int spbufcount = 0, savbufcount = 0, spcount = 0, savexcount = 0, savkacount = 0, cnt;
39236c6e 5855 int stop_handler = 1; /* stop the timehandler */
1c79356b 5856
39236c6e
A		 5857 microtime(&tv);
5858
2d21ac55
A		 5859 /* pre-allocate buffers before taking the lock */
5860 /* if allocation failures occur - portions of the processing will be skipped */
5861 if ((spbufcount = ipsec_policy_count) != 0) {
5862 spbufcount += 256;
5863 KMALLOC_WAIT(spbuf, struct secpolicy **, spbufcount * sizeof(struct secpolicy *));
5864 if (spbuf)
5865 spptr = spbuf;
5866 }
5867 if ((savbufcount = ipsec_sav_count) != 0) {
5868 savbufcount += 512;
5869 KMALLOC_WAIT(savexbuf, struct secasvar **, savbufcount * sizeof(struct secasvar *));
5870 if (savexbuf)
5871 savexptr = savexbuf;
5872 KMALLOC_WAIT(savkabuf, struct secasvar **, savbufcount * sizeof(struct secasvar *));
5873 if (savkabuf)
5874 savkaptr = savkabuf;
5875 }
91447636 5876 lck_mtx_lock(sadb_mutex);
1c79356b 5877 /* SPD */
2d21ac55 5878 if (spbuf) {
39236c6e 5879
2d21ac55 5880 struct secpolicy *sp, *nextsp;
39236c6e 5881
2d21ac55
A		 5882 for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
5883 for (sp = LIST_FIRST(&sptree[dir]);
5884 sp != NULL;
5885 sp = nextsp) {
39236c6e
A		 5886
5887 /* don't prevent timehandler from stopping for generate policy */
5888 if (sp->policy != IPSEC_POLICY_GENERATE)
5889 stop_handler = 0;
5890 spd_count++;
2d21ac55 5891 nextsp = LIST_NEXT(sp, chain);
39236c6e 5892
2d21ac55
A		 5893 if (sp->state == IPSEC_SPSTATE_DEAD) {
5894 key_freesp(sp, KEY_SADB_LOCKED);
5895 continue;
5896 }
39236c6e 5897
2d21ac55
A		 5898 if (sp->lifetime == 0 && sp->validtime == 0)
5899 continue;
5900 if (spbuf && spcount < spbufcount) {
5901 /* the deletion will occur next time */
5902 if ((sp->lifetime
5903 && tv.tv_sec - sp->created > sp->lifetime)
5904 || (sp->validtime
39236c6e
A		 5905 && tv.tv_sec - sp->lastused > sp->validtime)) {
5906 //key_spdexpire(sp);
5907 sp->state = IPSEC_SPSTATE_DEAD;
5908 sp->refcnt++;
5909 *spptr++ = sp;
5910 spcount++;
5911 }
2d21ac55 5912 }
9bccf70c 5913 }
1c79356b
A		 5914 }
5915 }
39236c6e 5916
1c79356b 5917 /* SAD */
39236c6e 5918 {
2d21ac55
A		 5919 struct secashead *sah, *nextsah;
5920 struct secasvar *sav, *nextsav;
39236c6e 5921
2d21ac55
A		 5922 for (sah = LIST_FIRST(&sahtree);
5923 sah != NULL;
5924 sah = nextsah) {
39236c6e
A		 5925
5926 sah_count++;
2d21ac55 5927 nextsah = LIST_NEXT(sah, chain);
39236c6e 5928
2d21ac55
A		 5929 /* if sah has been dead, then delete it and process next sah. */
5930 if (sah->state == SADB_SASTATE_DEAD) {
5931 key_delsah(sah);
e2fac8b1
A		 5932 dead_sah_count++;
5933 continue;
5934 }
39236c6e 5935
e2fac8b1 5936 if (LIST_FIRST(&sah->savtree[SADB_SASTATE_LARVAL]) == NULL &&
39236c6e
A		 5937 LIST_FIRST(&sah->savtree[SADB_SASTATE_MATURE]) == NULL &&
5938 LIST_FIRST(&sah->savtree[SADB_SASTATE_DYING]) == NULL &&
e2fac8b1 5939 LIST_FIRST(&sah->savtree[SADB_SASTATE_DEAD]) == NULL) {
39236c6e 5940 key_delsah(sah);
e2fac8b1 5941 empty_sah_count++;
1c79356b
A		 5942 continue;
5943 }
39236c6e
A		 5944
5945 if (savbufcount == 0) {
5946 continue;
5947 }
5948
5949 stop_handler = 0;
5950
2d21ac55
A		 5951 /* if LARVAL entry doesn't become MATURE, delete it. */
5952 for (sav = LIST_FIRST(&sah->savtree[SADB_SASTATE_LARVAL]);
5953 sav != NULL;
5954 sav = nextsav) {
39236c6e
A		 5955
5956 larval_sav_count++;
e2fac8b1 5957 total_sav_count++;
2d21ac55 5958 nextsav = LIST_NEXT(sav, chain);
39236c6e
A		 5959
5960 if (sav->lft_h != NULL) {
5961 /* If a hard lifetime is defined for the LARVAL SA, use it */
5962 if (sav->lft_h->sadb_lifetime_addtime != 0
5963 && tv.tv_sec - sav->created > sav->lft_h->sadb_lifetime_addtime) {
5964 if (sav->always_expire) {
5965 key_send_delete(sav);
5966 sav = NULL;
5967 } else {
5968 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
5969 key_freesav(sav, KEY_SADB_LOCKED);
5970 sav = NULL;
5971 }
5972 }
5973 } else {
5974 if (tv.tv_sec - sav->created > key_larval_lifetime) {
5975 key_freesav(sav, KEY_SADB_LOCKED);
5976 }
2d21ac55
A		 5977 }
5978 }
5979
5980 /*
5981 * If this is a NAT traversal SA with no activity,
5982 * we need to send a keep alive.
5983 *
5984 * Performed outside of the loop before so we will
5985 * only ever send one keepalive. The first SA on
5986 * the list is the one that will be used for sending
5987 * traffic, so this is the one we use for determining
5988 * when to send the keepalive.
5989 */
5990 if (savkabuf && savkacount < savbufcount) {
5991 sav = LIST_FIRST(&sah->savtree[SADB_SASTATE_MATURE]); //%%% should we check dying list if this is empty???
fe8ab488 5992 if (sav && (natt_keepalive_interval || sav->natt_interval) &&
316670eb 5993 (sav->flags & (SADB_X_EXT_NATT_KEEPALIVE | SADB_X_EXT_ESP_KEEPALIVE)) != 0) {
2d21ac55
A		 5994 sav->refcnt++;
5995 *savkaptr++ = sav;
5996 savkacount++;
5997 }
5998 }
5999
6000 /*
6001 * check MATURE entry to start to send expire message
6002 * whether or not.
6003 */
6004 for (sav = LIST_FIRST(&sah->savtree[SADB_SASTATE_MATURE]);
6005 sav != NULL;
6006 sav = nextsav) {
39236c6e
A		 6007
6008 mature_sav_count++;
e2fac8b1 6009 total_sav_count++;
2d21ac55 6010 nextsav = LIST_NEXT(sav, chain);
39236c6e 6011
2d21ac55
A		 6012 /* we don't need to check. */
6013 if (sav->lft_s == NULL)
6014 continue;
39236c6e 6015
2d21ac55
A		 6016 /* sanity check */
6017 if (sav->lft_c == NULL) {
6018 ipseclog((LOG_DEBUG,"key_timehandler: "
39236c6e 6019 "There is no CURRENT time, why?\n"));
2d21ac55
A		 6020 continue;
6021 }
39236c6e 6022
2d21ac55
A		 6023 /* check SOFT lifetime */
6024 if (sav->lft_s->sadb_lifetime_addtime != 0
39236c6e 6025 && tv.tv_sec - sav->created > sav->lft_s->sadb_lifetime_addtime) {
2d21ac55 6026 /*
39236c6e
A		 6027 * If always_expire is set, expire. Otherwise,
6028 * if the SA has not been used, delete immediately.
2d21ac55 6029 */
39236c6e
A		 6030 if (sav->lft_c->sadb_lifetime_usetime == 0
6031 && sav->always_expire == 0) {
2d21ac55
A		 6032 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
6033 key_freesav(sav, KEY_SADB_LOCKED);
6034 sav = NULL;
6035 } else if (savexbuf && savexcount < savbufcount) {
39236c6e 6036 key_sa_chgstate(sav, SADB_SASTATE_DYING);
2d21ac55
A		 6037 sav->refcnt++;
6038 *savexptr++ = sav;
6039 savexcount++;
6040 }
6041 }
39236c6e 6042
2d21ac55 6043 /* check SOFT lifetime by bytes */
1c79356b 6044 /*
2d21ac55
A		 6045 * XXX I don't know the way to delete this SA
6046 * when new SA is installed. Caution when it's
6047 * installed too big lifetime by time.
1c79356b 6048 */
2d21ac55 6049 else if (savexbuf && savexcount < savbufcount
39236c6e
A		 6050 && sav->lft_s->sadb_lifetime_bytes != 0
6051 && sav->lft_s->sadb_lifetime_bytes < sav->lft_c->sadb_lifetime_bytes) {
6052
1c79356b
A		 6053 /*
6054 * XXX If we keep to send expire
6055 * message in the status of
6056 * DYING. Do remove below code.
6057 */
2d21ac55
A		 6058 //key_expire(sav);
6059 key_sa_chgstate(sav, SADB_SASTATE_DYING);
6060 sav->refcnt++;
6061 *savexptr++ = sav;
6062 savexcount++;
1c79356b
A		 6063 }
6064 }
39236c6e 6065
2d21ac55
A		 6066 /* check DYING entry to change status to DEAD. */
6067 for (sav = LIST_FIRST(&sah->savtree[SADB_SASTATE_DYING]);
6068 sav != NULL;
6069 sav = nextsav) {
39236c6e
A		 6070
6071 dying_sav_count++;
e2fac8b1 6072 total_sav_count++;
2d21ac55 6073 nextsav = LIST_NEXT(sav, chain);
39236c6e 6074
2d21ac55
A		 6075 /* we don't need to check. */
6076 if (sav->lft_h == NULL)
6077 continue;
39236c6e 6078
2d21ac55
A		 6079 /* sanity check */
6080 if (sav->lft_c == NULL) {
6081 ipseclog((LOG_DEBUG, "key_timehandler: "
39236c6e 6082 "There is no CURRENT time, why?\n"));
2d21ac55
A		 6083 continue;
6084 }
39236c6e 6085
2d21ac55 6086 if (sav->lft_h->sadb_lifetime_addtime != 0
39236c6e
A		 6087 && tv.tv_sec - sav->created > sav->lft_h->sadb_lifetime_addtime) {
6088 if (sav->always_expire) {
6089 key_send_delete(sav);
6090 sav = NULL;
6091 } else {
6092 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
6093 key_freesav(sav, KEY_SADB_LOCKED);
6094 sav = NULL;
6095 }
2d21ac55 6096 }
1c79356b 6097#if 0 /* XXX Should we keep to send expire message until HARD lifetime ? */
2d21ac55 6098 else if (savbuf && savexcount < savbufcount
39236c6e
A		 6099 && sav->lft_s != NULL
6100 && sav->lft_s->sadb_lifetime_addtime != 0
6101 && tv.tv_sec - sav->created > sav->lft_s->sadb_lifetime_addtime) {
2d21ac55
A		 6102 /*
6103 * XXX: should be checked to be
6104 * installed the valid SA.
6105 */
39236c6e 6106
2d21ac55
A		 6107 /*
6108 * If there is no SA then sending
6109 * expire message.
6110 */
6111 //key_expire(sav);
6112 sav->refcnt++;
6113 *savexptr++ = sav;
6114 savexcount++;
6115 }
1c79356b 6116#endif
2d21ac55
A		 6117 /* check HARD lifetime by bytes */
6118 else if (sav->lft_h->sadb_lifetime_bytes != 0
39236c6e 6119 && sav->lft_h->sadb_lifetime_bytes < sav->lft_c->sadb_lifetime_bytes) {
2d21ac55
A		 6120 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
6121 key_freesav(sav, KEY_SADB_LOCKED);
6122 sav = NULL;
6123 }
1c79356b 6124 }
39236c6e 6125
2d21ac55
A		 6126 /* delete entry in DEAD */
6127 for (sav = LIST_FIRST(&sah->savtree[SADB_SASTATE_DEAD]);
6128 sav != NULL;
6129 sav = nextsav) {
39236c6e
A		 6130
6131 dead_sav_count++;
e2fac8b1 6132 total_sav_count++;
2d21ac55 6133 nextsav = LIST_NEXT(sav, chain);
39236c6e 6134
2d21ac55
A		 6135 /* sanity check */
6136 if (sav->state != SADB_SASTATE_DEAD) {
6137 ipseclog((LOG_DEBUG, "key_timehandler: "
39236c6e
A		 6138 "invalid sav->state "
6139 "(queue: %d SA: %d): "
6140 "kill it anyway\n",
6141 SADB_SASTATE_DEAD, sav->state));
2d21ac55 6142 }
39236c6e 6143
2d21ac55
A		 6144 /*
6145 * do not call key_freesav() here.
6146 * sav should already be freed, and sav->refcnt
6147 * shows other references to sav
6148 * (such as from SPD).
6149 */
1c79356b 6150 }
1c79356b 6151 }
39236c6e
A		 6152 }
6153
6154 if (++key_timehandler_debug >= 300) {
6155 if (key_debug_level) {
6156 printf("%s: total stats for %u calls\n", __FUNCTION__, key_timehandler_debug);
6157 printf("%s: walked %u SPDs\n", __FUNCTION__, spd_count);
6158 printf("%s: walked %llu SAs: LARVAL SAs %u, MATURE SAs %u, DYING SAs %u, DEAD SAs %u\n", __FUNCTION__,
6159 total_sav_count, larval_sav_count, mature_sav_count, dying_sav_count, dead_sav_count);
6160 printf("%s: walked %u SAHs: DEAD SAHs %u, EMPTY SAHs %u\n", __FUNCTION__,
6161 sah_count, dead_sah_count, empty_sah_count);
6162 if (sah_search_calls) {
6163 printf("%s: SAH search cost %d iters per call\n", __FUNCTION__,
6164 (sah_search_count/sah_search_calls));
6165 }
6166 }
6167 spd_count = 0;
6168 sah_count = 0;
6169 dead_sah_count = 0;
6170 empty_sah_count = 0;
6171 larval_sav_count = 0;
6172 mature_sav_count = 0;
6173 dying_sav_count = 0;
6174 dead_sav_count = 0;
6175 total_sav_count = 0;
6176 sah_search_count = 0;
6177 sah_search_calls = 0;
6178 key_timehandler_debug = 0;
6179 }
1c79356b
A		 6180#ifndef IPSEC_NONBLOCK_ACQUIRE
6181 /* ACQ tree */
6182 {
39236c6e
A		 6183 struct secacq *acq, *nextacq;
6184
6185 for (acq = LIST_FIRST(&acqtree);
6186 acq != NULL;
6187 acq = nextacq) {
6188
6189 stop_handler = 0;
6190 nextacq = LIST_NEXT(acq, chain);
6191
6192 if (tv.tv_sec - acq->created > key_blockacq_lifetime
6193 && __LIST_CHAINED(acq)) {
6194 LIST_REMOVE(acq, chain);
6195 KFREE(acq);
6196 }
1c79356b 6197 }
1c79356b
A		 6198 }
6199#endif
39236c6e 6200
1c79356b
A		 6201 /* SP ACQ tree */
6202 {
39236c6e
A		 6203 struct secspacq *acq, *nextacq;
6204
6205 for (acq = LIST_FIRST(&spacqtree);
6206 acq != NULL;
6207 acq = nextacq) {
6208
6209 stop_handler = 0;
6210 nextacq = LIST_NEXT(acq, chain);
6211
6212 if (tv.tv_sec - acq->created > key_blockacq_lifetime
6213 && __LIST_CHAINED(acq)) {
6214 LIST_REMOVE(acq, chain);
6215 KFREE(acq);
6216 }
1c79356b 6217 }
1c79356b 6218 }
39236c6e 6219
1c79356b
A		 6220 /* initialize random seed */
6221 if (key_tick_init_random++ > key_int_random) {
6222 key_tick_init_random = 0;
6223 key_srandom();
6224 }
39037602
A		 6225
6226 uint64_t acc_sleep_time = 0;
6227 absolutetime_to_nanoseconds(mach_absolutetime_asleep, &acc_sleep_time);
6228 natt_now = ++up_time + (acc_sleep_time / NSEC_PER_SEC);
39236c6e 6229
91447636 6230 lck_mtx_unlock(sadb_mutex);
39236c6e 6231
2d21ac55
A		 6232 /* send messages outside of sadb_mutex */
6233 if (spbuf && spcount > 0) {
6234 cnt = spcount;
6235 while (cnt--)
6236 key_spdexpire(*(--spptr));
6237 }
6238 if (savkabuf && savkacount > 0) {
b0d623f7
A		 6239 struct secasvar **savkaptr_sav = savkaptr;
6240 int cnt_send = savkacount;
39236c6e 6241
b0d623f7
A		 6242 while (cnt_send--) {
6243 if (ipsec_send_natt_keepalive(*(--savkaptr))) {
6244 // <rdar://6768487> iterate (all over again) and update timestamps
6245 struct secasvar **savkaptr_update = savkaptr_sav;
6246 int cnt_update = savkacount;
6247 while (cnt_update--) {
6248 key_update_natt_keepalive_timestamp(*savkaptr,
39236c6e 6249 *(--savkaptr_update));
b0d623f7
A		 6250 }
6251 }
6252 }
2d21ac55
A		 6253 }
6254 if (savexbuf && savexcount > 0) {
6255 cnt = savexcount;
6256 while (cnt--)
6257 key_expire(*(--savexptr));
6258 }
6259
6260 /* decrement ref counts and free buffers */
6261 lck_mtx_lock(sadb_mutex);
6262 if (spbuf) {
6263 while (spcount--)
6264 key_freesp(*spptr++, KEY_SADB_LOCKED);
6265 KFREE(spbuf);
6266 }
6267 if (savkabuf) {
6268 while (savkacount--)
6269 key_freesav(*savkaptr++, KEY_SADB_LOCKED);
6270 KFREE(savkabuf);
6271 }
6272 if (savexbuf) {
6273 while (savexcount--)
6274 key_freesav(*savexptr++, KEY_SADB_LOCKED);
6275 KFREE(savexbuf);
6276 }
2d21ac55 6277
fe8ab488 6278 if (stop_handler) {
39236c6e 6279 key_timehandler_running = 0;
fe8ab488
A		 6280 /* Turn on the ipsec bypass */
6281 ipsec_bypass = 1;
6282 } else {
39236c6e
A		 6283 /* do exchange to tick time !! */
6284 (void)timeout((void *)key_timehandler, (void *)0, hz);
6285 }
1c79356b 6286
39236c6e 6287 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 6288 return;
6289}
6290
6291/*
6292 * to initialize a seed for random()
6293 */
9bccf70c 6294static void
6d2010ae 6295key_srandom(void)
1c79356b 6296{
9bccf70c
A		 6297#ifdef __APPLE__
6298 /* Our PRNG is based on Yarrow and doesn't need to be seeded */
6299 random();
6300#else
1c79356b 6301 struct timeval tv;
39236c6e 6302
1c79356b 6303 microtime(&tv);
39236c6e 6304
1c79356b 6305 srandom(tv.tv_usec);
1c79356b 6306#endif
39236c6e 6307
1c79356b
A		 6308 return;
6309}
6310
b0d623f7 6311u_int32_t
6d2010ae 6312key_random(void)
9bccf70c 6313{
b0d623f7 6314 u_int32_t value;
39236c6e 6315
9bccf70c
A		 6316 key_randomfill(&value, sizeof(value));
6317 return value;
6318}
6319
6320void
6d2010ae 6321key_randomfill(
39236c6e
A		 6322 void *p,
6323 size_t l)
9bccf70c 6324{
9bccf70c 6325#ifdef __APPLE__
d190cdc3 6326 cc_rand_generate(p, l);
9bccf70c 6327#else
2d21ac55 6328 size_t n;
b0d623f7 6329 u_int32_t v;
2d21ac55 6330 static int warn = 1;
39236c6e 6331
9bccf70c
A		 6332 n = 0;
6333 n = (size_t)read_random(p, (u_int)l);
6334 /* last resort */
6335 while (n < l) {
6336 v = random();
6337 bcopy(&v, (u_int8_t *)p + n,
39236c6e 6338 l - n < sizeof(v) ? l - n : sizeof(v));
9bccf70c 6339 n += sizeof(v);
39236c6e 6340
9bccf70c
A		 6341 if (warn) {
6342 printf("WARNING: pseudo-random number generator "
39236c6e 6343 "used for IPsec processing\n");
9bccf70c
A		 6344 warn = 0;
6345 }
6346 }
6347#endif
6348}
6349
1c79356b
A		 6350/*
6351 * map SADB_SATYPE_* to IPPROTO_*.
6352 * if satype == SADB_SATYPE then satype is mapped to ~0.
6353 * OUT:
6354 * 0: invalid satype.
6355 */
6356static u_int16_t
6d2010ae 6357key_satype2proto(
39236c6e 6358 u_int8_t satype)
1c79356b
A		 6359{
6360 switch (satype) {
39236c6e
A		 6361 case SADB_SATYPE_UNSPEC:
6362 return IPSEC_PROTO_ANY;
6363 case SADB_SATYPE_AH:
6364 return IPPROTO_AH;
6365 case SADB_SATYPE_ESP:
6366 return IPPROTO_ESP;
6367 case SADB_X_SATYPE_IPCOMP:
6368 return IPPROTO_IPCOMP;
39236c6e
A		 6369 default:
6370 return 0;
1c79356b
A		 6371 }
6372 /* NOTREACHED */
6373}
6374
6375/*
6376 * map IPPROTO_* to SADB_SATYPE_*
6377 * OUT:
6378 * 0: invalid protocol type.
6379 */
6380static u_int8_t
6d2010ae 6381key_proto2satype(
39236c6e 6382 u_int16_t proto)
1c79356b
A		 6383{
6384 switch (proto) {
39236c6e
A		 6385 case IPPROTO_AH:
6386 return SADB_SATYPE_AH;
6387 case IPPROTO_ESP:
6388 return SADB_SATYPE_ESP;
6389 case IPPROTO_IPCOMP:
6390 return SADB_X_SATYPE_IPCOMP;
39236c6e
A		 6391 default:
6392 return 0;
1c79356b
A		 6393 }
6394 /* NOTREACHED */
6395}
6396
fe8ab488 6397static ifnet_t
3e170ce0 6398key_get_ipsec_if_from_message (const struct sadb_msghdr *mhp, int message_type)
fe8ab488
A		 6399{
6400 struct sadb_x_ipsecif *ipsecifopts = NULL;
6401 ifnet_t ipsec_if = NULL;
6402
3e170ce0 6403 ipsecifopts = (struct sadb_x_ipsecif *)(void *)mhp->ext[message_type];
fe8ab488 6404 if (ipsecifopts != NULL) {
3e170ce0 6405 if (ipsecifopts->sadb_x_ipsecif_ipsec_if[0]) {
fe8ab488
A		 6406 ifnet_find_by_name(ipsecifopts->sadb_x_ipsecif_ipsec_if, &ipsec_if);
6407 }
6408 }
6409
6410 return ipsec_if;
6411}
6412
6413static u_int
3e170ce0 6414key_get_outgoing_ifindex_from_message (const struct sadb_msghdr *mhp, int message_type)
fe8ab488
A		 6415{
6416 struct sadb_x_ipsecif *ipsecifopts = NULL;
6417 ifnet_t outgoing_if = NULL;
6418
3e170ce0 6419 ipsecifopts = (struct sadb_x_ipsecif *)(void *)mhp->ext[message_type];
fe8ab488 6420 if (ipsecifopts != NULL) {
3e170ce0 6421 if (ipsecifopts->sadb_x_ipsecif_outgoing_if[0]) {
fe8ab488
A		 6422 ifnet_find_by_name(ipsecifopts->sadb_x_ipsecif_outgoing_if, &outgoing_if);
6423 }
6424 }
6425
6426 return outgoing_if ? outgoing_if->if_index : 0;
6427}
6428
1c79356b
A		 6429/* %%% PF_KEY */
6430/*
6431 * SADB_GETSPI processing is to receive
9bccf70c 6432 * <base, (SA2), src address, dst address, (SPI range)>
1c79356b
A		 6433 * from the IKMPd, to assign a unique spi value, to hang on the INBOUND
6434 * tree with the status of LARVAL, and send
6435 * <base, SA(*), address(SD)>
6436 * to the IKMPd.
6437 *
6438 * IN: mhp: pointer to the pointer to each header.
6439 * OUT: NULL if fail.
6440 * other if success, return pointer to the message to send.
6441 */
9bccf70c 6442static int
6d2010ae 6443key_getspi(
39236c6e
A		 6444 struct socket *so,
6445 struct mbuf *m,
6446 const struct sadb_msghdr *mhp)
1c79356b 6447{
1c79356b
A		 6448 struct sadb_address *src0, *dst0;
6449 struct secasindex saidx;
6450 struct secashead *newsah;
6451 struct secasvar *newsav;
fe8ab488 6452 ifnet_t ipsec_if = NULL;
1c79356b
A		 6453 u_int8_t proto;
6454 u_int32_t spi;
9bccf70c
A		 6455 u_int8_t mode;
6456 u_int32_t reqid;
6457 int error;
39236c6e 6458
2d21ac55
A		 6459 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
6460
1c79356b 6461 /* sanity check */
9bccf70c 6462 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 6463 panic("key_getspi: NULL pointer is passed.\n");
39236c6e 6464
9bccf70c
A		 6465 if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
6466 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
55e303ae 6467 ipseclog((LOG_DEBUG, "key_getspi: invalid message is passed.\n"));
9bccf70c
A		 6468 return key_senderror(so, m, EINVAL);
6469 }
6470 if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
6471 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
55e303ae 6472 ipseclog((LOG_DEBUG, "key_getspi: invalid message is passed.\n"));
9bccf70c
A		 6473 return key_senderror(so, m, EINVAL);
6474 }
6475 if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
316670eb 6476 mode = ((struct sadb_x_sa2 *)
39236c6e 6477 (void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_mode;
316670eb 6478 reqid = ((struct sadb_x_sa2 *)
39236c6e 6479 (void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_reqid;
9bccf70c
A		 6480 } else {
6481 mode = IPSEC_MODE_ANY;
6482 reqid = 0;
1c79356b 6483 }
39236c6e 6484
9bccf70c
A		 6485 src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
6486 dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
39236c6e 6487
3e170ce0 6488 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
fe8ab488 6489
1c79356b 6490 /* map satype to proto */
9bccf70c 6491 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 6492 ipseclog((LOG_DEBUG, "key_getspi: invalid satype is passed.\n"));
9bccf70c
A		 6493 return key_senderror(so, m, EINVAL);
6494 }
39236c6e 6495
9bccf70c
A		 6496 /* make sure if port number is zero. */
6497 switch (((struct sockaddr *)(src0 + 1))->sa_family) {
39236c6e
A		 6498 case AF_INET:
6499 if (((struct sockaddr *)(src0 + 1))->sa_len !=
6500 sizeof(struct sockaddr_in))
6501 return key_senderror(so, m, EINVAL);
6502 ((struct sockaddr_in *)(void *)(src0 + 1))->sin_port = 0;
6503 break;
6504 case AF_INET6:
6505 if (((struct sockaddr *)(src0 + 1))->sa_len !=
6506 sizeof(struct sockaddr_in6))
6507 return key_senderror(so, m, EINVAL);
6508 ((struct sockaddr_in6 *)(void *)(src0 + 1))->sin6_port = 0;
6509 break;
6510 default:
6511 ; /*???*/
9bccf70c
A		 6512 }
6513 switch (((struct sockaddr *)(dst0 + 1))->sa_family) {
39236c6e
A		 6514 case AF_INET:
6515 if (((struct sockaddr *)(dst0 + 1))->sa_len !=
6516 sizeof(struct sockaddr_in))
6517 return key_senderror(so, m, EINVAL);
6518 ((struct sockaddr_in *)(void *)(dst0 + 1))->sin_port = 0;
6519 break;
6520 case AF_INET6:
6521 if (((struct sockaddr *)(dst0 + 1))->sa_len !=
6522 sizeof(struct sockaddr_in6))
6523 return key_senderror(so, m, EINVAL);
6524 ((struct sockaddr_in6 *)(void *)(dst0 + 1))->sin6_port = 0;
6525 break;
6526 default:
6527 ; /*???*/
1c79356b 6528 }
39236c6e 6529
9bccf70c 6530 /* XXX boundary check against sa_len */
fe8ab488 6531 KEY_SETSECASIDX(proto, mode, reqid, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 6532
2d21ac55 6533 lck_mtx_lock(sadb_mutex);
39236c6e 6534
1c79356b 6535 /* SPI allocation */
316670eb 6536 spi = key_do_getnewspi((struct sadb_spirange *)
39236c6e 6537 (void *)mhp->ext[SADB_EXT_SPIRANGE], &saidx);
2d21ac55
A		 6538 if (spi == 0) {
6539 lck_mtx_unlock(sadb_mutex);
9bccf70c 6540 return key_senderror(so, m, EINVAL);
2d21ac55 6541 }
39236c6e 6542
1c79356b
A		 6543 /* get a SA index */
6544 if ((newsah = key_getsah(&saidx)) == NULL) {
b0d623f7 6545 /* create a new SA index: key_addspi is always used for inbound spi */
3e170ce0 6546 if ((newsah = key_newsah(&saidx, ipsec_if, key_get_outgoing_ifindex_from_message(mhp, SADB_X_EXT_IPSECIF), IPSEC_DIR_INBOUND)) == NULL) {
2d21ac55 6547 lck_mtx_unlock(sadb_mutex);
55e303ae 6548 ipseclog((LOG_DEBUG, "key_getspi: No more memory.\n"));
9bccf70c 6549 return key_senderror(so, m, ENOBUFS);
1c79356b
A		 6550 }
6551 }
39236c6e 6552
1c79356b 6553 /* get a new SA */
9bccf70c 6554 /* XXX rewrite */
fe8ab488 6555 newsav = key_newsav(m, mhp, newsah, &error, so);
9bccf70c 6556 if (newsav == NULL) {
1c79356b 6557 /* XXX don't free new SA index allocated in above. */
2d21ac55 6558 lck_mtx_unlock(sadb_mutex);
9bccf70c 6559 return key_senderror(so, m, error);
1c79356b 6560 }
39236c6e 6561
1c79356b 6562 /* set spi */
91447636 6563 key_setspi(newsav, htonl(spi));
39236c6e 6564
1c79356b
A		 6565#ifndef IPSEC_NONBLOCK_ACQUIRE
6566 /* delete the entry in acqtree */
9bccf70c 6567 if (mhp->msg->sadb_msg_seq != 0) {
1c79356b 6568 struct secacq *acq;
9bccf70c
A		 6569 if ((acq = key_getacqbyseq(mhp->msg->sadb_msg_seq)) != NULL) {
6570 /* reset counter in order to deletion by timehandler. */
6571 struct timeval tv;
6572 microtime(&tv);
6573 acq->created = tv.tv_sec;
1c79356b
A		 6574 acq->count = 0;
6575 }
39236c6e 6576 }
1c79356b 6577#endif
39236c6e 6578
2d21ac55
A		 6579 lck_mtx_unlock(sadb_mutex);
6580
1c79356b 6581 {
39236c6e
A		 6582 struct mbuf *n, *nn;
6583 struct sadb_sa *m_sa;
6584 struct sadb_msg *newmsg;
6585 int off, len;
6586
6587 /* create new sadb_msg to reply. */
6588 len = PFKEY_ALIGN8(sizeof(struct sadb_msg)) +
9bccf70c 6589 PFKEY_ALIGN8(sizeof(struct sadb_sa));
39236c6e
A		 6590 if (len > MCLBYTES)
6591 return key_senderror(so, m, ENOBUFS);
6592
6593 MGETHDR(n, M_WAITOK, MT_DATA);
6594 if (n && len > MHLEN) {
6595 MCLGET(n, M_WAITOK);
6596 if ((n->m_flags & M_EXT) == 0) {
6597 m_freem(n);
6598 n = NULL;
6599 }
9bccf70c 6600 }
39236c6e
A		 6601 if (!n)
6602 return key_senderror(so, m, ENOBUFS);
6603
6604 n->m_len = len;
6605 n->m_next = NULL;
6606 off = 0;
6607
6608 m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, caddr_t) + off);
6609 off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
6610
6611 m_sa = (struct sadb_sa *)(void *)(mtod(n, caddr_t) + off);
6612 m_sa->sadb_sa_len = PFKEY_UNIT64(sizeof(struct sadb_sa));
6613 m_sa->sadb_sa_exttype = SADB_EXT_SA;
6614 m_sa->sadb_sa_spi = htonl(spi);
6615 off += PFKEY_ALIGN8(sizeof(struct sadb_sa));
6616
9bccf70c 6617#if DIAGNOSTIC
39236c6e
A		 6618 if (off != len)
6619 panic("length inconsistency in key_getspi");
9bccf70c 6620#endif
39236c6e
A		 6621 {
6622 int mbufItems[] = {SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST};
6623 n->m_next = key_gather_mbuf(m, mhp, 0, sizeof(mbufItems)/sizeof(int), mbufItems);
6624 if (!n->m_next) {
6625 m_freem(n);
6626 return key_senderror(so, m, ENOBUFS);
6627 }
6628 }
6629
6630 if (n->m_len < sizeof(struct sadb_msg)) {
6631 n = m_pullup(n, sizeof(struct sadb_msg));
6632 if (n == NULL)
6633 return key_sendup_mbuf(so, m, KEY_SENDUP_ONE);
6634 }
6635
6636 n->m_pkthdr.len = 0;
6637 for (nn = n; nn; nn = nn->m_next)
6638 n->m_pkthdr.len += nn->m_len;
6639
6640 newmsg = mtod(n, struct sadb_msg *);
6641 newmsg->sadb_msg_seq = newsav->seq;
6642 newmsg->sadb_msg_errno = 0;
6643 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
6644
6645 m_freem(m);
6646 return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
1c79356b
A		 6647 }
6648}
6649
316670eb
A		 6650u_int32_t
6651key_getspi2(struct sockaddr *src,
6652 struct sockaddr *dst,
6653 u_int8_t proto,
6654 u_int8_t mode,
6655 u_int32_t reqid,
6656 struct sadb_spirange *spirange)
6657{
6658 u_int32_t spi;
6659 struct secasindex saidx;
39236c6e 6660
316670eb 6661 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
39236c6e 6662
316670eb 6663 /* XXX boundary check against sa_len */
fe8ab488 6664 KEY_SETSECASIDX(proto, mode, reqid, src, dst, 0, &saidx);
39236c6e 6665
316670eb
A		 6666 /* make sure if port number is zero. */
6667 switch (((struct sockaddr *)&saidx.src)->sa_family) {
6668 case AF_INET:
6669 if (((struct sockaddr *)&saidx.src)->sa_len != sizeof(struct sockaddr_in))
6670 return 0;
6671 ((struct sockaddr_in *)&saidx.src)->sin_port = 0;
6672 break;
6673 case AF_INET6:
6674 if (((struct sockaddr *)&saidx.src)->sa_len != sizeof(struct sockaddr_in6))
6675 return 0;
6676 ((struct sockaddr_in6 *)&saidx.src)->sin6_port = 0;
6677 break;
6678 default:
6679 ; /*???*/
6680 }
6681 switch (((struct sockaddr *)&saidx.dst)->sa_family) {
6682 case AF_INET:
6683 if (((struct sockaddr *)&saidx.dst)->sa_len != sizeof(struct sockaddr_in))
6684 return 0;
6685 ((struct sockaddr_in *)&saidx.dst)->sin_port = 0;
6686 break;
6687 case AF_INET6:
6688 if (((struct sockaddr *)&saidx.dst)->sa_len != sizeof(struct sockaddr_in6))
6689 return 0;
6690 ((struct sockaddr_in6 *)&saidx.dst)->sin6_port = 0;
6691 break;
6692 default:
6693 ; /*???*/
6694 }
39236c6e 6695
316670eb
A		 6696 lck_mtx_lock(sadb_mutex);
6697
6698 /* SPI allocation */
6699 spi = key_do_getnewspi(spirange, &saidx);
39236c6e 6700
316670eb 6701 lck_mtx_unlock(sadb_mutex);
39236c6e 6702
316670eb
A		 6703 return spi;
6704}
6705
1c79356b
A		 6706/*
6707 * allocating new SPI
316670eb 6708 * called by key_getspi() and key_getspi2().
1c79356b
A		 6709 * OUT:
6710 * 0: failure.
6711 * others: success.
6712 */
6713static u_int32_t
6d2010ae 6714key_do_getnewspi(
39236c6e
A		 6715 struct sadb_spirange *spirange,
6716 struct secasindex *saidx)
1c79356b
A		 6717{
6718 u_int32_t newspi;
2d21ac55 6719 u_int32_t keymin, keymax;
1c79356b 6720 int count = key_spi_trycnt;
39236c6e 6721
91447636 6722 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 6723
1c79356b
A		 6724 /* set spi range to allocate */
6725 if (spirange != NULL) {
2d21ac55
A		 6726 keymin = spirange->sadb_spirange_min;
6727 keymax = spirange->sadb_spirange_max;
1c79356b 6728 } else {
2d21ac55
A		 6729 keymin = key_spi_minval;
6730 keymax = key_spi_maxval;
1c79356b
A		 6731 }
6732 /* IPCOMP needs 2-byte SPI */
6733 if (saidx->proto == IPPROTO_IPCOMP) {
6734 u_int32_t t;
2d21ac55
A		 6735 if (keymin >= 0x10000)
6736 keymin = 0xffff;
6737 if (keymax >= 0x10000)
6738 keymax = 0xffff;
6739 if (keymin > keymax) {
6740 t = keymin; keymin = keymax; keymax = t;
1c79356b
A		 6741 }
6742 }
39236c6e 6743
2d21ac55
A		 6744 if (keymin == keymax) {
6745 if (key_checkspidup(saidx, keymin) != NULL) {
6746 ipseclog((LOG_DEBUG, "key_do_getnewspi: SPI %u exists already.\n", keymin));
1c79356b
A		 6747 return 0;
6748 }
39236c6e 6749
1c79356b 6750 count--; /* taking one cost. */
2d21ac55 6751 newspi = keymin;
39236c6e 6752
1c79356b 6753 } else {
39236c6e 6754
b0d623f7 6755 u_int32_t range = keymax - keymin + 1; /* overflow value of zero means full range */
39236c6e 6756
1c79356b
A		 6757 /* init SPI */
6758 newspi = 0;
39236c6e 6759
1c79356b
A		 6760 /* when requesting to allocate spi ranged */
6761 while (count--) {
b0d623f7 6762 u_int32_t rand_val = key_random();
2d21ac55 6763
1c79356b 6764 /* generate pseudo-random SPI value ranged. */
2d21ac55 6765 newspi = (range == 0 ? rand_val : keymin + (rand_val % range));
39236c6e 6766
1c79356b
A		 6767 if (key_checkspidup(saidx, newspi) == NULL)
6768 break;
6769 }
39236c6e 6770
1c79356b 6771 if (count == 0 || newspi == 0) {
55e303ae 6772 ipseclog((LOG_DEBUG, "key_do_getnewspi: to allocate spi is failed.\n"));
1c79356b
A		 6773 return 0;
6774 }
6775 }
39236c6e 6776
1c79356b
A		 6777 /* statistics */
6778 keystat.getspi_count =
39236c6e
A		 6779 (keystat.getspi_count + key_spi_trycnt - count) / 2;
6780
1c79356b
A		 6781 return newspi;
6782}
6783
6784/*
6785 * SADB_UPDATE processing
6786 * receive
9bccf70c 6787 * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
1c79356b
A		 6788 * key(AE), (identity(SD),) (sensitivity)>
6789 * from the ikmpd, and update a secasvar entry whose status is SADB_SASTATE_LARVAL.
6790 * and send
9bccf70c 6791 * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
1c79356b
A		 6792 * (identity(SD),) (sensitivity)>
6793 * to the ikmpd.
6794 *
9bccf70c 6795 * m will always be freed.
1c79356b 6796 */
9bccf70c 6797static int
6d2010ae 6798key_update(
39236c6e
A		 6799 struct socket *so,
6800 struct mbuf *m,
6801 const struct sadb_msghdr *mhp)
1c79356b 6802{
1c79356b
A		 6803 struct sadb_sa *sa0;
6804 struct sadb_address *src0, *dst0;
fe8ab488 6805 ifnet_t ipsec_if = NULL;
1c79356b
A		 6806 struct secasindex saidx;
6807 struct secashead *sah;
6808 struct secasvar *sav;
6809 u_int16_t proto;
9bccf70c
A		 6810 u_int8_t mode;
6811 u_int32_t reqid;
fe8ab488 6812 u_int16_t flags2;
9bccf70c 6813 int error;
39236c6e 6814
2d21ac55
A		 6815 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
6816
1c79356b 6817 /* sanity check */
9bccf70c 6818 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 6819 panic("key_update: NULL pointer is passed.\n");
39236c6e 6820
1c79356b 6821 /* map satype to proto */
9bccf70c 6822 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 6823 ipseclog((LOG_DEBUG, "key_update: invalid satype is passed.\n"));
9bccf70c 6824 return key_senderror(so, m, EINVAL);
1c79356b 6825 }
39236c6e 6826
9bccf70c
A		 6827 if (mhp->ext[SADB_EXT_SA] == NULL ||
6828 mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
6829 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
6830 (mhp->msg->sadb_msg_satype == SADB_SATYPE_ESP &&
6831 mhp->ext[SADB_EXT_KEY_ENCRYPT] == NULL) ||
6832 (mhp->msg->sadb_msg_satype == SADB_SATYPE_AH &&
6833 mhp->ext[SADB_EXT_KEY_AUTH] == NULL) ||
6834 (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL &&
6835 mhp->ext[SADB_EXT_LIFETIME_SOFT] == NULL) ||
6836 (mhp->ext[SADB_EXT_LIFETIME_HARD] == NULL &&
6837 mhp->ext[SADB_EXT_LIFETIME_SOFT] != NULL)) {
39236c6e
A		 6838 ipseclog((LOG_DEBUG, "key_update: invalid message is passed.\n"));
6839 return key_senderror(so, m, EINVAL);
6840 }
9bccf70c
A		 6841 if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
6842 mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
6843 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
55e303ae 6844 ipseclog((LOG_DEBUG, "key_update: invalid message is passed.\n"));
9bccf70c
A		 6845 return key_senderror(so, m, EINVAL);
6846 }
6847 if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
316670eb 6848 mode = ((struct sadb_x_sa2 *)
39236c6e 6849 (void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_mode;
316670eb 6850 reqid = ((struct sadb_x_sa2 *)
39236c6e 6851 (void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_reqid;
fe8ab488 6852 flags2 = ((struct sadb_x_sa2 *)(void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_flags;
9bccf70c
A		 6853 } else {
6854 mode = IPSEC_MODE_ANY;
6855 reqid = 0;
fe8ab488 6856 flags2 = 0;
9bccf70c
A		 6857 }
6858 /* XXX boundary checking for other extensions */
39236c6e 6859
316670eb 6860 sa0 = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
9bccf70c
A		 6861 src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
6862 dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
3e170ce0 6863 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
39236c6e 6864
9bccf70c 6865 /* XXX boundary check against sa_len */
fe8ab488 6866 KEY_SETSECASIDX(proto, mode, reqid, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 6867
2d21ac55 6868 lck_mtx_lock(sadb_mutex);
39236c6e 6869
1c79356b
A		 6870 /* get a SA header */
6871 if ((sah = key_getsah(&saidx)) == NULL) {
2d21ac55 6872 lck_mtx_unlock(sadb_mutex);
55e303ae 6873 ipseclog((LOG_DEBUG, "key_update: no SA index found.\n"));
9bccf70c 6874 return key_senderror(so, m, ENOENT);
1c79356b 6875 }
39236c6e 6876
1c79356b 6877 /* set spidx if there */
9bccf70c
A		 6878 /* XXX rewrite */
6879 error = key_setident(sah, m, mhp);
2d21ac55
A		 6880 if (error) {
6881 lck_mtx_unlock(sadb_mutex);
9bccf70c 6882 return key_senderror(so, m, error);
2d21ac55 6883 }
39236c6e 6884
1c79356b
A		 6885 /* find a SA with sequence number. */
6886#if IPSEC_DOSEQCHECK
9bccf70c 6887 if (mhp->msg->sadb_msg_seq != 0
39236c6e 6888 && (sav = key_getsavbyseq(sah, mhp->msg->sadb_msg_seq)) == NULL) {
2d21ac55 6889 lck_mtx_unlock(sadb_mutex);
55e303ae 6890 ipseclog((LOG_DEBUG,
39236c6e
A		 6891 "key_update: no larval SA with sequence %u exists.\n",
6892 mhp->msg->sadb_msg_seq));
9bccf70c 6893 return key_senderror(so, m, ENOENT);
1c79356b
A		 6894 }
6895#else
6896 if ((sav = key_getsavbyspi(sah, sa0->sadb_sa_spi)) == NULL) {
2d21ac55 6897 lck_mtx_unlock(sadb_mutex);
55e303ae 6898 ipseclog((LOG_DEBUG,
39236c6e
A		 6899 "key_update: no such a SA found (spi:%u)\n",
6900 (u_int32_t)ntohl(sa0->sadb_sa_spi)));
9bccf70c 6901 return key_senderror(so, m, EINVAL);
1c79356b
A		 6902 }
6903#endif
39236c6e 6904
1c79356b
A		 6905 /* validity check */
6906 if (sav->sah->saidx.proto != proto) {
2d21ac55 6907 lck_mtx_unlock(sadb_mutex);
55e303ae 6908 ipseclog((LOG_DEBUG,
39236c6e
A		 6909 "key_update: protocol mismatched (DB=%u param=%u)\n",
6910 sav->sah->saidx.proto, proto));
9bccf70c 6911 return key_senderror(so, m, EINVAL);
1c79356b
A		 6912 }
6913#if IPSEC_DOSEQCHECK
6914 if (sav->spi != sa0->sadb_sa_spi) {
2d21ac55 6915 lck_mtx_unlock(sadb_mutex);
55e303ae 6916 ipseclog((LOG_DEBUG,
39236c6e
A		 6917 "key_update: SPI mismatched (DB:%u param:%u)\n",
6918 (u_int32_t)ntohl(sav->spi),
6919 (u_int32_t)ntohl(sa0->sadb_sa_spi)));
9bccf70c 6920 return key_senderror(so, m, EINVAL);
1c79356b
A		 6921 }
6922#endif
9bccf70c 6923 if (sav->pid != mhp->msg->sadb_msg_pid) {
2d21ac55 6924 lck_mtx_unlock(sadb_mutex);
55e303ae 6925 ipseclog((LOG_DEBUG,
39236c6e
A		 6926 "key_update: pid mismatched (DB:%u param:%u)\n",
6927 sav->pid, mhp->msg->sadb_msg_pid));
9bccf70c 6928 return key_senderror(so, m, EINVAL);
1c79356b 6929 }
39236c6e 6930
1c79356b 6931 /* copy sav values */
9bccf70c
A		 6932 error = key_setsaval(sav, m, mhp);
6933 if (error) {
2d21ac55
A		 6934 key_freesav(sav, KEY_SADB_LOCKED);
6935 lck_mtx_unlock(sadb_mutex);
9bccf70c 6936 return key_senderror(so, m, error);
1c79356b 6937 }
fe8ab488
A		 6938
6939 sav->flags2 = flags2;
6940 if (flags2 & SADB_X_EXT_SA2_DELETE_ON_DETACH) {
6941 sav->so = so;
6942 }
6943
2d21ac55
A		 6944 /*
6945 * Verify if SADB_X_EXT_NATT_MULTIPLEUSERS flag is set that
6946 * this SA is for transport mode - otherwise clear it.
6947 */
6948 if ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0 &&
6949 (sav->sah->saidx.mode != IPSEC_MODE_TRANSPORT ||
39236c6e 6950 sav->sah->saidx.src.ss_family != AF_INET))
2d21ac55 6951 sav->flags &= ~SADB_X_EXT_NATT_MULTIPLEUSERS;
39236c6e 6952
1c79356b 6953 /* check SA values to be mature. */
91447636 6954 if ((error = key_mature(sav)) != 0) {
2d21ac55
A		 6955 key_freesav(sav, KEY_SADB_LOCKED);
6956 lck_mtx_unlock(sadb_mutex);
91447636 6957 return key_senderror(so, m, error);
1c79356b 6958 }
2d21ac55
A		 6959
6960 lck_mtx_unlock(sadb_mutex);
6961
1c79356b 6962 {
39236c6e
A		 6963 struct mbuf *n;
6964
6965 /* set msg buf from mhp */
6966 n = key_getmsgbuf_x1(m, mhp);
6967 if (n == NULL) {
6968 ipseclog((LOG_DEBUG, "key_update: No more memory.\n"));
6969 return key_senderror(so, m, ENOBUFS);
6970 }
6971
6972 m_freem(m);
6973 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
1c79356b
A		 6974 }
6975}
6976
3e170ce0
A		 6977static int
6978key_migrate(struct socket *so,
6979 struct mbuf *m,
6980 const struct sadb_msghdr *mhp)
6981{
6982 struct sadb_sa *sa0 = NULL;
6983 struct sadb_address *src0 = NULL;
6984 struct sadb_address *dst0 = NULL;
6985 struct sadb_address *src1 = NULL;
6986 struct sadb_address *dst1 = NULL;
6987 ifnet_t ipsec_if0 = NULL;
6988 ifnet_t ipsec_if1 = NULL;
6989 struct secasindex saidx0;
6990 struct secasindex saidx1;
6991 struct secashead *sah = NULL;
6992 struct secashead *newsah = NULL;
6993 struct secasvar *sav = NULL;
6994 u_int16_t proto;
6995
6996 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
6997
6998 /* sanity check */
6999 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
7000 panic("key_migrate: NULL pointer is passed.\n");
7001
7002 /* map satype to proto */
7003 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
7004 ipseclog((LOG_DEBUG, "key_migrate: invalid satype is passed.\n"));
7005 return key_senderror(so, m, EINVAL);
7006 }
7007
7008 if (mhp->ext[SADB_EXT_SA] == NULL ||
7009 mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
7010 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
7011 mhp->ext[SADB_EXT_MIGRATE_ADDRESS_SRC] == NULL ||
7012 mhp->ext[SADB_EXT_MIGRATE_ADDRESS_DST] == NULL) {
7013 ipseclog((LOG_DEBUG, "key_migrate: invalid message is passed.\n"));
7014 return key_senderror(so, m, EINVAL);
7015 }
7016
7017 if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
7018 mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
7019 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
7020 mhp->extlen[SADB_EXT_MIGRATE_ADDRESS_SRC] < sizeof(struct sadb_address) ||
7021 mhp->extlen[SADB_EXT_MIGRATE_ADDRESS_DST] < sizeof(struct sadb_address)) {
7022 ipseclog((LOG_DEBUG, "key_migrate: invalid message is passed.\n"));
7023 return key_senderror(so, m, EINVAL);
7024 }
7025
7026 lck_mtx_lock(sadb_mutex);
7027
7028 sa0 = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
7029 src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
7030 dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
7031 src1 = (struct sadb_address *)(mhp->ext[SADB_EXT_MIGRATE_ADDRESS_SRC]);
7032 dst1 = (struct sadb_address *)(mhp->ext[SADB_EXT_MIGRATE_ADDRESS_DST]);
7033 ipsec_if0 = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
7034 ipsec_if1 = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_MIGRATE_IPSECIF);
7035
7036 /* Find existing SAH and SAV */
7037 KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, ipsec_if0 ? ipsec_if0->if_index : 0, &saidx0);
7038
7039 LIST_FOREACH(sah, &sahtree, chain) {
7040 if (sah->state != SADB_SASTATE_MATURE)
7041 continue;
7042 if (key_cmpsaidx(&sah->saidx, &saidx0, CMP_HEAD) == 0)
7043 continue;
7044
7045 sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
7046 if (sav && sav->state == SADB_SASTATE_MATURE)
7047 break;
7048 }
7049 if (sah == NULL) {
7050 lck_mtx_unlock(sadb_mutex);
7051 ipseclog((LOG_DEBUG, "key_migrate: no mature SAH found.\n"));
7052 return key_senderror(so, m, ENOENT);
7053 }
7054
7055 if (sav == NULL) {
7056 lck_mtx_unlock(sadb_mutex);
7057 ipseclog((LOG_DEBUG, "key_migrate: no SA found.\n"));
7058 return key_senderror(so, m, ENOENT);
7059 }
7060
7061 /* Find or create new SAH */
7062 KEY_SETSECASIDX(proto, sah->saidx.mode, sah->saidx.reqid, src1 + 1, dst1 + 1, ipsec_if1 ? ipsec_if1->if_index : 0, &saidx1);
7063
7064 if ((newsah = key_getsah(&saidx1)) == NULL) {
7065 if ((newsah = key_newsah(&saidx1, ipsec_if1, key_get_outgoing_ifindex_from_message(mhp, SADB_X_EXT_MIGRATE_IPSECIF), sah->dir)) == NULL) {
7066 lck_mtx_unlock(sadb_mutex);
7067 ipseclog((LOG_DEBUG, "key_migrate: No more memory.\n"));
7068 return key_senderror(so, m, ENOBUFS);
7069 }
7070 }
7071
7072 /* Migrate SAV in to new SAH */
7073 if (key_migratesav(sav, newsah) != 0) {
7074 lck_mtx_unlock(sadb_mutex);
7075 ipseclog((LOG_DEBUG, "key_migrate: Failed to migrate SA to new SAH.\n"));
7076 return key_senderror(so, m, EINVAL);
7077 }
7078
7079 /* Reset NAT values */
7080 sav->flags = sa0->sadb_sa_flags;
7081 sav->remote_ike_port = ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_port;
7082 sav->natt_interval = ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_interval;
7083 sav->natt_offload_interval = ((const struct sadb_sa_2*)(sa0))->sadb_sa_natt_offload_interval;
7084 sav->natt_last_activity = natt_now;
39037602 7085
3e170ce0
A		 7086 /*
7087 * Verify if SADB_X_EXT_NATT_MULTIPLEUSERS flag is set that
7088 * SADB_X_EXT_NATT is set and SADB_X_EXT_NATT_KEEPALIVE is not
7089 * set (we're not behind nat) - otherwise clear it.
7090 */
7091 if ((sav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0)
7092 if ((sav->flags & SADB_X_EXT_NATT) == 0 ||
7093 (sav->flags & SADB_X_EXT_NATT_KEEPALIVE) != 0)
7094 sav->flags &= ~SADB_X_EXT_NATT_MULTIPLEUSERS;
7095
7096 lck_mtx_unlock(sadb_mutex);
7097 {
7098 struct mbuf *n;
7099 struct sadb_msg *newmsg;
7100 int mbufItems[] = {SADB_EXT_RESERVED, SADB_EXT_SA,
7101 SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST, SADB_X_EXT_IPSECIF,
7102 SADB_EXT_MIGRATE_ADDRESS_SRC, SADB_EXT_MIGRATE_ADDRESS_DST, SADB_X_EXT_MIGRATE_IPSECIF};
7103
7104 /* create new sadb_msg to reply. */
7105 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
7106 if (!n)
7107 return key_senderror(so, m, ENOBUFS);
7108
7109 if (n->m_len < sizeof(struct sadb_msg)) {
7110 n = m_pullup(n, sizeof(struct sadb_msg));
7111 if (n == NULL)
7112 return key_senderror(so, m, ENOBUFS);
7113 }
7114 newmsg = mtod(n, struct sadb_msg *);
7115 newmsg->sadb_msg_errno = 0;
7116 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
7117
7118 m_freem(m);
7119 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
7120 }
7121}
7122
1c79356b
A		 7123/*
7124 * search SAD with sequence for a SA which state is SADB_SASTATE_LARVAL.
7125 * only called by key_update().
7126 * OUT:
7127 * NULL : not found
7128 * others : found, pointer to a SA.
7129 */
7130#if IPSEC_DOSEQCHECK
7131static struct secasvar *
6d2010ae 7132key_getsavbyseq(
39236c6e
A		 7133 struct secashead *sah,
7134 u_int32_t seq)
1c79356b
A		 7135{
7136 struct secasvar *sav;
7137 u_int state;
39236c6e 7138
91447636 7139 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 7140
1c79356b 7141 state = SADB_SASTATE_LARVAL;
39236c6e 7142
1c79356b
A		 7143 /* search SAD with sequence number ? */
7144 LIST_FOREACH(sav, &sah->savtree[state], chain) {
39236c6e 7145
1c79356b 7146 KEY_CHKSASTATE(state, sav->state, "key_getsabyseq");
39236c6e 7147
1c79356b
A		 7148 if (sav->seq == seq) {
7149 sav->refcnt++;
7150 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
39236c6e
A		 7151 printf("DP key_getsavbyseq cause "
7152 "refcnt++:%d SA:0x%llx\n", sav->refcnt,
7153 (uint64_t)VM_KERNEL_ADDRPERM(sav)));
1c79356b
A		 7154 return sav;
7155 }
7156 }
39236c6e 7157
1c79356b
A		 7158 return NULL;
7159}
7160#endif
7161
7162/*
7163 * SADB_ADD processing
7164 * add a entry to SA database, when received
9bccf70c 7165 * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
1c79356b
A		 7166 * key(AE), (identity(SD),) (sensitivity)>
7167 * from the ikmpd,
7168 * and send
9bccf70c 7169 * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
1c79356b
A		 7170 * (identity(SD),) (sensitivity)>
7171 * to the ikmpd.
7172 *
7173 * IGNORE identity and sensitivity messages.
7174 *
9bccf70c 7175 * m will always be freed.
1c79356b 7176 */
9bccf70c 7177static int
6d2010ae 7178key_add(
39236c6e
A		 7179 struct socket *so,
7180 struct mbuf *m,
7181 const struct sadb_msghdr *mhp)
9bccf70c
A		 7182{
7183 struct sadb_sa *sa0;
1c79356b 7184 struct sadb_address *src0, *dst0;
fe8ab488 7185 ifnet_t ipsec_if = NULL;
1c79356b
A		 7186 struct secasindex saidx;
7187 struct secashead *newsah;
7188 struct secasvar *newsav;
7189 u_int16_t proto;
9bccf70c
A		 7190 u_int8_t mode;
7191 u_int32_t reqid;
7192 int error;
39236c6e 7193
2d21ac55
A		 7194 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
7195
1c79356b 7196 /* sanity check */
9bccf70c 7197 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 7198 panic("key_add: NULL pointer is passed.\n");
39236c6e 7199
1c79356b 7200 /* map satype to proto */
9bccf70c 7201 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 7202 ipseclog((LOG_DEBUG, "key_add: invalid satype is passed.\n"));
ecc0ceb4 7203 bzero_keys(mhp);
9bccf70c 7204 return key_senderror(so, m, EINVAL);
1c79356b 7205 }
39236c6e 7206
9bccf70c
A		 7207 if (mhp->ext[SADB_EXT_SA] == NULL ||
7208 mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
7209 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
7210 (mhp->msg->sadb_msg_satype == SADB_SATYPE_ESP &&
7211 mhp->ext[SADB_EXT_KEY_ENCRYPT] == NULL) ||
7212 (mhp->msg->sadb_msg_satype == SADB_SATYPE_AH &&
7213 mhp->ext[SADB_EXT_KEY_AUTH] == NULL) ||
7214 (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL &&
7215 mhp->ext[SADB_EXT_LIFETIME_SOFT] == NULL) ||
7216 (mhp->ext[SADB_EXT_LIFETIME_HARD] == NULL &&
7217 mhp->ext[SADB_EXT_LIFETIME_SOFT] != NULL)) {
39236c6e 7218 ipseclog((LOG_DEBUG, "key_add: invalid message is passed.\n"));
ecc0ceb4 7219 bzero_keys(mhp);
39236c6e
A		 7220 return key_senderror(so, m, EINVAL);
7221 }
9bccf70c
A		 7222 if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
7223 mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
7224 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
7225 /* XXX need more */
55e303ae 7226 ipseclog((LOG_DEBUG, "key_add: invalid message is passed.\n"));
ecc0ceb4 7227 bzero_keys(mhp);
9bccf70c
A		 7228 return key_senderror(so, m, EINVAL);
7229 }
7230 if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
316670eb 7231 mode = ((struct sadb_x_sa2 *)
39236c6e 7232 (void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_mode;
316670eb 7233 reqid = ((struct sadb_x_sa2 *)
39236c6e 7234 (void *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_reqid;
9bccf70c
A		 7235 } else {
7236 mode = IPSEC_MODE_ANY;
7237 reqid = 0;
1c79356b 7238 }
39236c6e 7239
316670eb 7240 sa0 = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
9bccf70c
A		 7241 src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
7242 dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
3e170ce0 7243 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
39236c6e 7244
9bccf70c 7245 /* XXX boundary check against sa_len */
fe8ab488 7246 KEY_SETSECASIDX(proto, mode, reqid, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 7247
2d21ac55 7248 lck_mtx_lock(sadb_mutex);
39236c6e 7249
1c79356b
A		 7250 /* get a SA header */
7251 if ((newsah = key_getsah(&saidx)) == NULL) {
b0d623f7 7252 /* create a new SA header: key_addspi is always used for outbound spi */
3e170ce0 7253 if ((newsah = key_newsah(&saidx, ipsec_if, key_get_outgoing_ifindex_from_message(mhp, SADB_X_EXT_IPSECIF), IPSEC_DIR_OUTBOUND)) == NULL) {
2d21ac55 7254 lck_mtx_unlock(sadb_mutex);
55e303ae 7255 ipseclog((LOG_DEBUG, "key_add: No more memory.\n"));
ecc0ceb4 7256 bzero_keys(mhp);
9bccf70c 7257 return key_senderror(so, m, ENOBUFS);
1c79356b
A		 7258 }
7259 }
39236c6e 7260
1c79356b 7261 /* set spidx if there */
9bccf70c
A		 7262 /* XXX rewrite */
7263 error = key_setident(newsah, m, mhp);
7264 if (error) {
2d21ac55 7265 lck_mtx_unlock(sadb_mutex);
ecc0ceb4 7266 bzero_keys(mhp);
9bccf70c
A		 7267 return key_senderror(so, m, error);
7268 }
39236c6e 7269
1c79356b 7270 /* create new SA entry. */
2d21ac55 7271 /* We can create new SA only if SPI is different. */
1c79356b 7272 if (key_getsavbyspi(newsah, sa0->sadb_sa_spi)) {
2d21ac55 7273 lck_mtx_unlock(sadb_mutex);
55e303ae 7274 ipseclog((LOG_DEBUG, "key_add: SA already exists.\n"));
ecc0ceb4 7275 bzero_keys(mhp);
9bccf70c
A		 7276 return key_senderror(so, m, EEXIST);
7277 }
fe8ab488 7278 newsav = key_newsav(m, mhp, newsah, &error, so);
9bccf70c 7279 if (newsav == NULL) {
2d21ac55 7280 lck_mtx_unlock(sadb_mutex);
ecc0ceb4 7281 bzero_keys(mhp);
9bccf70c 7282 return key_senderror(so, m, error);
1c79356b 7283 }
39236c6e 7284
2d21ac55
A		 7285 /*
7286 * Verify if SADB_X_EXT_NATT_MULTIPLEUSERS flag is set that
7287 * this SA is for transport mode - otherwise clear it.
7288 */
7289 if ((newsav->flags & SADB_X_EXT_NATT_MULTIPLEUSERS) != 0 &&
7290 (newsah->saidx.mode != IPSEC_MODE_TRANSPORT ||
39236c6e 7291 newsah->saidx.dst.ss_family != AF_INET))
2d21ac55 7292 newsav->flags &= ~SADB_X_EXT_NATT_MULTIPLEUSERS;
39236c6e 7293
1c79356b 7294 /* check SA values to be mature. */
9bccf70c 7295 if ((error = key_mature(newsav)) != 0) {
2d21ac55
A		 7296 key_freesav(newsav, KEY_SADB_LOCKED);
7297 lck_mtx_unlock(sadb_mutex);
ecc0ceb4 7298 bzero_keys(mhp);
9bccf70c 7299 return key_senderror(so, m, error);
1c79356b 7300 }
39236c6e 7301
2d21ac55
A		 7302 lck_mtx_unlock(sadb_mutex);
7303
1c79356b
A		 7304 /*
7305 * don't call key_freesav() here, as we would like to keep the SA
7306 * in the database on success.
7307 */
39236c6e 7308
1c79356b 7309 {
39236c6e
A		 7310 struct mbuf *n;
7311
7312 /* set msg buf from mhp */
7313 n = key_getmsgbuf_x1(m, mhp);
7314 if (n == NULL) {
7315 ipseclog((LOG_DEBUG, "key_update: No more memory.\n"));
ecc0ceb4 7316 bzero_keys(mhp);
39236c6e
A		 7317 return key_senderror(so, m, ENOBUFS);
7318 }
7319
ecc0ceb4
A		 7320 // mh.ext points to the mbuf content.
7321 // Zero out Encryption and Integrity keys if present.
7322 bzero_keys(mhp);
39236c6e
A		 7323 m_freem(m);
7324 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
7325 }
1c79356b
A		 7326}
7327
9bccf70c 7328/* m is retained */
1c79356b 7329static int
6d2010ae 7330key_setident(
39236c6e
A		 7331 struct secashead *sah,
7332 struct mbuf *m,
7333 const struct sadb_msghdr *mhp)
1c79356b 7334{
9bccf70c 7335 const struct sadb_ident *idsrc, *iddst;
1c79356b 7336 int idsrclen, iddstlen;
39236c6e 7337
91447636 7338 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 7339
1c79356b 7340 /* sanity check */
9bccf70c 7341 if (sah == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 7342 panic("key_setident: NULL pointer is passed.\n");
39236c6e 7343
1c79356b 7344 /* don't make buffer if not there */
9bccf70c
A		 7345 if (mhp->ext[SADB_EXT_IDENTITY_SRC] == NULL &&
7346 mhp->ext[SADB_EXT_IDENTITY_DST] == NULL) {
1c79356b
A		 7347 sah->idents = NULL;
7348 sah->identd = NULL;
7349 return 0;
7350 }
7351
9bccf70c
A		 7352 if (mhp->ext[SADB_EXT_IDENTITY_SRC] == NULL ||
7353 mhp->ext[SADB_EXT_IDENTITY_DST] == NULL) {
55e303ae 7354 ipseclog((LOG_DEBUG, "key_setident: invalid identity.\n"));
9bccf70c 7355 return EINVAL;
1c79356b 7356 }
39236c6e 7357
316670eb 7358 idsrc = (const struct sadb_ident *)
39236c6e 7359 (void *)mhp->ext[SADB_EXT_IDENTITY_SRC];
316670eb 7360 iddst = (const struct sadb_ident *)
39236c6e 7361 (void *)mhp->ext[SADB_EXT_IDENTITY_DST];
9bccf70c
A		 7362 idsrclen = mhp->extlen[SADB_EXT_IDENTITY_SRC];
7363 iddstlen = mhp->extlen[SADB_EXT_IDENTITY_DST];
39236c6e 7364
1c79356b
A		 7365 /* validity check */
7366 if (idsrc->sadb_ident_type != iddst->sadb_ident_type) {
55e303ae 7367 ipseclog((LOG_DEBUG, "key_setident: ident type mismatch.\n"));
9bccf70c 7368 return EINVAL;
1c79356b 7369 }
39236c6e 7370
1c79356b 7371 switch (idsrc->sadb_ident_type) {
39236c6e
A		 7372 case SADB_IDENTTYPE_PREFIX:
7373 case SADB_IDENTTYPE_FQDN:
7374 case SADB_IDENTTYPE_USERFQDN:
7375 default:
7376 /* XXX do nothing */
7377 sah->idents = NULL;
7378 sah->identd = NULL;
7379 return 0;
1c79356b 7380 }
39236c6e 7381
1c79356b 7382 /* make structure */
2d21ac55 7383 KMALLOC_NOWAIT(sah->idents, struct sadb_ident *, idsrclen);
1c79356b 7384 if (sah->idents == NULL) {
2d21ac55
A		 7385 lck_mtx_unlock(sadb_mutex);
7386 KMALLOC_WAIT(sah->idents, struct sadb_ident *, idsrclen);
7387 lck_mtx_lock(sadb_mutex);
7388 if (sah->idents == NULL) {
7389 ipseclog((LOG_DEBUG, "key_setident: No more memory.\n"));
7390 return ENOBUFS;
7391 }
1c79356b 7392 }
2d21ac55 7393 KMALLOC_NOWAIT(sah->identd, struct sadb_ident *, iddstlen);
1c79356b 7394 if (sah->identd == NULL) {
2d21ac55
A		 7395 lck_mtx_unlock(sadb_mutex);
7396 KMALLOC_WAIT(sah->identd, struct sadb_ident *, iddstlen);
7397 lck_mtx_lock(sadb_mutex);
7398 if (sah->identd == NULL) {
7399 KFREE(sah->idents);
7400 sah->idents = NULL;
7401 ipseclog((LOG_DEBUG, "key_setident: No more memory.\n"));
7402 return ENOBUFS;
7403 }
1c79356b
A		 7404 }
7405 bcopy(idsrc, sah->idents, idsrclen);
7406 bcopy(iddst, sah->identd, iddstlen);
39236c6e 7407
1c79356b
A		 7408 return 0;
7409}
7410
9bccf70c
A		 7411/*
7412 * m will not be freed on return.
39236c6e 7413 * it is caller's responsibility to free the result.
9bccf70c
A		 7414 */
7415static struct mbuf *
6d2010ae 7416key_getmsgbuf_x1(
39236c6e
A		 7417 struct mbuf *m,
7418 const struct sadb_msghdr *mhp)
1c79356b 7419{
9bccf70c
A		 7420 struct mbuf *n;
7421 int mbufItems[] = {SADB_EXT_RESERVED, SADB_EXT_SA,
39236c6e
A		 7422 SADB_X_EXT_SA2, SADB_EXT_ADDRESS_SRC,
7423 SADB_EXT_ADDRESS_DST, SADB_EXT_LIFETIME_HARD,
7424 SADB_EXT_LIFETIME_SOFT, SADB_EXT_IDENTITY_SRC,
7425 SADB_EXT_IDENTITY_DST};
7426
1c79356b 7427 /* sanity check */
9bccf70c 7428 if (m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 7429 panic("key_getmsgbuf_x1: NULL pointer is passed.\n");
39236c6e 7430
1c79356b 7431 /* create new sadb_msg to reply. */
9bccf70c
A		 7432 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
7433 if (!n)
1c79356b 7434 return NULL;
39236c6e 7435
9bccf70c
A		 7436 if (n->m_len < sizeof(struct sadb_msg)) {
7437 n = m_pullup(n, sizeof(struct sadb_msg));
7438 if (n == NULL)
7439 return NULL;
7440 }
7441 mtod(n, struct sadb_msg *)->sadb_msg_errno = 0;
7442 mtod(n, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 7443 PFKEY_UNIT64(n->m_pkthdr.len);
7444
9bccf70c 7445 return n;
1c79356b
A		 7446}
7447
91447636 7448static int key_delete_all(struct socket *, struct mbuf *,
39236c6e 7449 const struct sadb_msghdr *, u_int16_t);
9bccf70c 7450
1c79356b
A		 7451/*
7452 * SADB_DELETE processing
7453 * receive
7454 * <base, SA(*), address(SD)>
7455 * from the ikmpd, and set SADB_SASTATE_DEAD,
7456 * and send,
7457 * <base, SA(*), address(SD)>
7458 * to the ikmpd.
7459 *
9bccf70c 7460 * m will always be freed.
1c79356b 7461 */
9bccf70c 7462static int
6d2010ae 7463key_delete(
39236c6e
A		 7464 struct socket *so,
7465 struct mbuf *m,
7466 const struct sadb_msghdr *mhp)
1c79356b 7467{
1c79356b
A		 7468 struct sadb_sa *sa0;
7469 struct sadb_address *src0, *dst0;
fe8ab488 7470 ifnet_t ipsec_if = NULL;
1c79356b
A		 7471 struct secasindex saidx;
7472 struct secashead *sah;
9bccf70c 7473 struct secasvar *sav = NULL;
1c79356b 7474 u_int16_t proto;
39236c6e 7475
2d21ac55
A		 7476 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
7477
1c79356b 7478 /* sanity check */
9bccf70c 7479 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 7480 panic("key_delete: NULL pointer is passed.\n");
39236c6e 7481
1c79356b 7482 /* map satype to proto */
9bccf70c 7483 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 7484 ipseclog((LOG_DEBUG, "key_delete: invalid satype is passed.\n"));
9bccf70c 7485 return key_senderror(so, m, EINVAL);
1c79356b 7486 }
39236c6e 7487
9bccf70c
A		 7488 if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
7489 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
55e303ae 7490 ipseclog((LOG_DEBUG, "key_delete: invalid message is passed.\n"));
9bccf70c 7491 return key_senderror(so, m, EINVAL);
1c79356b 7492 }
39236c6e 7493
9bccf70c
A		 7494 if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
7495 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
55e303ae 7496 ipseclog((LOG_DEBUG, "key_delete: invalid message is passed.\n"));
9bccf70c
A		 7497 return key_senderror(so, m, EINVAL);
7498 }
39236c6e 7499
2d21ac55
A		 7500 lck_mtx_lock(sadb_mutex);
7501
9bccf70c
A		 7502 if (mhp->ext[SADB_EXT_SA] == NULL) {
7503 /*
7504 * Caller wants us to delete all non-LARVAL SAs
7505 * that match the src/dst. This is used during
7506 * IKE INITIAL-CONTACT.
7507 */
55e303ae 7508 ipseclog((LOG_DEBUG, "key_delete: doing delete all.\n"));
2d21ac55 7509 /* key_delete_all will unlock sadb_mutex */
39236c6e 7510 return key_delete_all(so, m, mhp, proto);
9bccf70c 7511 } else if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa)) {
2d21ac55 7512 lck_mtx_unlock(sadb_mutex);
55e303ae 7513 ipseclog((LOG_DEBUG, "key_delete: invalid message is passed.\n"));
9bccf70c 7514 return key_senderror(so, m, EINVAL);
1c79356b 7515 }
39236c6e 7516
316670eb 7517 sa0 = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
9bccf70c
A		 7518 src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
7519 dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
3e170ce0 7520 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
39236c6e 7521
9bccf70c 7522 /* XXX boundary check against sa_len */
fe8ab488 7523 KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 7524
9bccf70c
A		 7525 /* get a SA header */
7526 LIST_FOREACH(sah, &sahtree, chain) {
7527 if (sah->state == SADB_SASTATE_DEAD)
7528 continue;
55e303ae 7529 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_HEAD) == 0)
9bccf70c 7530 continue;
39236c6e 7531
9bccf70c
A		 7532 /* get a SA with SPI. */
7533 sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
7534 if (sav)
7535 break;
7536 }
7537 if (sah == NULL) {
2d21ac55 7538 lck_mtx_unlock(sadb_mutex);
55e303ae 7539 ipseclog((LOG_DEBUG, "key_delete: no SA found.\n"));
9bccf70c 7540 return key_senderror(so, m, ENOENT);
1c79356b 7541 }
39236c6e 7542
1c79356b 7543 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
2d21ac55
A		 7544 key_freesav(sav, KEY_SADB_LOCKED);
7545
7546 lck_mtx_unlock(sadb_mutex);
1c79356b 7547 sav = NULL;
39236c6e 7548
1c79356b 7549 {
39236c6e
A		 7550 struct mbuf *n;
7551 struct sadb_msg *newmsg;
7552 int mbufItems[] = {SADB_EXT_RESERVED, SADB_EXT_SA,
7553 SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST};
7554
7555 /* create new sadb_msg to reply. */
7556 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
7557 if (!n)
9bccf70c 7558 return key_senderror(so, m, ENOBUFS);
39236c6e
A		 7559
7560 if (n->m_len < sizeof(struct sadb_msg)) {
7561 n = m_pullup(n, sizeof(struct sadb_msg));
7562 if (n == NULL)
7563 return key_senderror(so, m, ENOBUFS);
7564 }
7565 newmsg = mtod(n, struct sadb_msg *);
7566 newmsg->sadb_msg_errno = 0;
7567 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
7568
7569 m_freem(m);
7570 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
9bccf70c
A		 7571 }
7572}
7573
7574/*
7575 * delete all SAs for src/dst. Called from key_delete().
7576 */
7577static int
6d2010ae 7578key_delete_all(
39236c6e
A		 7579 struct socket *so,
7580 struct mbuf *m,
7581 const struct sadb_msghdr *mhp,
7582 u_int16_t proto)
9bccf70c
A		 7583{
7584 struct sadb_address *src0, *dst0;
fe8ab488 7585 ifnet_t ipsec_if = NULL;
9bccf70c
A		 7586 struct secasindex saidx;
7587 struct secashead *sah;
7588 struct secasvar *sav, *nextsav;
7589 u_int stateidx, state;
39236c6e 7590
91447636 7591 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 7592
9bccf70c
A		 7593 src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
7594 dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
3e170ce0 7595 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
39236c6e 7596
9bccf70c 7597 /* XXX boundary check against sa_len */
fe8ab488 7598 KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 7599
9bccf70c
A		 7600 LIST_FOREACH(sah, &sahtree, chain) {
7601 if (sah->state == SADB_SASTATE_DEAD)
7602 continue;
55e303ae 7603 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_HEAD) == 0)
9bccf70c 7604 continue;
39236c6e 7605
9bccf70c
A		 7606 /* Delete all non-LARVAL SAs. */
7607 for (stateidx = 0;
7608 stateidx < _ARRAYLEN(saorder_state_alive);
7609 stateidx++) {
7610 state = saorder_state_alive[stateidx];
7611 if (state == SADB_SASTATE_LARVAL)
7612 continue;
7613 for (sav = LIST_FIRST(&sah->savtree[state]);
7614 sav != NULL; sav = nextsav) {
7615 nextsav = LIST_NEXT(sav, chain);
7616 /* sanity check */
7617 if (sav->state != state) {
55e303ae 7618 ipseclog((LOG_DEBUG, "key_delete_all: "
39236c6e
A		 7619 "invalid sav->state "
7620 "(queue: %d SA: %d)\n",
7621 state, sav->state));
9bccf70c
A		 7622 continue;
7623 }
7624
7625 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
2d21ac55 7626 key_freesav(sav, KEY_SADB_LOCKED);
9bccf70c
A		 7627 }
7628 }
1c79356b 7629 }
2d21ac55
A		 7630 lck_mtx_unlock(sadb_mutex);
7631
9bccf70c 7632 {
39236c6e
A		 7633 struct mbuf *n;
7634 struct sadb_msg *newmsg;
7635 int mbufItems[] = {SADB_EXT_RESERVED, SADB_EXT_ADDRESS_SRC,
7636 SADB_EXT_ADDRESS_DST};
7637
7638 /* create new sadb_msg to reply. */
7639 n = key_gather_mbuf(m, mhp, 1, sizeof(mbufItems)/sizeof(int), mbufItems);
7640 if (!n)
9bccf70c 7641 return key_senderror(so, m, ENOBUFS);
39236c6e
A		 7642
7643 if (n->m_len < sizeof(struct sadb_msg)) {
7644 n = m_pullup(n, sizeof(struct sadb_msg));
7645 if (n == NULL)
7646 return key_senderror(so, m, ENOBUFS);
7647 }
7648 newmsg = mtod(n, struct sadb_msg *);
7649 newmsg->sadb_msg_errno = 0;
7650 newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
7651
7652 m_freem(m);
7653 return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
1c79356b
A		 7654 }
7655}
7656
7657/*
7658 * SADB_GET processing
7659 * receive
7660 * <base, SA(*), address(SD)>
7661 * from the ikmpd, and get a SP and a SA to respond,
7662 * and send,
7663 * <base, SA, (lifetime(HSC),) address(SD), (address(P),) key(AE),
7664 * (identity(SD),) (sensitivity)>
7665 * to the ikmpd.
7666 *
9bccf70c 7667 * m will always be freed.
1c79356b 7668 */
9bccf70c 7669static int
6d2010ae 7670key_get(
39236c6e
A		 7671 struct socket *so,
7672 struct mbuf *m,
7673 const struct sadb_msghdr *mhp)
1c79356b 7674{
1c79356b
A		 7675 struct sadb_sa *sa0;
7676 struct sadb_address *src0, *dst0;
fe8ab488 7677 ifnet_t ipsec_if = NULL;
1c79356b
A		 7678 struct secasindex saidx;
7679 struct secashead *sah;
9bccf70c 7680 struct secasvar *sav = NULL;
1c79356b 7681 u_int16_t proto;
39236c6e 7682
2d21ac55
A		 7683 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
7684
1c79356b 7685 /* sanity check */
9bccf70c 7686 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 7687 panic("key_get: NULL pointer is passed.\n");
39236c6e 7688
1c79356b 7689 /* map satype to proto */
9bccf70c 7690 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 7691 ipseclog((LOG_DEBUG, "key_get: invalid satype is passed.\n"));
9bccf70c 7692 return key_senderror(so, m, EINVAL);
1c79356b 7693 }
39236c6e 7694
9bccf70c
A		 7695 if (mhp->ext[SADB_EXT_SA] == NULL ||
7696 mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
7697 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
55e303ae 7698 ipseclog((LOG_DEBUG, "key_get: invalid message is passed.\n"));
9bccf70c 7699 return key_senderror(so, m, EINVAL);
1c79356b 7700 }
9bccf70c
A		 7701 if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
7702 mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
7703 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
55e303ae 7704 ipseclog((LOG_DEBUG, "key_get: invalid message is passed.\n"));
9bccf70c 7705 return key_senderror(so, m, EINVAL);
1c79356b 7706 }
39236c6e 7707
316670eb 7708 sa0 = (struct sadb_sa *)(void *)mhp->ext[SADB_EXT_SA];
9bccf70c
A		 7709 src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
7710 dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
3e170ce0 7711 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
39236c6e 7712
9bccf70c 7713 /* XXX boundary check against sa_len */
fe8ab488 7714 KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 7715
2d21ac55
A		 7716 lck_mtx_lock(sadb_mutex);
7717
9bccf70c
A		 7718 /* get a SA header */
7719 LIST_FOREACH(sah, &sahtree, chain) {
7720 if (sah->state == SADB_SASTATE_DEAD)
7721 continue;
55e303ae 7722 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_HEAD) == 0)
9bccf70c 7723 continue;
39236c6e 7724
9bccf70c
A		 7725 /* get a SA with SPI. */
7726 sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
7727 if (sav)
7728 break;
7729 }
7730 if (sah == NULL) {
2d21ac55 7731 lck_mtx_unlock(sadb_mutex);
55e303ae 7732 ipseclog((LOG_DEBUG, "key_get: no SA found.\n"));
9bccf70c 7733 return key_senderror(so, m, ENOENT);
1c79356b 7734 }
39236c6e 7735
1c79356b 7736 {
39236c6e
A		 7737 struct mbuf *n;
7738 u_int8_t satype;
7739
7740 /* map proto to satype */
7741 if ((satype = key_proto2satype(sah->saidx.proto)) == 0) {
7742 lck_mtx_unlock(sadb_mutex);
7743 ipseclog((LOG_DEBUG, "key_get: there was invalid proto in SAD.\n"));
7744 return key_senderror(so, m, EINVAL);
7745 }
2d21ac55 7746 lck_mtx_unlock(sadb_mutex);
39236c6e
A		 7747
7748 /* create new sadb_msg to reply. */
7749 n = key_setdumpsa(sav, SADB_GET, satype, mhp->msg->sadb_msg_seq,
7750 mhp->msg->sadb_msg_pid);
7751
7752
7753
7754 if (!n)
7755 return key_senderror(so, m, ENOBUFS);
7756
7757 m_freem(m);
7758 return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
9bccf70c
A		 7759 }
7760}
7761
b0d623f7
A		 7762/*
7763 * get SA stats by spi.
7764 * OUT: -1 : not found
7765 * 0 : found, arg pointer to a SA stats is updated.
7766 */
7767static int
7768key_getsastatbyspi_one (u_int32_t spi,
39236c6e 7769 struct sastat *stat)
b0d623f7
A		 7770{
7771 struct secashead *sah;
7772 struct secasvar *sav = NULL;
39236c6e 7773
b0d623f7 7774 if ((void *)stat == NULL) {
39236c6e 7775 return -1;
b0d623f7 7776 }
39236c6e 7777
b0d623f7
A		 7778 lck_mtx_lock(sadb_mutex);
7779
7780 /* get a SA header */
7781 LIST_FOREACH(sah, &sahtree, chain) {
7782 if (sah->state == SADB_SASTATE_DEAD)
7783 continue;
39236c6e 7784
b0d623f7
A		 7785 /* get a SA with SPI. */
7786 sav = key_getsavbyspi(sah, spi);
7787 if (sav) {
39236c6e 7788 stat->spi = sav->spi;
b0d623f7
A		 7789 stat->created = sav->created;
7790 if (sav->lft_c) {
39236c6e 7791 bcopy(sav->lft_c,&stat->lft_c, sizeof(stat->lft_c));
b0d623f7 7792 } else {
39236c6e 7793 bzero(&stat->lft_c, sizeof(stat->lft_c));
b0d623f7
A		 7794 }
7795 lck_mtx_unlock(sadb_mutex);
7796 return 0;
7797 }
7798 }
39236c6e 7799
b0d623f7 7800 lck_mtx_unlock(sadb_mutex);
39236c6e 7801
b0d623f7
A		 7802 return -1;
7803}
7804
7805/*
7806 * get SA stats collection by indices.
7807 * OUT: -1 : not found
7808 * 0 : found, arg pointers to a SA stats and 'maximum stats' are updated.
7809 */
7810static int
7811key_getsastatbyspi (struct sastat *stat_arg,
39236c6e
A		 7812 u_int32_t max_stat_arg,
7813 struct sastat *stat_res,
7814 u_int32_t *max_stat_res)
b0d623f7 7815{
39236c6e
A		 7816 int cur, found = 0;
7817
b0d623f7 7818 if (stat_arg == NULL ||
39236c6e 7819 stat_res == NULL ||
b0d623f7 7820 max_stat_res == NULL) {
39236c6e 7821 return -1;
b0d623f7 7822 }
39236c6e 7823
b0d623f7 7824 for (cur = 0; cur < max_stat_arg; cur++) {
39236c6e
A		 7825 if (key_getsastatbyspi_one(stat_arg[cur].spi,
7826 &stat_res[found]) == 0) {
7827 found++;
b0d623f7
A		 7828 }
7829 }
7830 *max_stat_res = found;
39236c6e 7831
b0d623f7 7832 if (found) {
39236c6e 7833 return 0;
b0d623f7
A		 7834 }
7835 return -1;
7836}
7837
9bccf70c
A		 7838/* XXX make it sysctl-configurable? */
7839static void
6d2010ae 7840key_getcomb_setlifetime(
39236c6e 7841 struct sadb_comb *comb)
9bccf70c 7842{
39236c6e 7843
9bccf70c
A		 7844 comb->sadb_comb_soft_allocations = 1;
7845 comb->sadb_comb_hard_allocations = 1;
7846 comb->sadb_comb_soft_bytes = 0;
7847 comb->sadb_comb_hard_bytes = 0;
7848 comb->sadb_comb_hard_addtime = 86400; /* 1 day */
7849 comb->sadb_comb_soft_addtime = comb->sadb_comb_soft_addtime * 80 / 100;
7850 comb->sadb_comb_soft_usetime = 28800; /* 8 hours */
7851 comb->sadb_comb_hard_usetime = comb->sadb_comb_hard_usetime * 80 / 100;
7852}
7853
7854#if IPSEC_ESP
7855/*
7856 * XXX reorder combinations by preference
7857 * XXX no idea if the user wants ESP authentication or not
7858 */
7859static struct mbuf *
6d2010ae 7860key_getcomb_esp(void)
9bccf70c
A		 7861{
7862 struct sadb_comb *comb;
7863 const struct esp_algorithm *algo;
7864 struct mbuf *result = NULL, *m, *n;
7865 int encmin;
7866 int i, off, o;
7867 int totlen;
7868 const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
39236c6e 7869
9bccf70c
A		 7870 m = NULL;
7871 for (i = 1; i <= SADB_EALG_MAX; i++) {
7872 algo = esp_algorithm_lookup(i);
7873 if (!algo)
7874 continue;
39236c6e 7875
9bccf70c
A		 7876 if (algo->keymax < ipsec_esp_keymin)
7877 continue;
7878 if (algo->keymin < ipsec_esp_keymin)
7879 encmin = ipsec_esp_keymin;
7880 else
7881 encmin = algo->keymin;
39236c6e 7882
9bccf70c
A		 7883 if (ipsec_esp_auth)
7884 m = key_getcomb_ah();
7885 else {
7886#if DIAGNOSTIC
7887 if (l > MLEN)
7888 panic("assumption failed in key_getcomb_esp");
7889#endif
316670eb 7890 MGET(m, M_WAITOK, MT_DATA);
9bccf70c
A		 7891 if (m) {
7892 M_ALIGN(m, l);
7893 m->m_len = l;
7894 m->m_next = NULL;
7895 bzero(mtod(m, caddr_t), m->m_len);
7896 }
7897 }
7898 if (!m)
7899 goto fail;
39236c6e 7900
9bccf70c
A		 7901 totlen = 0;
7902 for (n = m; n; n = n->m_next)
7903 totlen += n->m_len;
7904#if DIAGNOSTIC
7905 if (totlen % l)
7906 panic("assumption failed in key_getcomb_esp");
7907#endif
39236c6e 7908
9bccf70c
A		 7909 for (off = 0; off < totlen; off += l) {
7910 n = m_pulldown(m, off, l, &o);
7911 if (!n) {
7912 /* m is already freed */
7913 goto fail;
7914 }
316670eb 7915 comb = (struct sadb_comb *)
39236c6e 7916 (void *)(mtod(n, caddr_t) + o);
9bccf70c
A		 7917 bzero(comb, sizeof(*comb));
7918 key_getcomb_setlifetime(comb);
7919 comb->sadb_comb_encrypt = i;
7920 comb->sadb_comb_encrypt_minbits = encmin;
7921 comb->sadb_comb_encrypt_maxbits = algo->keymax;
7922 }
39236c6e 7923
9bccf70c
A		 7924 if (!result)
7925 result = m;
7926 else
7927 m_cat(result, m);
7928 }
39236c6e 7929
9bccf70c 7930 return result;
39236c6e
A		 7931
7932fail:
9bccf70c
A		 7933 if (result)
7934 m_freem(result);
7935 return NULL;
7936}
1c79356b 7937#endif
9bccf70c
A		 7938
7939/*
7940 * XXX reorder combinations by preference
7941 */
7942static struct mbuf *
6d2010ae 7943key_getcomb_ah(void)
9bccf70c
A		 7944{
7945 struct sadb_comb *comb;
7946 const struct ah_algorithm *algo;
7947 struct mbuf *m;
2d21ac55 7948 int keymin;
9bccf70c
A		 7949 int i;
7950 const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
39236c6e 7951
9bccf70c
A		 7952 m = NULL;
7953 for (i = 1; i <= SADB_AALG_MAX; i++) {
7954#if 1
7955 /* we prefer HMAC algorithms, not old algorithms */
7956 if (i != SADB_AALG_SHA1HMAC && i != SADB_AALG_MD5HMAC)
7957 continue;
7958#endif
7959 algo = ah_algorithm_lookup(i);
7960 if (!algo)
7961 continue;
39236c6e 7962
9bccf70c
A		 7963 if (algo->keymax < ipsec_ah_keymin)
7964 continue;
7965 if (algo->keymin < ipsec_ah_keymin)
2d21ac55 7966 keymin = ipsec_ah_keymin;
9bccf70c 7967 else
2d21ac55 7968 keymin = algo->keymin;
39236c6e 7969
9bccf70c
A		 7970 if (!m) {
7971#if DIAGNOSTIC
7972 if (l > MLEN)
7973 panic("assumption failed in key_getcomb_ah");
7974#endif
316670eb 7975 MGET(m, M_WAITOK, MT_DATA);
9bccf70c
A		 7976 if (m) {
7977 M_ALIGN(m, l);
7978 m->m_len = l;
7979 m->m_next = NULL;
7980 }
7981 } else
3e170ce0 7982 M_PREPEND(m, l, M_WAITOK, 1);
9bccf70c
A		 7983 if (!m)
7984 return NULL;
39236c6e 7985
9bccf70c
A		 7986 comb = mtod(m, struct sadb_comb *);
7987 bzero(comb, sizeof(*comb));
7988 key_getcomb_setlifetime(comb);
7989 comb->sadb_comb_auth = i;
2d21ac55 7990 comb->sadb_comb_auth_minbits = keymin;
9bccf70c
A		 7991 comb->sadb_comb_auth_maxbits = algo->keymax;
7992 }
39236c6e 7993
9bccf70c
A		 7994 return m;
7995}
7996
7997/*
7998 * not really an official behavior. discussed in pf_key@inner.net in Sep2000.
7999 * XXX reorder combinations by preference
8000 */
8001static struct mbuf *
6d2010ae 8002key_getcomb_ipcomp(void)
9bccf70c
A		 8003{
8004 struct sadb_comb *comb;
8005 const struct ipcomp_algorithm *algo;
8006 struct mbuf *m;
8007 int i;
8008 const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
39236c6e 8009
9bccf70c
A		 8010 m = NULL;
8011 for (i = 1; i <= SADB_X_CALG_MAX; i++) {
8012 algo = ipcomp_algorithm_lookup(i);
8013 if (!algo)
8014 continue;
39236c6e 8015
9bccf70c
A		 8016 if (!m) {
8017#if DIAGNOSTIC
8018 if (l > MLEN)
8019 panic("assumption failed in key_getcomb_ipcomp");
8020#endif
316670eb 8021 MGET(m, M_WAITOK, MT_DATA);
9bccf70c
A		 8022 if (m) {
8023 M_ALIGN(m, l);
8024 m->m_len = l;
8025 m->m_next = NULL;
8026 }
8027 } else
3e170ce0 8028 M_PREPEND(m, l, M_WAITOK, 1);
9bccf70c
A		 8029 if (!m)
8030 return NULL;
39236c6e 8031
9bccf70c
A		 8032 comb = mtod(m, struct sadb_comb *);
8033 bzero(comb, sizeof(*comb));
8034 key_getcomb_setlifetime(comb);
8035 comb->sadb_comb_encrypt = i;
8036 /* what should we set into sadb_comb_*_{min,max}bits? */
8037 }
39236c6e 8038
9bccf70c
A		 8039 return m;
8040}
8041
8042/*
8043 * XXX no way to pass mode (transport/tunnel) to userland
8044 * XXX replay checking?
8045 * XXX sysctl interface to ipsec_{ah,esp}_keymin
8046 */
8047static struct mbuf *
6d2010ae 8048key_getprop(
39236c6e 8049 const struct secasindex *saidx)
9bccf70c
A		 8050{
8051 struct sadb_prop *prop;
8052 struct mbuf *m, *n;
8053 const int l = PFKEY_ALIGN8(sizeof(struct sadb_prop));
8054 int totlen;
39236c6e 8055
9bccf70c
A		 8056 switch (saidx->proto) {
8057#if IPSEC_ESP
39236c6e
A		 8058 case IPPROTO_ESP:
8059 m = key_getcomb_esp();
8060 break;
9bccf70c 8061#endif
39236c6e
A		 8062 case IPPROTO_AH:
8063 m = key_getcomb_ah();
8064 break;
8065 case IPPROTO_IPCOMP:
8066 m = key_getcomb_ipcomp();
8067 break;
8068 default:
8069 return NULL;
1c79356b 8070 }
39236c6e 8071
9bccf70c
A		 8072 if (!m)
8073 return NULL;
3e170ce0 8074 M_PREPEND(m, l, M_WAITOK, 1);
9bccf70c
A		 8075 if (!m)
8076 return NULL;
39236c6e 8077
9bccf70c
A		 8078 totlen = 0;
8079 for (n = m; n; n = n->m_next)
8080 totlen += n->m_len;
39236c6e 8081
9bccf70c
A		 8082 prop = mtod(m, struct sadb_prop *);
8083 bzero(prop, sizeof(*prop));
8084 prop->sadb_prop_len = PFKEY_UNIT64(totlen);
8085 prop->sadb_prop_exttype = SADB_EXT_PROPOSAL;
8086 prop->sadb_prop_replay = 32; /* XXX */
39236c6e 8087
9bccf70c 8088 return m;
1c79356b
A		 8089}
8090
8091/*
8092 * SADB_ACQUIRE processing called by key_checkrequest() and key_acquire2().
8093 * send
9bccf70c 8094 * <base, SA, address(SD), (address(P)), x_policy,
1c79356b
A		 8095 * (identity(SD),) (sensitivity,) proposal>
8096 * to KMD, and expect to receive
91447636 8097 * <base> with SADB_ACQUIRE if error occurred,
1c79356b
A		 8098 * or
8099 * <base, src address, dst address, (SPI range)> with SADB_GETSPI
8100 * from KMD by PF_KEY.
8101 *
9bccf70c
A		 8102 * XXX x_policy is outside of RFC2367 (KAME extension).
8103 * XXX sensitivity is not supported.
8104 * XXX for ipcomp, RFC2367 does not define how to fill in proposal.
8105 * see comment for key_getcomb_ipcomp().
1c79356b
A		 8106 *
8107 * OUT:
8108 * 0 : succeed
8109 * others: error number
8110 */
8111static int
6d2010ae 8112key_acquire(
39236c6e
A		 8113 struct secasindex *saidx,
8114 struct secpolicy *sp)
1c79356b 8115{
9bccf70c 8116 struct mbuf *result = NULL, *m;
1c79356b
A		 8117#ifndef IPSEC_NONBLOCK_ACQUIRE
8118 struct secacq *newacq;
8119#endif
1c79356b 8120 u_int8_t satype;
9bccf70c
A		 8121 int error = -1;
8122 u_int32_t seq;
39236c6e 8123
2d21ac55
A		 8124 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
8125
1c79356b 8126 /* sanity check */
9bccf70c 8127 if (saidx == NULL)
1c79356b
A		 8128 panic("key_acquire: NULL pointer is passed.\n");
8129 if ((satype = key_proto2satype(saidx->proto)) == 0)
8130 panic("key_acquire: invalid proto is passed.\n");
39236c6e 8131
1c79356b
A		 8132#ifndef IPSEC_NONBLOCK_ACQUIRE
8133 /*
8134 * We never do anything about acquirng SA. There is anather
8135 * solution that kernel blocks to send SADB_ACQUIRE message until
8136 * getting something message from IKEd. In later case, to be
8137 * managed with ACQUIRING list.
8138 */
8139 /* get a entry to check whether sending message or not. */
2d21ac55 8140 lck_mtx_lock(sadb_mutex);
1c79356b
A		 8141 if ((newacq = key_getacq(saidx)) != NULL) {
8142 if (key_blockacq_count < newacq->count) {
8143 /* reset counter and do send message. */
8144 newacq->count = 0;
8145 } else {
8146 /* increment counter and do nothing. */
8147 newacq->count++;
2d21ac55 8148 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 8149 return 0;
8150 }
8151 } else {
8152 /* make new entry for blocking to send SADB_ACQUIRE. */
2d21ac55
A		 8153 if ((newacq = key_newacq(saidx)) == NULL) {
8154 lck_mtx_unlock(sadb_mutex);
1c79356b 8155 return ENOBUFS;
2d21ac55 8156 }
39236c6e 8157
1c79356b
A		 8158 /* add to acqtree */
8159 LIST_INSERT_HEAD(&acqtree, newacq, chain);
39236c6e 8160 key_start_timehandler();
1c79356b 8161 }
9bccf70c 8162 seq = newacq->seq;
2d21ac55 8163 lck_mtx_unlock(sadb_mutex);
39236c6e 8164
1c79356b 8165#else
9bccf70c 8166 seq = (acq_seq = (acq_seq == ~0 ? 1 : ++acq_seq));
1c79356b 8167#endif
9bccf70c
A		 8168 m = key_setsadbmsg(SADB_ACQUIRE, 0, satype, seq, 0, 0);
8169 if (!m) {
8170 error = ENOBUFS;
8171 goto fail;
8172 }
8173 result = m;
39236c6e 8174
1c79356b 8175 /* set sadb_address for saidx's. */
9bccf70c 8176 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
39236c6e 8177 (struct sockaddr *)&saidx->src, FULLMASK, IPSEC_ULPROTO_ANY);
9bccf70c
A		 8178 if (!m) {
8179 error = ENOBUFS;
8180 goto fail;
8181 }
8182 m_cat(result, m);
39236c6e 8183
9bccf70c 8184 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
39236c6e 8185 (struct sockaddr *)&saidx->dst, FULLMASK, IPSEC_ULPROTO_ANY);
9bccf70c
A		 8186 if (!m) {
8187 error = ENOBUFS;
8188 goto fail;
8189 }
8190 m_cat(result, m);
39236c6e 8191
9bccf70c 8192 /* XXX proxy address (optional) */
39236c6e 8193
9bccf70c
A		 8194 /* set sadb_x_policy */
8195 if (sp) {
8196 m = key_setsadbxpolicy(sp->policy, sp->spidx.dir, sp->id);
8197 if (!m) {
8198 error = ENOBUFS;
8199 goto fail;
8200 }
8201 m_cat(result, m);
8202 }
316670eb 8203
9bccf70c
A		 8204 /* XXX identity (optional) */
8205#if 0
1c79356b
A		 8206 if (idexttype && fqdn) {
8207 /* create identity extension (FQDN) */
8208 struct sadb_ident *id;
8209 int fqdnlen;
39236c6e 8210
1c79356b
A		 8211 fqdnlen = strlen(fqdn) + 1; /* +1 for terminating-NUL */
8212 id = (struct sadb_ident *)p;
8213 bzero(id, sizeof(*id) + PFKEY_ALIGN8(fqdnlen));
8214 id->sadb_ident_len = PFKEY_UNIT64(sizeof(*id) + PFKEY_ALIGN8(fqdnlen));
8215 id->sadb_ident_exttype = idexttype;
8216 id->sadb_ident_type = SADB_IDENTTYPE_FQDN;
8217 bcopy(fqdn, id + 1, fqdnlen);
8218 p += sizeof(struct sadb_ident) + PFKEY_ALIGN8(fqdnlen);
8219 }
39236c6e 8220
1c79356b
A		 8221 if (idexttype) {
8222 /* create identity extension (USERFQDN) */
8223 struct sadb_ident *id;
8224 int userfqdnlen;
39236c6e 8225
1c79356b
A		 8226 if (userfqdn) {
8227 /* +1 for terminating-NUL */
8228 userfqdnlen = strlen(userfqdn) + 1;
8229 } else
8230 userfqdnlen = 0;
8231 id = (struct sadb_ident *)p;
8232 bzero(id, sizeof(*id) + PFKEY_ALIGN8(userfqdnlen));
8233 id->sadb_ident_len = PFKEY_UNIT64(sizeof(*id) + PFKEY_ALIGN8(userfqdnlen));
8234 id->sadb_ident_exttype = idexttype;
8235 id->sadb_ident_type = SADB_IDENTTYPE_USERFQDN;
8236 /* XXX is it correct? */
8237 if (curproc && curproc->p_cred)
8238 id->sadb_ident_id = curproc->p_cred->p_ruid;
8239 if (userfqdn && userfqdnlen)
8240 bcopy(userfqdn, id + 1, userfqdnlen);
8241 p += sizeof(struct sadb_ident) + PFKEY_ALIGN8(userfqdnlen);
8242 }
8243#endif
39236c6e 8244
9bccf70c 8245 /* XXX sensitivity (optional) */
39236c6e 8246
9bccf70c
A		 8247 /* create proposal/combination extension */
8248 m = key_getprop(saidx);
8249#if 0
8250 /*
8251 * spec conformant: always attach proposal/combination extension,
8252 * the problem is that we have no way to attach it for ipcomp,
8253 * due to the way sadb_comb is declared in RFC2367.
8254 */
8255 if (!m) {
8256 error = ENOBUFS;
8257 goto fail;
8258 }
8259 m_cat(result, m);
8260#else
8261 /*
8262 * outside of spec; make proposal/combination extension optional.
8263 */
8264 if (m)
8265 m_cat(result, m);
1c79356b 8266#endif
39236c6e 8267
9bccf70c
A		 8268 if ((result->m_flags & M_PKTHDR) == 0) {
8269 error = EINVAL;
8270 goto fail;
8271 }
39236c6e 8272
9bccf70c
A		 8273 if (result->m_len < sizeof(struct sadb_msg)) {
8274 result = m_pullup(result, sizeof(struct sadb_msg));
8275 if (result == NULL) {
8276 error = ENOBUFS;
8277 goto fail;
8278 }
8279 }
39236c6e 8280
9bccf70c
A		 8281 result->m_pkthdr.len = 0;
8282 for (m = result; m; m = m->m_next)
8283 result->m_pkthdr.len += m->m_len;
39236c6e 8284
9bccf70c 8285 mtod(result, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 8286 PFKEY_UNIT64(result->m_pkthdr.len);
8287
9bccf70c 8288 return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
39236c6e
A		 8289
8290fail:
9bccf70c
A		 8291 if (result)
8292 m_freem(result);
8293 return error;
1c79356b
A		 8294}
8295
8296#ifndef IPSEC_NONBLOCK_ACQUIRE
8297static struct secacq *
6d2010ae 8298key_newacq(
39236c6e 8299 struct secasindex *saidx)
1c79356b
A		 8300{
8301 struct secacq *newacq;
9bccf70c 8302 struct timeval tv;
39236c6e 8303
1c79356b 8304 /* get new entry */
2d21ac55 8305 KMALLOC_NOWAIT(newacq, struct secacq *, sizeof(struct secacq));
1c79356b 8306 if (newacq == NULL) {
2d21ac55
A		 8307 lck_mtx_unlock(sadb_mutex);
8308 KMALLOC_WAIT(newacq, struct secacq *, sizeof(struct secacq));
8309 lck_mtx_lock(sadb_mutex);
39236c6e 8310 if (newacq == NULL) {
2d21ac55
A		 8311 ipseclog((LOG_DEBUG, "key_newacq: No more memory.\n"));
8312 return NULL;
8313 }
1c79356b
A		 8314 }
8315 bzero(newacq, sizeof(*newacq));
39236c6e 8316
1c79356b
A		 8317 /* copy secindex */
8318 bcopy(saidx, &newacq->saidx, sizeof(newacq->saidx));
8319 newacq->seq = (acq_seq == ~0 ? 1 : ++acq_seq);
9bccf70c
A		 8320 microtime(&tv);
8321 newacq->created = tv.tv_sec;
1c79356b 8322 newacq->count = 0;
39236c6e 8323
1c79356b
A		 8324 return newacq;
8325}
8326
8327static struct secacq *
6d2010ae 8328key_getacq(
39236c6e 8329 struct secasindex *saidx)
1c79356b
A		 8330{
8331 struct secacq *acq;
39236c6e 8332
91447636 8333 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 8334
1c79356b 8335 LIST_FOREACH(acq, &acqtree, chain) {
55e303ae 8336 if (key_cmpsaidx(saidx, &acq->saidx, CMP_EXACTLY))
1c79356b
A		 8337 return acq;
8338 }
39236c6e 8339
1c79356b
A		 8340 return NULL;
8341}
8342
8343static struct secacq *
6d2010ae 8344key_getacqbyseq(
39236c6e 8345 u_int32_t seq)
1c79356b
A		 8346{
8347 struct secacq *acq;
39236c6e 8348
91447636 8349 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 8350
1c79356b
A		 8351 LIST_FOREACH(acq, &acqtree, chain) {
8352 if (acq->seq == seq)
8353 return acq;
8354 }
39236c6e 8355
1c79356b
A		 8356 return NULL;
8357}
8358#endif
8359
8360static struct secspacq *
6d2010ae 8361key_newspacq(
39236c6e 8362 struct secpolicyindex *spidx)
1c79356b
A		 8363{
8364 struct secspacq *acq;
9bccf70c 8365 struct timeval tv;
39236c6e 8366
1c79356b 8367 /* get new entry */
2d21ac55 8368 KMALLOC_NOWAIT(acq, struct secspacq *, sizeof(struct secspacq));
1c79356b 8369 if (acq == NULL) {
2d21ac55
A		 8370 lck_mtx_unlock(sadb_mutex);
8371 KMALLOC_WAIT(acq, struct secspacq *, sizeof(struct secspacq));
8372 lck_mtx_lock(sadb_mutex);
8373 if (acq == NULL) {
8374 ipseclog((LOG_DEBUG, "key_newspacq: No more memory.\n"));
8375 return NULL;
8376 }
1c79356b
A		 8377 }
8378 bzero(acq, sizeof(*acq));
39236c6e 8379
1c79356b
A		 8380 /* copy secindex */
8381 bcopy(spidx, &acq->spidx, sizeof(acq->spidx));
9bccf70c
A		 8382 microtime(&tv);
8383 acq->created = tv.tv_sec;
1c79356b 8384 acq->count = 0;
39236c6e 8385
1c79356b
A		 8386 return acq;
8387}
8388
8389static struct secspacq *
6d2010ae 8390key_getspacq(
39236c6e 8391 struct secpolicyindex *spidx)
1c79356b
A		 8392{
8393 struct secspacq *acq;
39236c6e 8394
91447636 8395 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 8396
1c79356b
A		 8397 LIST_FOREACH(acq, &spacqtree, chain) {
8398 if (key_cmpspidx_exactly(spidx, &acq->spidx))
8399 return acq;
8400 }
39236c6e 8401
1c79356b
A		 8402 return NULL;
8403}
8404
8405/*
8406 * SADB_ACQUIRE processing,
8407 * in first situation, is receiving
8408 * <base>
8409 * from the ikmpd, and clear sequence of its secasvar entry.
8410 *
8411 * In second situation, is receiving
8412 * <base, address(SD), (address(P),) (identity(SD),) (sensitivity,) proposal>
8413 * from a user land process, and return
8414 * <base, address(SD), (address(P),) (identity(SD),) (sensitivity,) proposal>
8415 * to the socket.
8416 *
9bccf70c 8417 * m will always be freed.
1c79356b 8418 */
9bccf70c 8419static int
6d2010ae 8420key_acquire2(
39236c6e
A		 8421 struct socket *so,
8422 struct mbuf *m,
8423 const struct sadb_msghdr *mhp)
1c79356b 8424{
9bccf70c 8425 const struct sadb_address *src0, *dst0;
fe8ab488 8426 ifnet_t ipsec_if = NULL;
1c79356b
A		 8427 struct secasindex saidx;
8428 struct secashead *sah;
8429 u_int16_t proto;
9bccf70c 8430 int error;
39236c6e
A		 8431
8432
1c79356b 8433 /* sanity check */
9bccf70c 8434 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 8435 panic("key_acquire2: NULL pointer is passed.\n");
39236c6e 8436
1c79356b
A		 8437 /*
8438 * Error message from KMd.
91447636 8439 * We assume that if error was occurred in IKEd, the length of PFKEY
1c79356b 8440 * message is equal to the size of sadb_msg structure.
91447636 8441 * We do not raise error even if error occurred in this function.
1c79356b 8442 */
39236c6e
A		 8443 lck_mtx_lock(sadb_mutex);
8444
9bccf70c 8445 if (mhp->msg->sadb_msg_len == PFKEY_UNIT64(sizeof(struct sadb_msg))) {
1c79356b
A		 8446#ifndef IPSEC_NONBLOCK_ACQUIRE
8447 struct secacq *acq;
9bccf70c 8448 struct timeval tv;
39236c6e 8449
1c79356b 8450 /* check sequence number */
9bccf70c 8451 if (mhp->msg->sadb_msg_seq == 0) {
2d21ac55 8452 lck_mtx_unlock(sadb_mutex);
55e303ae 8453 ipseclog((LOG_DEBUG, "key_acquire2: must specify sequence number.\n"));
9bccf70c
A		 8454 m_freem(m);
8455 return 0;
1c79356b 8456 }
39236c6e 8457
9bccf70c
A		 8458 if ((acq = key_getacqbyseq(mhp->msg->sadb_msg_seq)) == NULL) {
8459 /*
8460 * the specified larval SA is already gone, or we got
8461 * a bogus sequence number. we can silently ignore it.
8462 */
2d21ac55 8463 lck_mtx_unlock(sadb_mutex);
9bccf70c
A		 8464 m_freem(m);
8465 return 0;
1c79356b 8466 }
39236c6e 8467
1c79356b 8468 /* reset acq counter in order to deletion by timehander. */
9bccf70c
A		 8469 microtime(&tv);
8470 acq->created = tv.tv_sec;
1c79356b
A		 8471 acq->count = 0;
8472#endif
2d21ac55 8473 lck_mtx_unlock(sadb_mutex);
9bccf70c
A		 8474 m_freem(m);
8475 return 0;
1c79356b 8476 }
39236c6e 8477
1c79356b
A		 8478 /*
8479 * This message is from user land.
8480 */
39236c6e 8481
1c79356b 8482 /* map satype to proto */
9bccf70c 8483 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
2d21ac55 8484 lck_mtx_unlock(sadb_mutex);
55e303ae 8485 ipseclog((LOG_DEBUG, "key_acquire2: invalid satype is passed.\n"));
9bccf70c 8486 return key_senderror(so, m, EINVAL);
1c79356b 8487 }
39236c6e 8488
9bccf70c
A		 8489 if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
8490 mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
8491 mhp->ext[SADB_EXT_PROPOSAL] == NULL) {
1c79356b 8492 /* error */
2d21ac55 8493 lck_mtx_unlock(sadb_mutex);
55e303ae 8494 ipseclog((LOG_DEBUG, "key_acquire2: invalid message is passed.\n"));
9bccf70c 8495 return key_senderror(so, m, EINVAL);
1c79356b 8496 }
9bccf70c
A		 8497 if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
8498 mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
8499 mhp->extlen[SADB_EXT_PROPOSAL] < sizeof(struct sadb_prop)) {
8500 /* error */
2d21ac55 8501 lck_mtx_unlock(sadb_mutex);
55e303ae 8502 ipseclog((LOG_DEBUG, "key_acquire2: invalid message is passed.\n"));
9bccf70c
A		 8503 return key_senderror(so, m, EINVAL);
8504 }
39236c6e 8505
b0d623f7
A		 8506 src0 = (const struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
8507 dst0 = (const struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
3e170ce0 8508 ipsec_if = key_get_ipsec_if_from_message(mhp, SADB_X_EXT_IPSECIF);
39236c6e 8509
9bccf70c 8510 /* XXX boundary check against sa_len */
b0d623f7 8511 /* cast warnings */
fe8ab488 8512 KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, ipsec_if ? ipsec_if->if_index : 0, &saidx);
39236c6e 8513
1c79356b 8514 /* get a SA index */
9bccf70c
A		 8515 LIST_FOREACH(sah, &sahtree, chain) {
8516 if (sah->state == SADB_SASTATE_DEAD)
8517 continue;
2d21ac55 8518 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_MODE | CMP_REQID))
9bccf70c
A		 8519 break;
8520 }
8521 if (sah != NULL) {
2d21ac55 8522 lck_mtx_unlock(sadb_mutex);
55e303ae 8523 ipseclog((LOG_DEBUG, "key_acquire2: a SA exists already.\n"));
9bccf70c 8524 return key_senderror(so, m, EEXIST);
1c79356b 8525 }
2d21ac55 8526 lck_mtx_unlock(sadb_mutex);
9bccf70c
A		 8527 error = key_acquire(&saidx, NULL);
8528 if (error != 0) {
55e303ae 8529 ipseclog((LOG_DEBUG, "key_acquire2: error %d returned "
39236c6e 8530 "from key_acquire.\n", mhp->msg->sadb_msg_errno));
9bccf70c 8531 return key_senderror(so, m, error);
1c79356b 8532 }
39236c6e 8533
9bccf70c 8534 return key_sendup_mbuf(so, m, KEY_SENDUP_REGISTERED);
1c79356b
A		 8535}
8536
8537/*
8538 * SADB_REGISTER processing.
2d21ac55 8539 * If SATYPE_UNSPEC has been passed as satype, only return sadb_supported.
1c79356b
A		 8540 * receive
8541 * <base>
8542 * from the ikmpd, and register a socket to send PF_KEY messages,
8543 * and send
8544 * <base, supported>
8545 * to KMD by PF_KEY.
8546 * If socket is detached, must free from regnode.
9bccf70c
A		 8547 *
8548 * m will always be freed.
1c79356b 8549 */
9bccf70c 8550static int
6d2010ae 8551key_register(
39236c6e
A		 8552 struct socket *so,
8553 struct mbuf *m,
8554 const struct sadb_msghdr *mhp)
1c79356b 8555{
1c79356b 8556 struct secreg *reg, *newreg = 0;
2d21ac55 8557
1c79356b 8558 /* sanity check */
9bccf70c 8559 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 8560 panic("key_register: NULL pointer is passed.\n");
39236c6e 8561
1c79356b 8562 /* check for invalid register message */
9bccf70c
A		 8563 if (mhp->msg->sadb_msg_satype >= sizeof(regtree)/sizeof(regtree[0]))
8564 return key_senderror(so, m, EINVAL);
39236c6e 8565
2d21ac55 8566 /* When SATYPE_UNSPEC is specified, only return sadb_supported. */
9bccf70c 8567 if (mhp->msg->sadb_msg_satype == SADB_SATYPE_UNSPEC)
1c79356b 8568 goto setmsg;
39236c6e 8569
2d21ac55
A		 8570 /* create regnode */
8571 KMALLOC_WAIT(newreg, struct secreg *, sizeof(*newreg));
39236c6e
A		 8572 if (newreg == NULL) {
8573 ipseclog((LOG_DEBUG, "key_register: No more memory.\n"));
8574 return key_senderror(so, m, ENOBUFS);
8575 }
8576 bzero((caddr_t)newreg, sizeof(*newreg));
8577
2d21ac55 8578 lck_mtx_lock(sadb_mutex);
1c79356b 8579 /* check whether existing or not */
9bccf70c 8580 LIST_FOREACH(reg, &regtree[mhp->msg->sadb_msg_satype], chain) {
1c79356b 8581 if (reg->so == so) {
2d21ac55 8582 lck_mtx_unlock(sadb_mutex);
55e303ae 8583 ipseclog((LOG_DEBUG, "key_register: socket exists already.\n"));
2d21ac55 8584 KFREE(newreg);
9bccf70c 8585 return key_senderror(so, m, EEXIST);
1c79356b
A		 8586 }
8587 }
39236c6e 8588
91447636 8589 socket_lock(so, 1);
1c79356b
A		 8590 newreg->so = so;
8591 ((struct keycb *)sotorawcb(so))->kp_registered++;
91447636 8592 socket_unlock(so, 1);
39236c6e 8593
1c79356b 8594 /* add regnode to regtree. */
9bccf70c 8595 LIST_INSERT_HEAD(&regtree[mhp->msg->sadb_msg_satype], newreg, chain);
2d21ac55 8596 lck_mtx_unlock(sadb_mutex);
39236c6e 8597setmsg:
9bccf70c 8598 {
39236c6e
A		 8599 struct mbuf *n;
8600 struct sadb_msg *newmsg;
8601 struct sadb_supported *sup;
8602 u_int len, alen, elen;
8603 int off;
8604 int i;
8605 struct sadb_alg *alg;
8606
8607 /* create new sadb_msg to reply. */
8608 alen = 0;
8609 for (i = 1; i <= SADB_AALG_MAX; i++) {
8610 if (ah_algorithm_lookup(i))
8611 alen += sizeof(struct sadb_alg);
8612 }
8613 if (alen)
8614 alen += sizeof(struct sadb_supported);
8615 elen = 0;
9bccf70c 8616#if IPSEC_ESP
39236c6e
A		 8617 for (i = 1; i <= SADB_EALG_MAX; i++) {
8618 if (esp_algorithm_lookup(i))
8619 elen += sizeof(struct sadb_alg);
8620 }
8621 if (elen)
8622 elen += sizeof(struct sadb_supported);
1c79356b 8623#endif
39236c6e
A		 8624
8625 len = sizeof(struct sadb_msg) + alen + elen;
8626
8627 if (len > MCLBYTES)
8628 return key_senderror(so, m, ENOBUFS);
8629
8630 MGETHDR(n, M_WAITOK, MT_DATA);
8631 if (n && len > MHLEN) {
8632 MCLGET(n, M_WAITOK);
8633 if ((n->m_flags & M_EXT) == 0) {
8634 m_freem(n);
8635 n = NULL;
8636 }
9bccf70c 8637 }
39236c6e
A		 8638 if (!n)
8639 return key_senderror(so, m, ENOBUFS);
8640
8641 n->m_pkthdr.len = n->m_len = len;
8642 n->m_next = NULL;
8643 off = 0;
8644
8645 m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, caddr_t) + off);
8646 newmsg = mtod(n, struct sadb_msg *);
8647 newmsg->sadb_msg_errno = 0;
8648 newmsg->sadb_msg_len = PFKEY_UNIT64(len);
8649 off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
8650
8651 /* for authentication algorithm */
8652 if (alen) {
8653 sup = (struct sadb_supported *)(void *)(mtod(n, caddr_t) + off);
8654 sup->sadb_supported_len = PFKEY_UNIT64(alen);
8655 sup->sadb_supported_exttype = SADB_EXT_SUPPORTED_AUTH;
8656 off += PFKEY_ALIGN8(sizeof(*sup));
8657
8658 for (i = 1; i <= SADB_AALG_MAX; i++) {
8659 const struct ah_algorithm *aalgo;
8660
8661 aalgo = ah_algorithm_lookup(i);
8662 if (!aalgo)
8663 continue;
8664 alg = (struct sadb_alg *)
316670eb 8665 (void *)(mtod(n, caddr_t) + off);
39236c6e
A		 8666 alg->sadb_alg_id = i;
8667 alg->sadb_alg_ivlen = 0;
8668 alg->sadb_alg_minbits = aalgo->keymin;
8669 alg->sadb_alg_maxbits = aalgo->keymax;
8670 off += PFKEY_ALIGN8(sizeof(*alg));
8671 }
9bccf70c 8672 }
39236c6e 8673
1c79356b 8674#if IPSEC_ESP
39236c6e
A		 8675 /* for encryption algorithm */
8676 if (elen) {
8677 sup = (struct sadb_supported *)(void *)(mtod(n, caddr_t) + off);
8678 sup->sadb_supported_len = PFKEY_UNIT64(elen);
8679 sup->sadb_supported_exttype = SADB_EXT_SUPPORTED_ENCRYPT;
8680 off += PFKEY_ALIGN8(sizeof(*sup));
8681
8682 for (i = 1; i <= SADB_EALG_MAX; i++) {
8683 const struct esp_algorithm *ealgo;
8684
8685 ealgo = esp_algorithm_lookup(i);
8686 if (!ealgo)
8687 continue;
8688 alg = (struct sadb_alg *)
316670eb 8689 (void *)(mtod(n, caddr_t) + off);
39236c6e
A		 8690 alg->sadb_alg_id = i;
8691 if (ealgo && ealgo->ivlen) {
8692 /*
8693 * give NULL to get the value preferred by
8694 * algorithm XXX SADB_X_EXT_DERIV ?
8695 */
8696 alg->sadb_alg_ivlen =
9bccf70c 8697 (*ealgo->ivlen)(ealgo, NULL);
39236c6e
A		 8698 } else
8699 alg->sadb_alg_ivlen = 0;
8700 alg->sadb_alg_minbits = ealgo->keymin;
8701 alg->sadb_alg_maxbits = ealgo->keymax;
8702 off += PFKEY_ALIGN8(sizeof(struct sadb_alg));
8703 }
9bccf70c 8704 }
1c79356b 8705#endif
39236c6e 8706
9bccf70c 8707#if DIGAGNOSTIC
39236c6e
A		 8708 if (off != len)
8709 panic("length assumption failed in key_register");
9bccf70c 8710#endif
39236c6e
A		 8711
8712 m_freem(m);
8713 return key_sendup_mbuf(so, n, KEY_SENDUP_REGISTERED);
9bccf70c 8714 }
1c79356b
A		 8715}
8716
fe8ab488
A		 8717static void
8718key_delete_all_for_socket (struct socket *so)
8719{
8720 struct secashead *sah, *nextsah;
8721 struct secasvar *sav, *nextsav;
8722 u_int stateidx;
8723 u_int state;
8724
8725 for (sah = LIST_FIRST(&sahtree);
8726 sah != NULL;
8727 sah = nextsah) {
8728 nextsah = LIST_NEXT(sah, chain);
8729 for (stateidx = 0; stateidx < _ARRAYLEN(saorder_state_alive); stateidx++) {
8730 state = saorder_state_any[stateidx];
8731 for (sav = LIST_FIRST(&sah->savtree[state]); sav != NULL; sav = nextsav) {
8732 nextsav = LIST_NEXT(sav, chain);
8733 if (sav->flags2 & SADB_X_EXT_SA2_DELETE_ON_DETACH &&
8734 sav->so == so) {
8735 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
8736 key_freesav(sav, KEY_SADB_LOCKED);
8737 }
8738 }
8739 }
8740 }
8741}
8742
1c79356b
A		 8743/*
8744 * free secreg entry registered.
8745 * XXX: I want to do free a socket marked done SADB_RESIGER to socket.
8746 */
8747void
6d2010ae 8748key_freereg(
39236c6e 8749 struct socket *so)
1c79356b
A		 8750{
8751 struct secreg *reg;
8752 int i;
2d21ac55 8753
1c79356b
A		 8754 /* sanity check */
8755 if (so == NULL)
8756 panic("key_freereg: NULL pointer is passed.\n");
39236c6e 8757
1c79356b
A		 8758 /*
8759 * check whether existing or not.
8760 * check all type of SA, because there is a potential that
8761 * one socket is registered to multiple type of SA.
8762 */
2d21ac55 8763 lck_mtx_lock(sadb_mutex);
fe8ab488 8764 key_delete_all_for_socket(so);
1c79356b
A		 8765 for (i = 0; i <= SADB_SATYPE_MAX; i++) {
8766 LIST_FOREACH(reg, &regtree[i], chain) {
8767 if (reg->so == so
39236c6e 8768 && __LIST_CHAINED(reg)) {
1c79356b
A		 8769 LIST_REMOVE(reg, chain);
8770 KFREE(reg);
8771 break;
8772 }
8773 }
8774 }
2d21ac55 8775 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 8776 return;
8777}
8778
8779/*
8780 * SADB_EXPIRE processing
8781 * send
9bccf70c 8782 * <base, SA, SA2, lifetime(C and one of HS), address(SD)>
1c79356b
A		 8783 * to KMD by PF_KEY.
8784 * NOTE: We send only soft lifetime extension.
8785 *
8786 * OUT: 0 : succeed
8787 * others : error number
8788 */
8789static int
6d2010ae 8790key_expire(
39236c6e 8791 struct secasvar *sav)
1c79356b 8792{
1c79356b 8793 int satype;
9bccf70c
A		 8794 struct mbuf *result = NULL, *m;
8795 int len;
8796 int error = -1;
8797 struct sadb_lifetime *lt;
39236c6e 8798
2d21ac55
A		 8799 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
8800
1c79356b
A		 8801 /* sanity check */
8802 if (sav == NULL)
8803 panic("key_expire: NULL pointer is passed.\n");
8804 if (sav->sah == NULL)
8805 panic("key_expire: Why was SA index in SA NULL.\n");
8806 if ((satype = key_proto2satype(sav->sah->saidx.proto)) == 0)
8807 panic("key_expire: invalid proto is passed.\n");
39236c6e 8808
9bccf70c
A		 8809 /* set msg header */
8810 m = key_setsadbmsg(SADB_EXPIRE, 0, satype, sav->seq, 0, sav->refcnt);
8811 if (!m) {
8812 error = ENOBUFS;
8813 goto fail;
1c79356b 8814 }
9bccf70c 8815 result = m;
39236c6e 8816
9bccf70c
A		 8817 /* create SA extension */
8818 m = key_setsadbsa(sav);
8819 if (!m) {
8820 error = ENOBUFS;
8821 goto fail;
8822 }
8823 m_cat(result, m);
39236c6e 8824
1c79356b 8825 /* create SA extension */
55e303ae 8826 m = key_setsadbxsa2(sav->sah->saidx.mode,
39236c6e 8827 sav->replay ? sav->replay->count : 0,
fe8ab488
A		 8828 sav->sah->saidx.reqid,
8829 sav->flags2);
9bccf70c
A		 8830 if (!m) {
8831 error = ENOBUFS;
8832 goto fail;
8833 }
8834 m_cat(result, m);
39236c6e 8835
9bccf70c
A		 8836 /* create lifetime extension (current and soft) */
8837 len = PFKEY_ALIGN8(sizeof(*lt)) * 2;
8838 m = key_alloc_mbuf(len);
8839 if (!m || m->m_next) { /*XXX*/
8840 if (m)
8841 m_freem(m);
8842 error = ENOBUFS;
8843 goto fail;
8844 }
8845 bzero(mtod(m, caddr_t), len);
8846 lt = mtod(m, struct sadb_lifetime *);
8847 lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
8848 lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
8849 lt->sadb_lifetime_allocations = sav->lft_c->sadb_lifetime_allocations;
8850 lt->sadb_lifetime_bytes = sav->lft_c->sadb_lifetime_bytes;
8851 lt->sadb_lifetime_addtime = sav->lft_c->sadb_lifetime_addtime;
8852 lt->sadb_lifetime_usetime = sav->lft_c->sadb_lifetime_usetime;
316670eb 8853 lt = (struct sadb_lifetime *)(void *)(mtod(m, caddr_t) + len / 2);
9bccf70c
A		 8854 bcopy(sav->lft_s, lt, sizeof(*lt));
8855 m_cat(result, m);
39236c6e 8856
1c79356b 8857 /* set sadb_address for source */
9bccf70c 8858 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
39236c6e
A		 8859 (struct sockaddr *)&sav->sah->saidx.src,
8860 FULLMASK, IPSEC_ULPROTO_ANY);
9bccf70c
A		 8861 if (!m) {
8862 error = ENOBUFS;
8863 goto fail;
8864 }
8865 m_cat(result, m);
39236c6e 8866
1c79356b 8867 /* set sadb_address for destination */
9bccf70c 8868 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
39236c6e
A		 8869 (struct sockaddr *)&sav->sah->saidx.dst,
8870 FULLMASK, IPSEC_ULPROTO_ANY);
9bccf70c
A		 8871 if (!m) {
8872 error = ENOBUFS;
8873 goto fail;
8874 }
8875 m_cat(result, m);
39236c6e 8876
9bccf70c
A		 8877 if ((result->m_flags & M_PKTHDR) == 0) {
8878 error = EINVAL;
8879 goto fail;
8880 }
39236c6e 8881
9bccf70c
A		 8882 if (result->m_len < sizeof(struct sadb_msg)) {
8883 result = m_pullup(result, sizeof(struct sadb_msg));
8884 if (result == NULL) {
8885 error = ENOBUFS;
8886 goto fail;
8887 }
8888 }
39236c6e 8889
9bccf70c
A		 8890 result->m_pkthdr.len = 0;
8891 for (m = result; m; m = m->m_next)
8892 result->m_pkthdr.len += m->m_len;
39236c6e 8893
9bccf70c 8894 mtod(result, struct sadb_msg *)->sadb_msg_len =
39236c6e
A		 8895 PFKEY_UNIT64(result->m_pkthdr.len);
8896
9bccf70c 8897 return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
39236c6e
A		 8898
8899fail:
9bccf70c
A		 8900 if (result)
8901 m_freem(result);
1c79356b 8902 return error;
1c79356b
A		 8903}
8904
8905/*
8906 * SADB_FLUSH processing
8907 * receive
8908 * <base>
8909 * from the ikmpd, and free all entries in secastree.
8910 * and send,
8911 * <base>
8912 * to the ikmpd.
8913 * NOTE: to do is only marking SADB_SASTATE_DEAD.
8914 *
9bccf70c 8915 * m will always be freed.
1c79356b 8916 */
9bccf70c 8917static int
6d2010ae 8918key_flush(
39236c6e
A		 8919 struct socket *so,
8920 struct mbuf *m,
8921 const struct sadb_msghdr *mhp)
1c79356b 8922{
9bccf70c 8923 struct sadb_msg *newmsg;
1c79356b
A		 8924 struct secashead *sah, *nextsah;
8925 struct secasvar *sav, *nextsav;
8926 u_int16_t proto;
8927 u_int8_t state;
8928 u_int stateidx;
2d21ac55 8929
1c79356b 8930 /* sanity check */
9bccf70c 8931 if (so == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 8932 panic("key_flush: NULL pointer is passed.\n");
39236c6e 8933
1c79356b 8934 /* map satype to proto */
9bccf70c 8935 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 8936 ipseclog((LOG_DEBUG, "key_flush: invalid satype is passed.\n"));
9bccf70c 8937 return key_senderror(so, m, EINVAL);
1c79356b 8938 }
39236c6e 8939
2d21ac55
A		 8940 lck_mtx_lock(sadb_mutex);
8941
1c79356b
A		 8942 /* no SATYPE specified, i.e. flushing all SA. */
8943 for (sah = LIST_FIRST(&sahtree);
8944 sah != NULL;
8945 sah = nextsah) {
1c79356b 8946 nextsah = LIST_NEXT(sah, chain);
39236c6e 8947
9bccf70c 8948 if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC
39236c6e 8949 && proto != sah->saidx.proto)
1c79356b 8950 continue;
39236c6e 8951
1c79356b
A		 8952 for (stateidx = 0;
8953 stateidx < _ARRAYLEN(saorder_state_alive);
8954 stateidx++) {
1c79356b
A		 8955 state = saorder_state_any[stateidx];
8956 for (sav = LIST_FIRST(&sah->savtree[state]);
8957 sav != NULL;
8958 sav = nextsav) {
39236c6e 8959
1c79356b 8960 nextsav = LIST_NEXT(sav, chain);
39236c6e 8961
1c79356b 8962 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
2d21ac55 8963 key_freesav(sav, KEY_SADB_LOCKED);
1c79356b
A		 8964 }
8965 }
39236c6e 8966
1c79356b
A		 8967 sah->state = SADB_SASTATE_DEAD;
8968 }
2d21ac55
A		 8969 lck_mtx_unlock(sadb_mutex);
8970
9bccf70c
A		 8971 if (m->m_len < sizeof(struct sadb_msg) ||
8972 sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
55e303ae 8973 ipseclog((LOG_DEBUG, "key_flush: No more memory.\n"));
9bccf70c 8974 return key_senderror(so, m, ENOBUFS);
1c79356b 8975 }
39236c6e 8976
9bccf70c
A		 8977 if (m->m_next)
8978 m_freem(m->m_next);
8979 m->m_next = NULL;
8980 m->m_pkthdr.len = m->m_len = sizeof(struct sadb_msg);
8981 newmsg = mtod(m, struct sadb_msg *);
1c79356b 8982 newmsg->sadb_msg_errno = 0;
9bccf70c 8983 newmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
39236c6e 8984
9bccf70c 8985 return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
1c79356b
A		 8986}
8987
8988/*
8989 * SADB_DUMP processing
8990 * dump all entries including status of DEAD in SAD.
8991 * receive
8992 * <base>
8993 * from the ikmpd, and dump all secasvar leaves
8994 * and send,
8995 * <base> .....
8996 * to the ikmpd.
8997 *
9bccf70c 8998 * m will always be freed.
1c79356b 8999 */
39236c6e 9000
2d21ac55
A		 9001struct sav_dump_elem {
9002 struct secasvar *sav;
9003 u_int8_t satype;
9004};
9005
1c79356b 9006static int
6d2010ae 9007key_dump(
39236c6e
A		 9008 struct socket *so,
9009 struct mbuf *m,
9010 const struct sadb_msghdr *mhp)
1c79356b 9011{
1c79356b
A		 9012 struct secashead *sah;
9013 struct secasvar *sav;
2d21ac55 9014 struct sav_dump_elem *savbuf = NULL, *elem_ptr;
1c79356b
A		 9015 u_int16_t proto;
9016 u_int stateidx;
9017 u_int8_t satype;
9018 u_int8_t state;
2d21ac55 9019 int cnt = 0, cnt2, bufcount;
9bccf70c 9020 struct mbuf *n;
2d21ac55 9021 int error = 0;
39236c6e 9022
2d21ac55
A		 9023 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
9024
1c79356b 9025 /* sanity check */
9bccf70c 9026 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 9027 panic("key_dump: NULL pointer is passed.\n");
39236c6e 9028
1c79356b 9029 /* map satype to proto */
9bccf70c 9030 if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
55e303ae 9031 ipseclog((LOG_DEBUG, "key_dump: invalid satype is passed.\n"));
9bccf70c 9032 return key_senderror(so, m, EINVAL);
1c79356b 9033 }
39236c6e 9034
2d21ac55
A		 9035 if ((bufcount = ipsec_sav_count) <= 0) {
9036 error = ENOENT;
9037 goto end;
9038 }
9039 bufcount += 512; /* extra */
9040 KMALLOC_WAIT(savbuf, struct sav_dump_elem*, bufcount * sizeof(struct sav_dump_elem));
9041 if (savbuf == NULL) {
9042 ipseclog((LOG_DEBUG, "key_dump: No more memory.\n"));
9043 error = ENOMEM;
9044 goto end;
9045 }
39236c6e 9046
1c79356b 9047 /* count sav entries to be sent to the userland. */
2d21ac55
A		 9048 lck_mtx_lock(sadb_mutex);
9049 elem_ptr = savbuf;
1c79356b 9050 LIST_FOREACH(sah, &sahtree, chain) {
9bccf70c 9051 if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC
39236c6e 9052 && proto != sah->saidx.proto)
1c79356b 9053 continue;
2d21ac55
A		 9054
9055 /* map proto to satype */
9056 if ((satype = key_proto2satype(sah->saidx.proto)) == 0) {
9057 lck_mtx_unlock(sadb_mutex);
9058 ipseclog((LOG_DEBUG, "key_dump: there was invalid proto in SAD.\n"));
9059 error = EINVAL;
9060 goto end;
9061 }
39236c6e 9062
1c79356b
A		 9063 for (stateidx = 0;
9064 stateidx < _ARRAYLEN(saorder_state_any);
9065 stateidx++) {
1c79356b
A		 9066 state = saorder_state_any[stateidx];
9067 LIST_FOREACH(sav, &sah->savtree[state], chain) {
2d21ac55
A		 9068 if (cnt == bufcount)
9069 break; /* out of buffer space */
9070 elem_ptr->sav = sav;
9071 elem_ptr->satype = satype;
9072 sav->refcnt++;
9073 elem_ptr++;
39236c6e 9074 cnt++;
1c79356b
A		 9075 }
9076 }
9077 }
2d21ac55 9078 lck_mtx_unlock(sadb_mutex);
39236c6e 9079
2d21ac55
A		 9080 if (cnt == 0) {
9081 error = ENOENT;
9082 goto end;
9083 }
39236c6e 9084
1c79356b 9085 /* send this to the userland, one at a time. */
2d21ac55
A		 9086 elem_ptr = savbuf;
9087 cnt2 = cnt;
9088 while (cnt2) {
9089 n = key_setdumpsa(elem_ptr->sav, SADB_DUMP, elem_ptr->satype,
39236c6e 9090 --cnt2, mhp->msg->sadb_msg_pid);
2d21ac55
A		 9091
9092 if (!n) {
9093 error = ENOBUFS;
9094 goto end;
1c79356b 9095 }
39236c6e 9096
2d21ac55
A		 9097 key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
9098 elem_ptr++;
9099 }
39236c6e 9100
2d21ac55
A		 9101end:
9102 if (savbuf) {
9103 if (cnt) {
9104 elem_ptr = savbuf;
9105 lck_mtx_lock(sadb_mutex);
9106 while (cnt--)
9107 key_freesav((elem_ptr++)->sav, KEY_SADB_LOCKED);
9108 lck_mtx_unlock(sadb_mutex);
1c79356b 9109 }
2d21ac55 9110 KFREE(savbuf);
1c79356b 9111 }
39236c6e 9112
2d21ac55
A		 9113 if (error)
9114 return key_senderror(so, m, error);
39236c6e 9115
9bccf70c 9116 m_freem(m);
1c79356b
A		 9117 return 0;
9118}
9119
9120/*
9121 * SADB_X_PROMISC processing
9bccf70c
A		 9122 *
9123 * m will always be freed.
1c79356b 9124 */
9bccf70c 9125static int
6d2010ae 9126key_promisc(
39236c6e
A		 9127 struct socket *so,
9128 struct mbuf *m,
9129 const struct sadb_msghdr *mhp)
1c79356b 9130{
1c79356b 9131 int olen;
2d21ac55 9132
1c79356b 9133 /* sanity check */
9bccf70c 9134 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
1c79356b 9135 panic("key_promisc: NULL pointer is passed.\n");
39236c6e 9136
9bccf70c 9137 olen = PFKEY_UNUNIT64(mhp->msg->sadb_msg_len);
39236c6e 9138
1c79356b 9139 if (olen < sizeof(struct sadb_msg)) {
9bccf70c
A		 9140#if 1
9141 return key_senderror(so, m, EINVAL);
9142#else
9143 m_freem(m);
9144 return 0;
9145#endif
1c79356b
A		 9146 } else if (olen == sizeof(struct sadb_msg)) {
9147 /* enable/disable promisc mode */
9148 struct keycb *kp;
91447636
A		 9149
9150 socket_lock(so, 1);
9bccf70c
A		 9151 if ((kp = (struct keycb *)sotorawcb(so)) == NULL)
9152 return key_senderror(so, m, EINVAL);
9153 mhp->msg->sadb_msg_errno = 0;
9154 switch (mhp->msg->sadb_msg_satype) {
39236c6e
A		 9155 case 0:
9156 case 1:
9157 kp->kp_promisc = mhp->msg->sadb_msg_satype;
9158 break;
9159 default:
9160 socket_unlock(so, 1);
9161 return key_senderror(so, m, EINVAL);
1c79356b 9162 }
91447636 9163 socket_unlock(so, 1);
39236c6e 9164
1c79356b 9165 /* send the original message back to everyone */
9bccf70c
A		 9166 mhp->msg->sadb_msg_errno = 0;
9167 return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
1c79356b
A		 9168 } else {
9169 /* send packet as is */
39236c6e 9170
9bccf70c 9171 m_adj(m, PFKEY_ALIGN8(sizeof(struct sadb_msg)));
39236c6e 9172
9bccf70c
A		 9173 /* TODO: if sadb_msg_seq is specified, send to specific pid */
9174 return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
1c79356b
A		 9175 }
9176}
9177
91447636 9178static int (*key_typesw[])(struct socket *, struct mbuf *,
39236c6e 9179 const struct sadb_msghdr *) = {
9bccf70c
A		 9180 NULL, /* SADB_RESERVED */
9181 key_getspi, /* SADB_GETSPI */
9182 key_update, /* SADB_UPDATE */
9183 key_add, /* SADB_ADD */
9184 key_delete, /* SADB_DELETE */
9185 key_get, /* SADB_GET */
9186 key_acquire2, /* SADB_ACQUIRE */
9187 key_register, /* SADB_REGISTER */
9188 NULL, /* SADB_EXPIRE */
9189 key_flush, /* SADB_FLUSH */
9190 key_dump, /* SADB_DUMP */
9191 key_promisc, /* SADB_X_PROMISC */
9192 NULL, /* SADB_X_PCHANGE */
9193 key_spdadd, /* SADB_X_SPDUPDATE */
9194 key_spdadd, /* SADB_X_SPDADD */
9195 key_spddelete, /* SADB_X_SPDDELETE */
9196 key_spdget, /* SADB_X_SPDGET */
9197 NULL, /* SADB_X_SPDACQUIRE */
9198 key_spddump, /* SADB_X_SPDDUMP */
9199 key_spdflush, /* SADB_X_SPDFLUSH */
9200 key_spdadd, /* SADB_X_SPDSETIDX */
9201 NULL, /* SADB_X_SPDEXPIRE */
9202 key_spddelete2, /* SADB_X_SPDDELETE2 */
b0d623f7 9203 key_getsastat, /* SADB_GETSASTAT */
39236c6e
A		 9204 key_spdenable, /* SADB_X_SPDENABLE */
9205 key_spddisable, /* SADB_X_SPDDISABLE */
3e170ce0 9206 key_migrate, /* SADB_MIGRATE */
9bccf70c 9207};
1c79356b 9208
3e170ce0
A		 9209static void
9210bzero_mbuf(struct mbuf *m)
9211{
9212 struct mbuf *mptr = m;
9213 struct sadb_msg *msg = NULL;
9214 int offset = 0;
9215
9216 if (!mptr) {
9217 return;
9218 }
9219
9220 if (mptr->m_len >= sizeof(struct sadb_msg)) {
9221 msg = mtod(mptr, struct sadb_msg *);
9222 if (msg->sadb_msg_type != SADB_ADD &&
9223 msg->sadb_msg_type != SADB_UPDATE) {
9224 return;
9225 }
9226 offset = sizeof(struct sadb_msg);
9227 }
9228 bzero(mptr->m_data+offset, mptr->m_len-offset);
9229 mptr = mptr->m_next;
9230 while (mptr != NULL) {
9231 bzero(mptr->m_data, mptr->m_len);
9232 mptr = mptr->m_next;
9233 }
9234}
9235
9236static void
ecc0ceb4 9237bzero_keys(const struct sadb_msghdr *mh)
3e170ce0
A		 9238{
9239 int extlen = 0;
9240 int offset = 0;
9241
9242 if (!mh) {
9243 return;
9244 }
9245 offset = sizeof(struct sadb_key);
9246
9247 if (mh->ext[SADB_EXT_KEY_ENCRYPT]) {
9248 struct sadb_key *key = (struct sadb_key*)mh->ext[SADB_EXT_KEY_ENCRYPT];
9249 extlen = key->sadb_key_bits >> 3;
9250
9251 if (mh->extlen[SADB_EXT_KEY_ENCRYPT] >= offset + extlen) {
9252 bzero((uint8_t *)mh->ext[SADB_EXT_KEY_ENCRYPT]+offset, extlen);
9253 } else {
9254 bzero(mh->ext[SADB_EXT_KEY_ENCRYPT], mh->extlen[SADB_EXT_KEY_ENCRYPT]);
9255 }
9256 }
9257 if (mh->ext[SADB_EXT_KEY_AUTH]) {
9258 struct sadb_key *key = (struct sadb_key*)mh->ext[SADB_EXT_KEY_AUTH];
9259 extlen = key->sadb_key_bits >> 3;
9260
9261 if (mh->extlen[SADB_EXT_KEY_AUTH] >= offset + extlen) {
9262 bzero((uint8_t *)mh->ext[SADB_EXT_KEY_AUTH]+offset, extlen);
9263 } else {
9264 bzero(mh->ext[SADB_EXT_KEY_AUTH], mh->extlen[SADB_EXT_KEY_AUTH]);
9265 }
9266 }
9267}
9268
1c79356b
A		 9269/*
9270 * parse sadb_msg buffer to process PFKEYv2,
9271 * and create a data to response if needed.
9272 * I think to be dealed with mbuf directly.
9273 * IN:
9274 * msgp : pointer to pointer to a received buffer pulluped.
9275 * This is rewrited to response.
9276 * so : pointer to socket.
9277 * OUT:
9278 * length for buffer to send to user process.
9279 */
9280int
6d2010ae 9281key_parse(
39236c6e
A		 9282 struct mbuf *m,
9283 struct socket *so)
1c79356b 9284{
9bccf70c
A		 9285 struct sadb_msg *msg;
9286 struct sadb_msghdr mh;
1c79356b
A		 9287 u_int orglen;
9288 int error;
9bccf70c 9289 int target;
3e170ce0
A		 9290 Boolean keyAligned = FALSE;
9291
2d21ac55
A		 9292 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
9293
1c79356b 9294 /* sanity check */
9bccf70c 9295 if (m == NULL || so == NULL)
1c79356b 9296 panic("key_parse: NULL pointer is passed.\n");
39236c6e 9297
9bccf70c 9298#if 0 /*kdebug_sadb assumes msg in linear buffer*/
1c79356b 9299 KEYDEBUG(KEYDEBUG_KEY_DUMP,
39236c6e
A		 9300 ipseclog((LOG_DEBUG, "key_parse: passed sadb_msg\n"));
9301 kdebug_sadb(msg));
9bccf70c 9302#endif
39236c6e 9303
9bccf70c
A		 9304 if (m->m_len < sizeof(struct sadb_msg)) {
9305 m = m_pullup(m, sizeof(struct sadb_msg));
9306 if (!m)
9307 return ENOBUFS;
9308 }
9309 msg = mtod(m, struct sadb_msg *);
1c79356b 9310 orglen = PFKEY_UNUNIT64(msg->sadb_msg_len);
9bccf70c 9311 target = KEY_SENDUP_ONE;
39236c6e 9312
9bccf70c
A		 9313 if ((m->m_flags & M_PKTHDR) == 0 ||
9314 m->m_pkthdr.len != m->m_pkthdr.len) {
55e303ae 9315 ipseclog((LOG_DEBUG, "key_parse: invalid message length.\n"));
2d21ac55 9316 PFKEY_STAT_INCREMENT(pfkeystat.out_invlen);
9bccf70c
A		 9317 error = EINVAL;
9318 goto senderror;
9319 }
39236c6e 9320
1c79356b 9321 if (msg->sadb_msg_version != PF_KEY_V2) {
55e303ae 9322 ipseclog((LOG_DEBUG,
39236c6e
A		 9323 "key_parse: PF_KEY version %u is mismatched.\n",
9324 msg->sadb_msg_version));
2d21ac55 9325 PFKEY_STAT_INCREMENT(pfkeystat.out_invver);
9bccf70c
A		 9326 error = EINVAL;
9327 goto senderror;
1c79356b 9328 }
39236c6e 9329
1c79356b 9330 if (msg->sadb_msg_type > SADB_MAX) {
55e303ae 9331 ipseclog((LOG_DEBUG, "key_parse: invalid type %u is passed.\n",
39236c6e 9332 msg->sadb_msg_type));
2d21ac55 9333 PFKEY_STAT_INCREMENT(pfkeystat.out_invmsgtype);
9bccf70c
A		 9334 error = EINVAL;
9335 goto senderror;
9336 }
39236c6e 9337
9bccf70c
A		 9338 /* for old-fashioned code - should be nuked */
9339 if (m->m_pkthdr.len > MCLBYTES) {
9340 m_freem(m);
9341 return ENOBUFS;
9342 }
9343 if (m->m_next) {
9344 struct mbuf *n;
39236c6e 9345
316670eb 9346 MGETHDR(n, M_WAITOK, MT_DATA);
9bccf70c 9347 if (n && m->m_pkthdr.len > MHLEN) {
316670eb 9348 MCLGET(n, M_WAITOK);
9bccf70c
A		 9349 if ((n->m_flags & M_EXT) == 0) {
9350 m_free(n);
9351 n = NULL;
9352 }
9353 }
9354 if (!n) {
3e170ce0 9355 bzero_mbuf(m);
9bccf70c
A		 9356 m_freem(m);
9357 return ENOBUFS;
9358 }
9359 m_copydata(m, 0, m->m_pkthdr.len, mtod(n, caddr_t));
9360 n->m_pkthdr.len = n->m_len = m->m_pkthdr.len;
9361 n->m_next = NULL;
3e170ce0 9362 bzero_mbuf(m);
9bccf70c
A		 9363 m_freem(m);
9364 m = n;
1c79356b 9365 }
39236c6e 9366
9bccf70c
A		 9367 /* align the mbuf chain so that extensions are in contiguous region. */
9368 error = key_align(m, &mh);
9369 if (error)
9370 return error;
39236c6e 9371
9bccf70c 9372 if (m->m_next) { /*XXX*/
3e170ce0 9373 bzero_mbuf(m);
9bccf70c
A		 9374 m_freem(m);
9375 return ENOBUFS;
1c79356b 9376 }
39236c6e 9377
3e170ce0 9378 keyAligned = TRUE;
9bccf70c 9379 msg = mh.msg;
39236c6e 9380
1c79356b
A		 9381 /* check SA type */
9382 switch (msg->sadb_msg_satype) {
39236c6e
A		 9383 case SADB_SATYPE_UNSPEC:
9384 switch (msg->sadb_msg_type) {
9385 case SADB_GETSPI:
9386 case SADB_UPDATE:
9387 case SADB_ADD:
9388 case SADB_DELETE:
9389 case SADB_GET:
9390 case SADB_ACQUIRE:
9391 case SADB_EXPIRE:
9392 ipseclog((LOG_DEBUG, "key_parse: must specify satype "
9393 "when msg type=%u.\n", msg->sadb_msg_type));
9394 PFKEY_STAT_INCREMENT(pfkeystat.out_invsatype);
9395 error = EINVAL;
9396 goto senderror;
9397 }
9398 break;
9399 case SADB_SATYPE_AH:
9400 case SADB_SATYPE_ESP:
9401 case SADB_X_SATYPE_IPCOMP:
9402 switch (msg->sadb_msg_type) {
9403 case SADB_X_SPDADD:
9404 case SADB_X_SPDDELETE:
9405 case SADB_X_SPDGET:
9406 case SADB_X_SPDDUMP:
9407 case SADB_X_SPDFLUSH:
9408 case SADB_X_SPDSETIDX:
9409 case SADB_X_SPDUPDATE:
9410 case SADB_X_SPDDELETE2:
9411 case SADB_X_SPDENABLE:
9412 case SADB_X_SPDDISABLE:
9413 ipseclog((LOG_DEBUG, "key_parse: illegal satype=%u\n",
9414 msg->sadb_msg_type));
9415 PFKEY_STAT_INCREMENT(pfkeystat.out_invsatype);
9416 error = EINVAL;
9417 goto senderror;
9418 }
9419 break;
9420 case SADB_SATYPE_RSVP:
9421 case SADB_SATYPE_OSPFV2:
9422 case SADB_SATYPE_RIPV2:
9423 case SADB_SATYPE_MIP:
9424 ipseclog((LOG_DEBUG, "key_parse: type %u isn't supported.\n",
9425 msg->sadb_msg_satype));
2d21ac55 9426 PFKEY_STAT_INCREMENT(pfkeystat.out_invsatype);
39236c6e 9427 error = EOPNOTSUPP;
9bccf70c 9428 goto senderror;
39236c6e
A		 9429 case 1: /* XXX: What does it do? */
9430 if (msg->sadb_msg_type == SADB_X_PROMISC)
9431 break;
9432 /*FALLTHROUGH*/
9433 default:
9434 ipseclog((LOG_DEBUG, "key_parse: invalid type %u is passed.\n",
9435 msg->sadb_msg_satype));
2d21ac55 9436 PFKEY_STAT_INCREMENT(pfkeystat.out_invsatype);
9bccf70c
A		 9437 error = EINVAL;
9438 goto senderror;
1c79356b 9439 }
39236c6e 9440
1c79356b 9441 /* check field of upper layer protocol and address family */
9bccf70c 9442 if (mh.ext[SADB_EXT_ADDRESS_SRC] != NULL
39236c6e 9443 && mh.ext[SADB_EXT_ADDRESS_DST] != NULL) {
1c79356b 9444 struct sadb_address *src0, *dst0;
9bccf70c 9445 u_int plen;
39236c6e 9446
9bccf70c
A		 9447 src0 = (struct sadb_address *)(mh.ext[SADB_EXT_ADDRESS_SRC]);
9448 dst0 = (struct sadb_address *)(mh.ext[SADB_EXT_ADDRESS_DST]);
39236c6e 9449
1c79356b
A		 9450 /* check upper layer protocol */
9451 if (src0->sadb_address_proto != dst0->sadb_address_proto) {
55e303ae 9452 ipseclog((LOG_DEBUG, "key_parse: upper layer protocol mismatched.\n"));
2d21ac55 9453 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
9bccf70c
A		 9454 error = EINVAL;
9455 goto senderror;
1c79356b 9456 }
39236c6e 9457
1c79356b 9458 /* check family */
9bccf70c
A		 9459 if (PFKEY_ADDR_SADDR(src0)->sa_family !=
9460 PFKEY_ADDR_SADDR(dst0)->sa_family) {
55e303ae 9461 ipseclog((LOG_DEBUG, "key_parse: address family mismatched.\n"));
2d21ac55 9462 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
9bccf70c
A		 9463 error = EINVAL;
9464 goto senderror;
1c79356b 9465 }
9bccf70c
A		 9466 if (PFKEY_ADDR_SADDR(src0)->sa_len !=
9467 PFKEY_ADDR_SADDR(dst0)->sa_len) {
55e303ae 9468 ipseclog((LOG_DEBUG,
39236c6e 9469 "key_parse: address struct size mismatched.\n"));
2d21ac55 9470 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
9bccf70c
A		 9471 error = EINVAL;
9472 goto senderror;
1c79356b 9473 }
39236c6e 9474
1c79356b 9475 switch (PFKEY_ADDR_SADDR(src0)->sa_family) {
39236c6e
A		 9476 case AF_INET:
9477 if (PFKEY_ADDR_SADDR(src0)->sa_len !=
9478 sizeof(struct sockaddr_in)) {
9479 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
9480 error = EINVAL;
9481 goto senderror;
9482 }
9483 break;
9484 case AF_INET6:
9485 if (PFKEY_ADDR_SADDR(src0)->sa_len !=
9486 sizeof(struct sockaddr_in6)) {
9487 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
9488 error = EINVAL;
9489 goto senderror;
9490 }
9491 break;
9492 default:
9493 ipseclog((LOG_DEBUG,
9494 "key_parse: unsupported address family.\n"));
2d21ac55 9495 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
39236c6e 9496 error = EAFNOSUPPORT;
9bccf70c 9497 goto senderror;
1c79356b 9498 }
39236c6e 9499
9bccf70c 9500 switch (PFKEY_ADDR_SADDR(src0)->sa_family) {
39236c6e
A		 9501 case AF_INET:
9502 plen = sizeof(struct in_addr) << 3;
9503 break;
9504 case AF_INET6:
9505 plen = sizeof(struct in6_addr) << 3;
9506 break;
9507 default:
9508 plen = 0; /*fool gcc*/
9509 break;
1c79356b 9510 }
39236c6e 9511
9bccf70c
A		 9512 /* check max prefix length */
9513 if (src0->sadb_address_prefixlen > plen ||
9514 dst0->sadb_address_prefixlen > plen) {
55e303ae 9515 ipseclog((LOG_DEBUG,
39236c6e 9516 "key_parse: illegal prefixlen.\n"));
2d21ac55 9517 PFKEY_STAT_INCREMENT(pfkeystat.out_invaddr);
9bccf70c
A		 9518 error = EINVAL;
9519 goto senderror;
1c79356b 9520 }
39236c6e 9521
9bccf70c
A		 9522 /*
9523 * prefixlen == 0 is valid because there can be a case when
9524 * all addresses are matched.
9525 */
9526 }
39236c6e 9527
9bccf70c
A		 9528 if (msg->sadb_msg_type >= sizeof(key_typesw)/sizeof(key_typesw[0]) ||
9529 key_typesw[msg->sadb_msg_type] == NULL) {
2d21ac55 9530 PFKEY_STAT_INCREMENT(pfkeystat.out_invmsgtype);
9bccf70c
A		 9531 error = EINVAL;
9532 goto senderror;
9533 }
39236c6e 9534
3e170ce0
A		 9535 error = (*key_typesw[msg->sadb_msg_type])(so, m, &mh);
9536
3e170ce0
A		 9537 return error;
9538
9bccf70c 9539senderror:
3e170ce0
A		 9540 if (keyAligned) {
9541 bzero_keys(&mh);
9542 } else {
9543 bzero_mbuf(m);
9544 }
9bccf70c
A		 9545 msg->sadb_msg_errno = error;
9546 return key_sendup_mbuf(so, m, target);
9547}
1c79356b 9548
9bccf70c 9549static int
6d2010ae 9550key_senderror(
39236c6e
A		 9551 struct socket *so,
9552 struct mbuf *m,
9553 int code)
9bccf70c
A		 9554{
9555 struct sadb_msg *msg;
39236c6e 9556
2d21ac55
A		 9557 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
9558
9bccf70c
A		 9559 if (m->m_len < sizeof(struct sadb_msg))
9560 panic("invalid mbuf passed to key_senderror");
39236c6e 9561
9bccf70c
A		 9562 msg = mtod(m, struct sadb_msg *);
9563 msg->sadb_msg_errno = code;
9564 return key_sendup_mbuf(so, m, KEY_SENDUP_ONE);
1c79356b
A		 9565}
9566
9567/*
9568 * set the pointer to each header into message buffer.
9bccf70c
A		 9569 * m will be freed on error.
9570 * XXX larger-than-MCLBYTES extension?
1c79356b
A		 9571 */
9572static int
6d2010ae 9573key_align(
39236c6e
A		 9574 struct mbuf *m,
9575 struct sadb_msghdr *mhp)
1c79356b 9576{
9bccf70c 9577 struct mbuf *n;
1c79356b 9578 struct sadb_ext *ext;
9bccf70c
A		 9579 size_t off, end;
9580 int extlen;
9581 int toff;
39236c6e 9582
1c79356b 9583 /* sanity check */
9bccf70c 9584 if (m == NULL || mhp == NULL)
1c79356b 9585 panic("key_align: NULL pointer is passed.\n");
9bccf70c
A		 9586 if (m->m_len < sizeof(struct sadb_msg))
9587 panic("invalid mbuf passed to key_align");
39236c6e 9588
1c79356b 9589 /* initialize */
9bccf70c 9590 bzero(mhp, sizeof(*mhp));
39236c6e 9591
9bccf70c
A		 9592 mhp->msg = mtod(m, struct sadb_msg *);
9593 mhp->ext[0] = (struct sadb_ext *)mhp->msg; /*XXX backward compat */
39236c6e 9594
9bccf70c
A		 9595 end = PFKEY_UNUNIT64(mhp->msg->sadb_msg_len);
9596 extlen = end; /*just in case extlen is not updated*/
9597 for (off = sizeof(struct sadb_msg); off < end; off += extlen) {
9598 n = m_pulldown(m, off, sizeof(struct sadb_ext), &toff);
9599 if (!n) {
9600 /* m is already freed */
9601 return ENOBUFS;
9602 }
316670eb 9603 ext = (struct sadb_ext *)(void *)(mtod(n, caddr_t) + toff);
39236c6e 9604
1c79356b
A		 9605 /* set pointer */
9606 switch (ext->sadb_ext_type) {
39236c6e
A		 9607 case SADB_EXT_SA:
9608 case SADB_EXT_ADDRESS_SRC:
9609 case SADB_EXT_ADDRESS_DST:
9610 case SADB_EXT_ADDRESS_PROXY:
9611 case SADB_EXT_LIFETIME_CURRENT:
9612 case SADB_EXT_LIFETIME_HARD:
9613 case SADB_EXT_LIFETIME_SOFT:
9614 case SADB_EXT_KEY_AUTH:
9615 case SADB_EXT_KEY_ENCRYPT:
9616 case SADB_EXT_IDENTITY_SRC:
9617 case SADB_EXT_IDENTITY_DST:
9618 case SADB_EXT_SENSITIVITY:
9619 case SADB_EXT_PROPOSAL:
9620 case SADB_EXT_SUPPORTED_AUTH:
9621 case SADB_EXT_SUPPORTED_ENCRYPT:
9622 case SADB_EXT_SPIRANGE:
9623 case SADB_X_EXT_POLICY:
9624 case SADB_X_EXT_SA2:
9625 case SADB_EXT_SESSION_ID:
9626 case SADB_EXT_SASTAT:
9627 case SADB_X_EXT_IPSECIF:
9628 case SADB_X_EXT_ADDR_RANGE_SRC_START:
9629 case SADB_X_EXT_ADDR_RANGE_SRC_END:
9630 case SADB_X_EXT_ADDR_RANGE_DST_START:
9631 case SADB_X_EXT_ADDR_RANGE_DST_END:
3e170ce0
A		 9632 case SADB_EXT_MIGRATE_ADDRESS_SRC:
9633 case SADB_EXT_MIGRATE_ADDRESS_DST:
9634 case SADB_X_EXT_MIGRATE_IPSECIF:
39236c6e
A		 9635 /* duplicate check */
9636 /*
9637 * XXX Are there duplication payloads of either
9638 * KEY_AUTH or KEY_ENCRYPT ?
9639 */
9640 if (mhp->ext[ext->sadb_ext_type] != NULL) {
9641 ipseclog((LOG_DEBUG,
9642 "key_align: duplicate ext_type %u "
9643 "is passed.\n", ext->sadb_ext_type));
3e170ce0 9644 bzero_mbuf(m);
39236c6e
A		 9645 m_freem(m);
9646 PFKEY_STAT_INCREMENT(pfkeystat.out_dupext);
9647 return EINVAL;
9648 }
9649 break;
9650 default:
55e303ae 9651 ipseclog((LOG_DEBUG,
39236c6e
A		 9652 "key_align: invalid ext_type %u is passed.\n",
9653 ext->sadb_ext_type));
3e170ce0 9654 bzero_mbuf(m);
9bccf70c 9655 m_freem(m);
39236c6e 9656 PFKEY_STAT_INCREMENT(pfkeystat.out_invexttype);
1c79356b 9657 return EINVAL;
1c79356b 9658 }
39236c6e 9659
1c79356b 9660 extlen = PFKEY_UNUNIT64(ext->sadb_ext_len);
39236c6e 9661
9bccf70c 9662 if (key_validate_ext(ext, extlen)) {
3e170ce0 9663 bzero_mbuf(m);
9bccf70c 9664 m_freem(m);
2d21ac55 9665 PFKEY_STAT_INCREMENT(pfkeystat.out_invlen);
9bccf70c
A		 9666 return EINVAL;
9667 }
39236c6e 9668
9bccf70c
A		 9669 n = m_pulldown(m, off, extlen, &toff);
9670 if (!n) {
9671 /* m is already freed */
9672 return ENOBUFS;
9673 }
316670eb 9674 ext = (struct sadb_ext *)(void *)(mtod(n, caddr_t) + toff);
39236c6e 9675
9bccf70c
A		 9676 mhp->ext[ext->sadb_ext_type] = ext;
9677 mhp->extoff[ext->sadb_ext_type] = off;
9678 mhp->extlen[ext->sadb_ext_type] = extlen;
9679 }
39236c6e 9680
9bccf70c 9681 if (off != end) {
3e170ce0 9682 bzero_mbuf(m);
9bccf70c 9683 m_freem(m);
2d21ac55 9684 PFKEY_STAT_INCREMENT(pfkeystat.out_invlen);
9bccf70c
A		 9685 return EINVAL;
9686 }
39236c6e 9687
9bccf70c
A		 9688 return 0;
9689}
9690
9691static int
6d2010ae 9692key_validate_ext(
39236c6e
A		 9693 const struct sadb_ext *ext,
9694 int len)
9bccf70c
A		 9695{
9696 struct sockaddr *sa;
9697 enum { NONE, ADDR } checktype = NONE;
9698 int baselen;
9699 const int sal = offsetof(struct sockaddr, sa_len) + sizeof(sa->sa_len);
39236c6e 9700
9bccf70c
A		 9701 if (len != PFKEY_UNUNIT64(ext->sadb_ext_len))
9702 return EINVAL;
39236c6e 9703
9bccf70c
A		 9704 /* if it does not match minimum/maximum length, bail */
9705 if (ext->sadb_ext_type >= sizeof(minsize) / sizeof(minsize[0]) ||
9706 ext->sadb_ext_type >= sizeof(maxsize) / sizeof(maxsize[0]))
9707 return EINVAL;
9708 if (!minsize[ext->sadb_ext_type] || len < minsize[ext->sadb_ext_type])
9709 return EINVAL;
9710 if (maxsize[ext->sadb_ext_type] && len > maxsize[ext->sadb_ext_type])
9711 return EINVAL;
39236c6e 9712
9bccf70c
A		 9713 /* more checks based on sadb_ext_type XXX need more */
9714 switch (ext->sadb_ext_type) {
39236c6e
A		 9715 case SADB_EXT_ADDRESS_SRC:
9716 case SADB_EXT_ADDRESS_DST:
9717 case SADB_EXT_ADDRESS_PROXY:
9718 case SADB_X_EXT_ADDR_RANGE_SRC_START:
9719 case SADB_X_EXT_ADDR_RANGE_SRC_END:
9720 case SADB_X_EXT_ADDR_RANGE_DST_START:
9721 case SADB_X_EXT_ADDR_RANGE_DST_END:
3e170ce0
A		 9722 case SADB_EXT_MIGRATE_ADDRESS_SRC:
9723 case SADB_EXT_MIGRATE_ADDRESS_DST:
39236c6e 9724 baselen = PFKEY_ALIGN8(sizeof(struct sadb_address));
9bccf70c 9725 checktype = ADDR;
39236c6e
A		 9726 break;
9727 case SADB_EXT_IDENTITY_SRC:
9728 case SADB_EXT_IDENTITY_DST:
9729 if (((struct sadb_ident *)(uintptr_t)(size_t)ext)->
9730 sadb_ident_type == SADB_X_IDENTTYPE_ADDR) {
9731 baselen = PFKEY_ALIGN8(sizeof(struct sadb_ident));
9732 checktype = ADDR;
9733 } else
9734 checktype = NONE;
9735 break;
9736 default:
9bccf70c 9737 checktype = NONE;
39236c6e 9738 break;
9bccf70c 9739 }
39236c6e 9740
9bccf70c 9741 switch (checktype) {
39236c6e
A		 9742 case NONE:
9743 break;
9744 case ADDR:
9745 sa = (struct sockaddr *)((caddr_t)(uintptr_t)ext + baselen);
9746
9747 if (len < baselen + sal)
9748 return EINVAL;
9749 if (baselen + PFKEY_ALIGN8(sa->sa_len) != len)
9750 return EINVAL;
9751 break;
1c79356b 9752 }
39236c6e 9753
1c79356b
A		 9754 return 0;
9755}
9756
1c79356b
A		 9757/*
9758 * XXX: maybe This function is called after INBOUND IPsec processing.
9759 *
9760 * Special check for tunnel-mode packets.
9761 * We must make some checks for consistency between inner and outer IP header.
9762 *
9763 * xxx more checks to be provided
9764 */
9765int
2d21ac55 9766key_checktunnelsanity(
39236c6e
A		 9767 struct secasvar *sav,
9768 __unused u_int family,
9769 __unused caddr_t src,
9770 __unused caddr_t dst)
1c79356b 9771{
39236c6e 9772
1c79356b
A		 9773 /* sanity check */
9774 if (sav->sah == NULL)
9775 panic("sav->sah == NULL at key_checktunnelsanity");
39236c6e 9776
1c79356b 9777 /* XXX: check inner IP header */
39236c6e 9778
1c79356b
A		 9779 return 1;
9780}
9781
1c79356b
A		 9782/* record data transfer on SA, and update timestamps */
9783void
6d2010ae 9784key_sa_recordxfer(
39236c6e
A		 9785 struct secasvar *sav,
9786 struct mbuf *m)
1c79356b 9787{
39236c6e 9788
2d21ac55 9789
1c79356b
A		 9790 if (!sav)
9791 panic("key_sa_recordxfer called with sav == NULL");
9792 if (!m)
9793 panic("key_sa_recordxfer called with m == NULL");
9794 if (!sav->lft_c)
9795 return;
39236c6e 9796
2d21ac55 9797 lck_mtx_lock(sadb_mutex);
1c79356b
A		 9798 /*
9799 * XXX Currently, there is a difference of bytes size
9800 * between inbound and outbound processing.
9801 */
9802 sav->lft_c->sadb_lifetime_bytes += m->m_pkthdr.len;
9803 /* to check bytes lifetime is done in key_timehandler(). */
39236c6e 9804
1c79356b
A		 9805 /*
9806 * We use the number of packets as the unit of
9807 * sadb_lifetime_allocations. We increment the variable
9808 * whenever {esp,ah}_{in,out}put is called.
9809 */
9810 sav->lft_c->sadb_lifetime_allocations++;
9811 /* XXX check for expires? */
39236c6e 9812
1c79356b
A		 9813 /*
9814 * NOTE: We record CURRENT sadb_lifetime_usetime by using wall clock,
9815 * in seconds. HARD and SOFT lifetime are measured by the time
9816 * difference (again in seconds) from sadb_lifetime_usetime.
9817 *
9818 * usetime
9819 * v expire expire
9820 * -----+-----+--------+---> t
9821 * <--------------> HARD
9822 * <-----> SOFT
9823 */
9824 {
39236c6e
A		 9825 struct timeval tv;
9826 microtime(&tv);
9827 sav->lft_c->sadb_lifetime_usetime = tv.tv_sec;
9828 /* XXX check for expires? */
1c79356b 9829 }
2d21ac55
A		 9830 lck_mtx_unlock(sadb_mutex);
9831
1c79356b
A		 9832 return;
9833}
9834
9835/* dumb version */
9836void
6d2010ae 9837key_sa_routechange(
39236c6e 9838 struct sockaddr *dst)
1c79356b
A		 9839{
9840 struct secashead *sah;
9841 struct route *ro;
2d21ac55 9842
91447636 9843 lck_mtx_lock(sadb_mutex);
1c79356b
A		 9844 LIST_FOREACH(sah, &sahtree, chain) {
9845 ro = &sah->sa_route;
9846 if (ro->ro_rt && dst->sa_len == ro->ro_dst.sa_len
39236c6e
A		 9847 && bcmp(dst, &ro->ro_dst, dst->sa_len) == 0) {
9848 ROUTE_RELEASE(ro);
1c79356b
A		 9849 }
9850 }
91447636 9851 lck_mtx_unlock(sadb_mutex);
39236c6e 9852
1c79356b
A		 9853 return;
9854}
9855
316670eb 9856void
6d2010ae 9857key_sa_chgstate(
39236c6e
A		 9858 struct secasvar *sav,
9859 u_int8_t state)
1c79356b 9860{
39236c6e 9861
1c79356b
A		 9862 if (sav == NULL)
9863 panic("key_sa_chgstate called with sav == NULL");
39236c6e 9864
1c79356b
A		 9865 if (sav->state == state)
9866 return;
39236c6e 9867
2d21ac55 9868 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_OWNED);
39236c6e 9869
1c79356b
A		 9870 if (__LIST_CHAINED(sav))
9871 LIST_REMOVE(sav, chain);
39236c6e 9872
1c79356b
A		 9873 sav->state = state;
9874 LIST_INSERT_HEAD(&sav->sah->savtree[state], sav, chain);
2d21ac55 9875
1c79356b
A		 9876}
9877
9bccf70c 9878void
6d2010ae 9879key_sa_stir_iv(
39236c6e 9880 struct secasvar *sav)
1c79356b 9881{
2d21ac55 9882 lck_mtx_lock(sadb_mutex);
9bccf70c
A		 9883 if (!sav->iv)
9884 panic("key_sa_stir_iv called with sav == NULL");
9885 key_randomfill(sav->iv, sav->ivlen);
2d21ac55 9886 lck_mtx_unlock(sadb_mutex);
1c79356b
A		 9887}
9888
9bccf70c
A		 9889/* XXX too much? */
9890static struct mbuf *
6d2010ae 9891key_alloc_mbuf(
39236c6e 9892 int l)
1c79356b 9893{
9bccf70c
A		 9894 struct mbuf *m = NULL, *n;
9895 int len, t;
39236c6e 9896
9bccf70c
A		 9897 len = l;
9898 while (len > 0) {
9899 MGET(n, M_DONTWAIT, MT_DATA);
9900 if (n && len > MLEN)
9901 MCLGET(n, M_DONTWAIT);
9902 if (!n) {
9903 m_freem(m);
9904 return NULL;
9905 }
39236c6e 9906
9bccf70c
A		 9907 n->m_next = NULL;
9908 n->m_len = 0;
9909 n->m_len = M_TRAILINGSPACE(n);
9910 /* use the bottom of mbuf, hoping we can prepend afterwards */
9911 if (n->m_len > len) {
9912 t = (n->m_len - len) & ~(sizeof(long) - 1);
9913 n->m_data += t;
9914 n->m_len = len;
9915 }
39236c6e 9916
9bccf70c 9917 len -= n->m_len;
39236c6e 9918
9bccf70c
A		 9919 if (m)
9920 m_cat(m, n);
9921 else
9922 m = n;
1c79356b 9923 }
39236c6e 9924
9bccf70c 9925 return m;
1c79356b 9926}
593a1d5f 9927
b0d623f7
A		 9928static struct mbuf *
9929key_setdumpsastats (u_int32_t dir,
39236c6e
A		 9930 struct sastat *stats,
9931 u_int32_t max_stats,
9932 u_int64_t session_ids[],
9933 u_int32_t seq,
9934 u_int32_t pid)
b0d623f7 9935{
39236c6e
A		 9936 struct mbuf *result = NULL, *m = NULL;
9937
9938 m = key_setsadbmsg(SADB_GETSASTAT, 0, 0, seq, pid, 0);
9939 if (!m) {
9940 goto fail;
b0d623f7 9941 }
39236c6e
A		 9942 result = m;
9943
b0d623f7
A		 9944 m = key_setsadbsession_id(session_ids);
9945 if (!m) {
39236c6e 9946 goto fail;
b0d623f7 9947 }
39236c6e
A		 9948 m_cat(result, m);
9949
b0d623f7 9950 m = key_setsadbsastat(dir,
39236c6e
A		 9951 stats,
9952 max_stats);
b0d623f7 9953 if (!m) {
39236c6e 9954 goto fail;
b0d623f7 9955 }
39236c6e
A		 9956 m_cat(result, m);
9957
9958 if ((result->m_flags & M_PKTHDR) == 0) {
b0d623f7 9959 goto fail;
39236c6e
A		 9960 }
9961
9962 if (result->m_len < sizeof(struct sadb_msg)) {
9963 result = m_pullup(result, sizeof(struct sadb_msg));
b0d623f7
A		 9964 if (result == NULL) {
9965 goto fail;
9966 }
593a1d5f 9967 }
39236c6e
A		 9968
9969 result->m_pkthdr.len = 0;
9970 for (m = result; m; m = m->m_next) {
9971 result->m_pkthdr.len += m->m_len;
9972 }
9973
9974 mtod(result, struct sadb_msg *)->sadb_msg_len =
9975 PFKEY_UNIT64(result->m_pkthdr.len);
9976
9977 return result;
9978
9979fail:
b0d623f7 9980 if (result) {
39236c6e 9981 m_freem(result);
593a1d5f 9982 }
39236c6e 9983 return NULL;
593a1d5f
A		 9984}
9985
9986/*
b0d623f7
A		 9987 * SADB_GETSASTAT processing
9988 * dump all stats for matching entries in SAD.
9989 *
9990 * m will always be freed.
593a1d5f 9991 */
39236c6e 9992
b0d623f7
A		 9993static int
9994key_getsastat (struct socket *so,
39236c6e
A		 9995 struct mbuf *m,
9996 const struct sadb_msghdr *mhp)
b0d623f7
A		 9997{
9998 struct sadb_session_id *session_id;
9999 u_int32_t bufsize, arg_count, res_count;
10000 struct sadb_sastat *sa_stats_arg;
10001 struct sastat *sa_stats_sav = NULL;
10002 struct mbuf *n;
10003 int error = 0;
39236c6e 10004
b0d623f7
A		 10005 /* sanity check */
10006 if (so == NULL || m == NULL || mhp == NULL || mhp->msg == NULL)
39236c6e
A		 10007 panic("%s: NULL pointer is passed.\n", __FUNCTION__);
10008
10009 if (mhp->ext[SADB_EXT_SESSION_ID] == NULL) {
10010 printf("%s: invalid message is passed. missing session-id.\n", __FUNCTION__);
b0d623f7 10011 return key_senderror(so, m, EINVAL);
39236c6e 10012 }
b0d623f7 10013 if (mhp->extlen[SADB_EXT_SESSION_ID] < sizeof(struct sadb_session_id)) {
39236c6e 10014 printf("%s: invalid message is passed. short session-id.\n", __FUNCTION__);
b0d623f7 10015 return key_senderror(so, m, EINVAL);
39236c6e 10016 }
b0d623f7 10017 if (mhp->ext[SADB_EXT_SASTAT] == NULL) {
39236c6e 10018 printf("%s: invalid message is passed. missing stat args.\n", __FUNCTION__);
b0d623f7 10019 return key_senderror(so, m, EINVAL);
39236c6e
A		 10020 }
10021 if (mhp->extlen[SADB_EXT_SASTAT] < sizeof(*sa_stats_arg)) {
10022 printf("%s: invalid message is passed. short stat args.\n", __FUNCTION__);
b0d623f7 10023 return key_senderror(so, m, EINVAL);
39236c6e
A		 10024 }
10025
b0d623f7 10026 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
39236c6e 10027
b0d623f7
A		 10028 // exit early if there are no active SAs
10029 if (ipsec_sav_count <= 0) {
39236c6e 10030 printf("%s: No active SAs.\n", __FUNCTION__);
b0d623f7
A		 10031 error = ENOENT;
10032 goto end;
593a1d5f 10033 }
b0d623f7 10034 bufsize = (ipsec_sav_count + 1) * sizeof(*sa_stats_sav);
39236c6e 10035
b0d623f7
A		 10036 KMALLOC_WAIT(sa_stats_sav, __typeof__(sa_stats_sav), bufsize);
10037 if (sa_stats_sav == NULL) {
39236c6e 10038 printf("%s: No more memory.\n", __FUNCTION__);
b0d623f7
A		 10039 error = ENOMEM;
10040 goto end;
593a1d5f 10041 }
b0d623f7 10042 bzero(sa_stats_sav, bufsize);
39236c6e
A		 10043
10044 sa_stats_arg = (__typeof__(sa_stats_arg))
10045 (void *)mhp->ext[SADB_EXT_SASTAT];
b0d623f7
A		 10046 arg_count = sa_stats_arg->sadb_sastat_list_len;
10047 // exit early if there are no requested SAs
10048 if (arg_count == 0) {
39236c6e 10049 printf("%s: No SAs requested.\n", __FUNCTION__);
b0d623f7
A		 10050 error = ENOENT;
10051 goto end;
593a1d5f 10052 }
b0d623f7 10053 res_count = 0;
39236c6e 10054
b0d623f7 10055 if (key_getsastatbyspi((struct sastat *)(sa_stats_arg + 1),
39236c6e
A		 10056 arg_count,
10057 sa_stats_sav,
10058 &res_count)) {
10059 printf("%s: Error finding SAs.\n", __FUNCTION__);
b0d623f7
A		 10060 error = ENOENT;
10061 goto end;
593a1d5f 10062 }
b0d623f7 10063 if (!res_count) {
39236c6e 10064 printf("%s: No SAs found.\n", __FUNCTION__);
b0d623f7
A		 10065 error = ENOENT;
10066 goto end;
593a1d5f 10067 }
39236c6e 10068
316670eb 10069 session_id = (__typeof__(session_id))
39236c6e
A		 10070 (void *)mhp->ext[SADB_EXT_SESSION_ID];
10071
b0d623f7
A		 10072 /* send this to the userland. */
10073 n = key_setdumpsastats(sa_stats_arg->sadb_sastat_dir,
39236c6e
A		 10074 sa_stats_sav,
10075 res_count,
10076 session_id->sadb_session_id_v,
10077 mhp->msg->sadb_msg_seq,
10078 mhp->msg->sadb_msg_pid);
10079 if (!n) {
10080 printf("%s: No bufs to dump stats.\n", __FUNCTION__);
b0d623f7
A		 10081 error = ENOBUFS;
10082 goto end;
593a1d5f 10083 }
39236c6e
A		 10084
10085 key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
b0d623f7
A		 10086end:
10087 if (sa_stats_sav) {
10088 KFREE(sa_stats_sav);
593a1d5f 10089 }
39236c6e 10090
b0d623f7
A		 10091 if (error)
10092 return key_senderror(so, m, error);
39236c6e 10093
b0d623f7 10094 m_freem(m);
593a1d5f
A		 10095 return 0;
10096}
10097
10098static void
b0d623f7 10099key_update_natt_keepalive_timestamp (struct secasvar *sav_sent,
39236c6e 10100 struct secasvar *sav_update)
593a1d5f 10101{
b0d623f7 10102 struct secasindex saidx_swap_sent_addr;
39236c6e 10103
b0d623f7
A		 10104 // exit early if two SAs are identical, or if sav_update is current
10105 if (sav_sent == sav_update ||
10106 sav_update->natt_last_activity == natt_now) {
10107 return;
10108 }
39236c6e 10109
b0d623f7 10110 // assuming that (sav_update->remote_ike_port != 0 && (esp_udp_encap_port & 0xFFFF) != 0)
39236c6e 10111
b0d623f7
A		 10112 bzero(&saidx_swap_sent_addr, sizeof(saidx_swap_sent_addr));
10113 memcpy(&saidx_swap_sent_addr.src, &sav_sent->sah->saidx.dst, sizeof(saidx_swap_sent_addr.src));
10114 memcpy(&saidx_swap_sent_addr.dst, &sav_sent->sah->saidx.src, sizeof(saidx_swap_sent_addr.dst));
10115 saidx_swap_sent_addr.proto = sav_sent->sah->saidx.proto;
10116 saidx_swap_sent_addr.mode = sav_sent->sah->saidx.mode;
10117 // we ignore reqid for split-tunnel setups
39236c6e 10118
b0d623f7
A		 10119 if (key_cmpsaidx(&sav_sent->sah->saidx, &sav_update->sah->saidx, CMP_MODE | CMP_PORT) ||
10120 key_cmpsaidx(&saidx_swap_sent_addr, &sav_update->sah->saidx, CMP_MODE | CMP_PORT)) {
10121 sav_update->natt_last_activity = natt_now;
593a1d5f 10122 }
593a1d5f 10123}
39236c6e
A		 10124
10125static int
10126key_send_delsp (struct secpolicy *sp)
10127{
10128 struct mbuf *result = NULL, *m;
10129
10130 if (sp == NULL)
10131 goto fail;
10132
10133 /* set msg header */
10134 m = key_setsadbmsg(SADB_X_SPDDELETE, 0, 0, 0, 0, 0);
10135 if (!m) {
10136 goto fail;
10137 }
10138 result = m;
10139
10140 /* set sadb_address(es) for source */
10141 if (sp->spidx.src_range.start.ss_len > 0) {
10142 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_SRC_START,
10143 (struct sockaddr *)&sp->spidx.src_range.start, sp->spidx.prefs,
10144 sp->spidx.ul_proto);
10145 if (!m)
10146 goto fail;
10147 m_cat(result, m);
10148
10149 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_SRC_END,
10150 (struct sockaddr *)&sp->spidx.src_range.end, sp->spidx.prefs,
10151 sp->spidx.ul_proto);
10152 if (!m)
10153 goto fail;
10154 m_cat(result, m);
10155 } else {
10156 m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
10157 (struct sockaddr *)&sp->spidx.src, sp->spidx.prefs,
10158 sp->spidx.ul_proto);
10159 if (!m)
10160 goto fail;
10161 m_cat(result, m);
10162 }
10163
10164 /* set sadb_address(es) for destination */
10165 if (sp->spidx.dst_range.start.ss_len > 0) {
10166 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_DST_START,
10167 (struct sockaddr *)&sp->spidx.dst_range.start, sp->spidx.prefd,
10168 sp->spidx.ul_proto);
10169 if (!m)
10170 goto fail;
10171 m_cat(result, m);
10172
10173 m = key_setsadbaddr(SADB_X_EXT_ADDR_RANGE_DST_END,
10174 (struct sockaddr *)&sp->spidx.dst_range.end, sp->spidx.prefd,
10175 sp->spidx.ul_proto);
10176 if (!m)
10177 goto fail;
10178 m_cat(result, m);
10179 } else {
10180 m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
10181 (struct sockaddr *)&sp->spidx.dst, sp->spidx.prefd,
10182 sp->spidx.ul_proto);
10183 if (!m)
10184 goto fail;
10185 m_cat(result, m);
10186 }
10187
10188 /* set secpolicy */
10189 m = key_sp2msg(sp);
10190 if (!m) {
10191 goto fail;
10192 }
10193 m_cat(result, m);
10194
10195 if ((result->m_flags & M_PKTHDR) == 0) {
10196 goto fail;
10197 }
10198
10199 if (result->m_len < sizeof(struct sadb_msg)) {
10200 result = m_pullup(result, sizeof(struct sadb_msg));
10201 if (result == NULL) {
10202 goto fail;
10203 }
10204 }
10205
10206 result->m_pkthdr.len = 0;
10207 for (m = result; m; m = m->m_next)
10208 result->m_pkthdr.len += m->m_len;
10209
10210 mtod(result, struct sadb_msg *)->sadb_msg_len = PFKEY_UNIT64(result->m_pkthdr.len);
10211
10212 return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
10213
10214fail:
10215 if (result)
10216 m_free(result);
10217 return -1;
10218}
10219
10220void
10221key_delsp_for_ipsec_if (ifnet_t ipsec_if)
10222{
fe8ab488
A		 10223 struct secashead *sah;
10224 struct secasvar *sav, *nextsav;
10225 u_int stateidx;
10226 u_int state;
39236c6e
A		 10227 struct secpolicy *sp, *nextsp;
10228 int dir;
10229
10230 if (ipsec_if == NULL)
10231 return;
10232
10233 lck_mtx_assert(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);
10234
10235 lck_mtx_lock(sadb_mutex);
10236
10237 for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
10238 for (sp = LIST_FIRST(&sptree[dir]);
10239 sp != NULL;
10240 sp = nextsp) {
10241
10242 nextsp = LIST_NEXT(sp, chain);
10243
10244 if (sp->ipsec_if == ipsec_if) {
10245 ifnet_release(sp->ipsec_if);
10246 sp->ipsec_if = NULL;
10247
10248 key_send_delsp(sp);
10249
10250 sp->state = IPSEC_SPSTATE_DEAD;
10251 key_freesp(sp, KEY_SADB_LOCKED);
10252 }
10253 }
10254 }
10255
fe8ab488
A		 10256 LIST_FOREACH(sah, &sahtree, chain) {
10257 if (sah->ipsec_if == ipsec_if) {
10258 /* This SAH is linked to the IPSec interface. It now needs to close. */
10259 ifnet_release(sah->ipsec_if);
10260 sah->ipsec_if = NULL;
10261
10262 for (stateidx = 0; stateidx < _ARRAYLEN(saorder_state_alive); stateidx++) {
10263 state = saorder_state_any[stateidx];
10264 for (sav = LIST_FIRST(&sah->savtree[state]); sav != NULL; sav = nextsav) {
10265 nextsav = LIST_NEXT(sav, chain);
10266
10267 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
10268 key_freesav(sav, KEY_SADB_LOCKED);
10269 }
10270 }
10271
10272 sah->state = SADB_SASTATE_DEAD;
10273 }
10274 }
10275
39236c6e 10276 lck_mtx_unlock(sadb_mutex);
fe8ab488
A		 10277}
10278
10279__private_extern__ u_int32_t
10280key_fill_offload_frames_for_savs (ifnet_t ifp,
3e170ce0
A		 10281 struct ifnet_keepalive_offload_frame *frames_array,
10282 u_int32_t frames_array_count,
10283 size_t frame_data_offset)
fe8ab488
A		 10284{
10285 struct secashead *sah = NULL;
10286 struct secasvar *sav = NULL;
3e170ce0 10287 struct ifnet_keepalive_offload_frame *frame = frames_array;
fe8ab488
A		 10288 u_int32_t frame_index = 0;
10289
10290 if (frame == NULL || frames_array_count == 0) {
10291 return (frame_index);
10292 }
10293
10294 lck_mtx_lock(sadb_mutex);
10295 LIST_FOREACH(sah, &sahtree, chain) {
10296 LIST_FOREACH(sav, &sah->savtree[SADB_SASTATE_MATURE], chain) {
10297 if (ipsec_fill_offload_frame(ifp, sav, frame, frame_data_offset)) {
10298 frame_index++;
10299 if (frame_index >= frames_array_count) {
10300 lck_mtx_unlock(sadb_mutex);
10301 return (frame_index);
10302 }
10303 frame = &(frames_array[frame_index]);
10304 }
10305 }
10306 }
10307 lck_mtx_unlock(sadb_mutex);
10308
10309 return (frame_index);
39236c6e 10310}
mirror of XNU