xref: /freebsd/sys/netipsec/ipsec.c (revision 5bb3134a8c21cb87b30e135ef168483f0333dabb)
1 /*	$FreeBSD$	*/
2 /*	$KAME: ipsec.c,v 1.103 2001/05/24 07:14:18 sakane Exp $	*/
3 
4 /*-
5  * SPDX-License-Identifier: BSD-3-Clause
6  *
7  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the project nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 /*
36  * IPsec controller part.
37  */
38 
39 #include "opt_inet.h"
40 #include "opt_inet6.h"
41 #include "opt_ipsec.h"
42 
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/malloc.h>
46 #include <sys/mbuf.h>
47 #include <sys/domain.h>
48 #include <sys/priv.h>
49 #include <sys/protosw.h>
50 #include <sys/socket.h>
51 #include <sys/socketvar.h>
52 #include <sys/errno.h>
53 #include <sys/hhook.h>
54 #include <sys/time.h>
55 #include <sys/kernel.h>
56 #include <sys/syslog.h>
57 #include <sys/sysctl.h>
58 #include <sys/proc.h>
59 
60 #include <net/if.h>
61 #include <net/if_enc.h>
62 #include <net/if_var.h>
63 #include <net/vnet.h>
64 
65 #include <netinet/in.h>
66 #include <netinet/in_systm.h>
67 #include <netinet/ip.h>
68 #include <netinet/ip_var.h>
69 #include <netinet/in_var.h>
70 #include <netinet/udp.h>
71 #include <netinet/udp_var.h>
72 #include <netinet/tcp.h>
73 #include <netinet/udp.h>
74 
75 #include <netinet/ip6.h>
76 #ifdef INET6
77 #include <netinet6/ip6_var.h>
78 #endif
79 #include <netinet/in_pcb.h>
80 #ifdef INET6
81 #include <netinet/icmp6.h>
82 #endif
83 
84 #include <sys/types.h>
85 #include <netipsec/ipsec.h>
86 #ifdef INET6
87 #include <netipsec/ipsec6.h>
88 #endif
89 #include <netipsec/ah_var.h>
90 #include <netipsec/esp_var.h>
91 #include <netipsec/ipcomp.h>		/*XXX*/
92 #include <netipsec/ipcomp_var.h>
93 #include <netipsec/ipsec_support.h>
94 
95 #include <netipsec/key.h>
96 #include <netipsec/keydb.h>
97 #include <netipsec/key_debug.h>
98 
99 #include <netipsec/xform.h>
100 
101 #include <machine/in_cksum.h>
102 
103 #include <opencrypto/cryptodev.h>
104 
105 /* NB: name changed so netstat doesn't use it. */
106 VNET_PCPUSTAT_DEFINE(struct ipsecstat, ipsec4stat);
107 VNET_PCPUSTAT_SYSINIT(ipsec4stat);
108 
109 #ifdef VIMAGE
110 VNET_PCPUSTAT_SYSUNINIT(ipsec4stat);
111 #endif /* VIMAGE */
112 
113 /* DF bit on encap. 0: clear 1: set 2: copy */
114 VNET_DEFINE(int, ip4_ipsec_dfbit) = 0;
115 VNET_DEFINE(int, ip4_ipsec_min_pmtu) = 576;
116 VNET_DEFINE(int, ip4_esp_trans_deflev) = IPSEC_LEVEL_USE;
117 VNET_DEFINE(int, ip4_esp_net_deflev) = IPSEC_LEVEL_USE;
118 VNET_DEFINE(int, ip4_ah_trans_deflev) = IPSEC_LEVEL_USE;
119 VNET_DEFINE(int, ip4_ah_net_deflev) = IPSEC_LEVEL_USE;
120 /* ECN ignore(-1)/forbidden(0)/allowed(1) */
121 VNET_DEFINE(int, ip4_ipsec_ecn) = 0;
122 
123 VNET_DEFINE_STATIC(int, ip4_filtertunnel) = 0;
124 #define	V_ip4_filtertunnel VNET(ip4_filtertunnel)
125 VNET_DEFINE_STATIC(int, check_policy_history) = 0;
126 #define	V_check_policy_history	VNET(check_policy_history)
127 VNET_DEFINE_STATIC(struct secpolicy *, def_policy) = NULL;
128 #define	V_def_policy	VNET(def_policy)
129 static int
130 sysctl_def_policy(SYSCTL_HANDLER_ARGS)
131 {
132 	int error, value;
133 
134 	value = V_def_policy->policy;
135 	error = sysctl_handle_int(oidp, &value, 0, req);
136 	if (error == 0) {
137 		if (value != IPSEC_POLICY_DISCARD &&
138 		    value != IPSEC_POLICY_NONE)
139 			return (EINVAL);
140 		V_def_policy->policy = value;
141 	}
142 	return (error);
143 }
144 
145 /*
146  * Crypto support requirements:
147  *
148  *  1	require hardware support
149  * -1	require software support
150  *  0	take anything
151  */
152 VNET_DEFINE(int, crypto_support) = CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE;
153 
154 /*
155  * Use asynchronous mode to parallelize crypto jobs:
156  *
157  *  0 - disabled
158  *  1 - enabled
159  */
160 VNET_DEFINE(int, async_crypto) = 0;
161 
162 /*
163  * TCP/UDP checksum handling policy for transport mode NAT-T (RFC3948)
164  *
165  * 0 - auto: incrementally recompute, when checksum delta is known;
166  *     if checksum delta isn't known, reset checksum to zero for UDP,
167  *     and mark csum_flags as valid for TCP.
168  * 1 - fully recompute TCP/UDP checksum.
169  */
170 VNET_DEFINE(int, natt_cksum_policy) = 0;
171 
172 FEATURE(ipsec, "Internet Protocol Security (IPsec)");
173 FEATURE(ipsec_natt, "UDP Encapsulation of IPsec ESP Packets ('NAT-T')");
174 
175 SYSCTL_DECL(_net_inet_ipsec);
176 
177 /* net.inet.ipsec */
178 SYSCTL_PROC(_net_inet_ipsec, IPSECCTL_DEF_POLICY, def_policy,
179     CTLTYPE_INT | CTLFLAG_VNET | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
180     0, 0, sysctl_def_policy, "I",
181     "IPsec default policy.");
182 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev,
183 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_esp_trans_deflev), 0,
184 	"Default ESP transport mode level");
185 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_ESP_NETLEV, esp_net_deflev,
186 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_esp_net_deflev), 0,
187 	"Default ESP tunnel mode level.");
188 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_AH_TRANSLEV, ah_trans_deflev,
189 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ah_trans_deflev), 0,
190 	"AH transfer mode default level.");
191 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_AH_NETLEV, ah_net_deflev,
192 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ah_net_deflev), 0,
193 	"AH tunnel mode default level.");
194 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_AH_CLEARTOS, ah_cleartos,
195 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ah_cleartos), 0,
196 	"If set, clear type-of-service field when doing AH computation.");
197 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DFBIT, dfbit,
198 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ipsec_dfbit), 0,
199 	"Do not fragment bit on encap.");
200 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_MIN_PMTU, min_pmtu,
201 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ipsec_min_pmtu), 0,
202 	"Lowest acceptable PMTU value.");
203 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_ECN, ecn,
204 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ipsec_ecn), 0,
205 	"Explicit Congestion Notification handling.");
206 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, crypto_support,
207 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(crypto_support), 0,
208 	"Crypto driver selection.");
209 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, async_crypto,
210 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(async_crypto), 0,
211 	"Use asynchronous mode to parallelize crypto jobs.");
212 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, check_policy_history,
213 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(check_policy_history), 0,
214 	"Use strict check of inbound packets to security policy compliance.");
215 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, natt_cksum_policy,
216 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(natt_cksum_policy), 0,
217 	"Method to fix TCP/UDP checksum for transport mode IPsec after NAT.");
218 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, filtertunnel,
219 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_filtertunnel), 0,
220 	"If set, filter packets from an IPsec tunnel.");
221 SYSCTL_VNET_PCPUSTAT(_net_inet_ipsec, OID_AUTO, ipsecstats, struct ipsecstat,
222     ipsec4stat, "IPsec IPv4 statistics.");
223 
224 #ifdef REGRESSION
225 /*
226  * When set to 1, IPsec will send packets with the same sequence number.
227  * This allows to verify if the other side has proper replay attacks detection.
228  */
229 VNET_DEFINE(int, ipsec_replay) = 0;
230 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, test_replay,
231 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ipsec_replay), 0,
232 	"Emulate replay attack");
233 /*
234  * When set 1, IPsec will send packets with corrupted HMAC.
235  * This allows to verify if the other side properly detects modified packets.
236  */
237 VNET_DEFINE(int, ipsec_integrity) = 0;
238 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, test_integrity,
239 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ipsec_integrity), 0,
240 	"Emulate man-in-the-middle attack");
241 #endif
242 
243 #ifdef INET6
244 VNET_PCPUSTAT_DEFINE(struct ipsecstat, ipsec6stat);
245 VNET_PCPUSTAT_SYSINIT(ipsec6stat);
246 
247 #ifdef VIMAGE
248 VNET_PCPUSTAT_SYSUNINIT(ipsec6stat);
249 #endif /* VIMAGE */
250 
251 VNET_DEFINE(int, ip6_esp_trans_deflev) = IPSEC_LEVEL_USE;
252 VNET_DEFINE(int, ip6_esp_net_deflev) = IPSEC_LEVEL_USE;
253 VNET_DEFINE(int, ip6_ah_trans_deflev) = IPSEC_LEVEL_USE;
254 VNET_DEFINE(int, ip6_ah_net_deflev) = IPSEC_LEVEL_USE;
255 VNET_DEFINE(int, ip6_ipsec_ecn) = 0;	/* ECN ignore(-1)/forbidden(0)/allowed(1) */
256 
257 VNET_DEFINE_STATIC(int, ip6_filtertunnel) = 0;
258 #define	V_ip6_filtertunnel	VNET(ip6_filtertunnel)
259 
260 SYSCTL_DECL(_net_inet6_ipsec6);
261 
262 /* net.inet6.ipsec6 */
263 SYSCTL_PROC(_net_inet6_ipsec6, IPSECCTL_DEF_POLICY, def_policy,
264     CTLTYPE_INT | CTLFLAG_VNET | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
265     0, 0, sysctl_def_policy, "I",
266     "IPsec default policy.");
267 SYSCTL_INT(_net_inet6_ipsec6, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev,
268 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_esp_trans_deflev), 0,
269 	"Default ESP transport mode level.");
270 SYSCTL_INT(_net_inet6_ipsec6, IPSECCTL_DEF_ESP_NETLEV, esp_net_deflev,
271 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_esp_net_deflev), 0,
272 	"Default ESP tunnel mode level.");
273 SYSCTL_INT(_net_inet6_ipsec6, IPSECCTL_DEF_AH_TRANSLEV, ah_trans_deflev,
274 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_ah_trans_deflev), 0,
275 	"AH transfer mode default level.");
276 SYSCTL_INT(_net_inet6_ipsec6, IPSECCTL_DEF_AH_NETLEV, ah_net_deflev,
277 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_ah_net_deflev), 0,
278 	"AH tunnel mode default level.");
279 SYSCTL_INT(_net_inet6_ipsec6, IPSECCTL_ECN, ecn,
280 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_ipsec_ecn), 0,
281 	"Explicit Congestion Notification handling.");
282 SYSCTL_INT(_net_inet6_ipsec6, OID_AUTO, filtertunnel,
283 	CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_filtertunnel),  0,
284 	"If set, filter packets from an IPsec tunnel.");
285 SYSCTL_VNET_PCPUSTAT(_net_inet6_ipsec6, IPSECCTL_STATS, ipsecstats,
286     struct ipsecstat, ipsec6stat, "IPsec IPv6 statistics.");
287 #endif /* INET6 */
288 
289 static int ipsec_in_reject(struct secpolicy *, struct inpcb *,
290     const struct mbuf *);
291 
292 #ifdef INET
293 static void ipsec4_get_ulp(const struct mbuf *, struct secpolicyindex *, int);
294 static void ipsec4_setspidx_ipaddr(const struct mbuf *,
295     struct secpolicyindex *);
296 #endif
297 #ifdef INET6
298 static void ipsec6_get_ulp(const struct mbuf *m, struct secpolicyindex *, int);
299 static void ipsec6_setspidx_ipaddr(const struct mbuf *,
300     struct secpolicyindex *);
301 #endif
302 
303 /*
304  * Return a held reference to the default SP.
305  */
306 static struct secpolicy *
307 key_allocsp_default(void)
308 {
309 
310 	key_addref(V_def_policy);
311 	return (V_def_policy);
312 }
313 
314 static void
315 ipsec_invalidate_cache(struct inpcb *inp, u_int dir)
316 {
317 	struct secpolicy *sp;
318 
319 	INP_WLOCK_ASSERT(inp);
320 	if (dir == IPSEC_DIR_OUTBOUND) {
321 		if (inp->inp_sp->flags & INP_INBOUND_POLICY)
322 			return;
323 		sp = inp->inp_sp->sp_in;
324 		inp->inp_sp->sp_in = NULL;
325 	} else {
326 		if (inp->inp_sp->flags & INP_OUTBOUND_POLICY)
327 			return;
328 		sp = inp->inp_sp->sp_out;
329 		inp->inp_sp->sp_out = NULL;
330 	}
331 	if (sp != NULL)
332 		key_freesp(&sp); /* release extra reference */
333 }
334 
335 static void
336 ipsec_cachepolicy(struct inpcb *inp, struct secpolicy *sp, u_int dir)
337 {
338 	uint32_t genid;
339 	int downgrade;
340 
341 	INP_LOCK_ASSERT(inp);
342 
343 	if (dir == IPSEC_DIR_OUTBOUND) {
344 		/* Do we have configured PCB policy? */
345 		if (inp->inp_sp->flags & INP_OUTBOUND_POLICY)
346 			return;
347 		/* Another thread has already set cached policy */
348 		if (inp->inp_sp->sp_out != NULL)
349 			return;
350 		/*
351 		 * Do not cache OUTBOUND policy if PCB isn't connected,
352 		 * i.e. foreign address is INADDR_ANY/UNSPECIFIED.
353 		 */
354 #ifdef INET
355 		if ((inp->inp_vflag & INP_IPV4) != 0 &&
356 		    inp->inp_faddr.s_addr == INADDR_ANY)
357 			return;
358 #endif
359 #ifdef INET6
360 		if ((inp->inp_vflag & INP_IPV6) != 0 &&
361 		    IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))
362 			return;
363 #endif
364 	} else {
365 		/* Do we have configured PCB policy? */
366 		if (inp->inp_sp->flags & INP_INBOUND_POLICY)
367 			return;
368 		/* Another thread has already set cached policy */
369 		if (inp->inp_sp->sp_in != NULL)
370 			return;
371 		/*
372 		 * Do not cache INBOUND policy for listen socket,
373 		 * that is bound to INADDR_ANY/UNSPECIFIED address.
374 		 */
375 #ifdef INET
376 		if ((inp->inp_vflag & INP_IPV4) != 0 &&
377 		    inp->inp_faddr.s_addr == INADDR_ANY)
378 			return;
379 #endif
380 #ifdef INET6
381 		if ((inp->inp_vflag & INP_IPV6) != 0 &&
382 		    IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))
383 			return;
384 #endif
385 	}
386 	downgrade = 0;
387 	if (!INP_WLOCKED(inp)) {
388 		if ((downgrade = INP_TRY_UPGRADE(inp)) == 0)
389 			return;
390 	}
391 	if (dir == IPSEC_DIR_OUTBOUND)
392 		inp->inp_sp->sp_out = sp;
393 	else
394 		inp->inp_sp->sp_in = sp;
395 	/*
396 	 * SP is already referenced by the lookup code.
397 	 * We take extra reference here to avoid race in the
398 	 * ipsec_getpcbpolicy() function - SP will not be freed in the
399 	 * time between we take SP pointer from the cache and key_addref()
400 	 * call.
401 	 */
402 	key_addref(sp);
403 	genid = key_getspgen();
404 	if (genid != inp->inp_sp->genid) {
405 		ipsec_invalidate_cache(inp, dir);
406 		inp->inp_sp->genid = genid;
407 	}
408 	KEYDBG(IPSEC_STAMP,
409 	    printf("%s: PCB(%p): cached %s SP(%p)\n",
410 	    __func__, inp, dir == IPSEC_DIR_OUTBOUND ? "OUTBOUND":
411 	    "INBOUND", sp));
412 	if (downgrade != 0)
413 		INP_DOWNGRADE(inp);
414 }
415 
416 static struct secpolicy *
417 ipsec_checkpolicy(struct secpolicy *sp, struct inpcb *inp, int *error)
418 {
419 
420 	/* Save found OUTBOUND policy into PCB SP cache. */
421 	if (inp != NULL && inp->inp_sp != NULL && inp->inp_sp->sp_out == NULL)
422 		ipsec_cachepolicy(inp, sp, IPSEC_DIR_OUTBOUND);
423 
424 	switch (sp->policy) {
425 	default:
426 		printf("%s: invalid policy %u\n", __func__, sp->policy);
427 		/* FALLTHROUGH */
428 	case IPSEC_POLICY_DISCARD:
429 		*error = -EINVAL;	/* Packet is discarded by caller. */
430 		/* FALLTHROUGH */
431 	case IPSEC_POLICY_BYPASS:
432 	case IPSEC_POLICY_NONE:
433 		key_freesp(&sp);
434 		sp = NULL;		/* NB: force NULL result. */
435 		break;
436 	case IPSEC_POLICY_IPSEC:
437 		/* XXXAE: handle LARVAL SP */
438 		break;
439 	}
440 	KEYDBG(IPSEC_DUMP,
441 	    printf("%s: get SP(%p), error %d\n", __func__, sp, *error));
442 	return (sp);
443 }
444 
445 static struct secpolicy *
446 ipsec_getpcbpolicy(struct inpcb *inp, u_int dir)
447 {
448 	struct secpolicy *sp;
449 	int flags, downgrade;
450 
451 	if (inp == NULL || inp->inp_sp == NULL)
452 		return (NULL);
453 
454 	INP_LOCK_ASSERT(inp);
455 
456 	flags = inp->inp_sp->flags;
457 	if (dir == IPSEC_DIR_OUTBOUND) {
458 		sp = inp->inp_sp->sp_out;
459 		flags &= INP_OUTBOUND_POLICY;
460 	} else {
461 		sp = inp->inp_sp->sp_in;
462 		flags &= INP_INBOUND_POLICY;
463 	}
464 	/*
465 	 * Check flags. If we have PCB SP, just return it.
466 	 * Otherwise we need to check that cached SP entry isn't stale.
467 	 */
468 	if (flags == 0) {
469 		if (sp == NULL)
470 			return (NULL);
471 		if (inp->inp_sp->genid != key_getspgen()) {
472 			/* Invalidate the cache. */
473 			downgrade = 0;
474 			if (!INP_WLOCKED(inp)) {
475 				if ((downgrade = INP_TRY_UPGRADE(inp)) == 0)
476 					return (NULL);
477 			}
478 			ipsec_invalidate_cache(inp, IPSEC_DIR_OUTBOUND);
479 			ipsec_invalidate_cache(inp, IPSEC_DIR_INBOUND);
480 			if (downgrade != 0)
481 				INP_DOWNGRADE(inp);
482 			return (NULL);
483 		}
484 		KEYDBG(IPSEC_STAMP,
485 		    printf("%s: PCB(%p): cache hit SP(%p)\n",
486 		    __func__, inp, sp));
487 		/* Return referenced cached policy */
488 	}
489 	key_addref(sp);
490 	return (sp);
491 }
492 
493 #ifdef INET
494 static void
495 ipsec4_get_ulp(const struct mbuf *m, struct secpolicyindex *spidx,
496     int needport)
497 {
498 	uint8_t nxt;
499 	int off;
500 
501 	/* Sanity check. */
502 	IPSEC_ASSERT(m->m_pkthdr.len >= sizeof(struct ip),
503 	    ("packet too short"));
504 
505 	if (m->m_len >= sizeof (struct ip)) {
506 		const struct ip *ip = mtod(m, const struct ip *);
507 		if (ip->ip_off & htons(IP_MF | IP_OFFMASK))
508 			goto done;
509 		off = ip->ip_hl << 2;
510 		nxt = ip->ip_p;
511 	} else {
512 		struct ip ih;
513 
514 		m_copydata(m, 0, sizeof (struct ip), (caddr_t) &ih);
515 		if (ih.ip_off & htons(IP_MF | IP_OFFMASK))
516 			goto done;
517 		off = ih.ip_hl << 2;
518 		nxt = ih.ip_p;
519 	}
520 
521 	while (off < m->m_pkthdr.len) {
522 		struct ip6_ext ip6e;
523 		struct tcphdr th;
524 		struct udphdr uh;
525 
526 		switch (nxt) {
527 		case IPPROTO_TCP:
528 			spidx->ul_proto = nxt;
529 			if (!needport)
530 				goto done_proto;
531 			if (off + sizeof(struct tcphdr) > m->m_pkthdr.len)
532 				goto done;
533 			m_copydata(m, off, sizeof (th), (caddr_t) &th);
534 			spidx->src.sin.sin_port = th.th_sport;
535 			spidx->dst.sin.sin_port = th.th_dport;
536 			return;
537 		case IPPROTO_UDP:
538 			spidx->ul_proto = nxt;
539 			if (!needport)
540 				goto done_proto;
541 			if (off + sizeof(struct udphdr) > m->m_pkthdr.len)
542 				goto done;
543 			m_copydata(m, off, sizeof (uh), (caddr_t) &uh);
544 			spidx->src.sin.sin_port = uh.uh_sport;
545 			spidx->dst.sin.sin_port = uh.uh_dport;
546 			return;
547 		case IPPROTO_AH:
548 			if (off + sizeof(ip6e) > m->m_pkthdr.len)
549 				goto done;
550 			/* XXX Sigh, this works but is totally bogus. */
551 			m_copydata(m, off, sizeof(ip6e), (caddr_t) &ip6e);
552 			off += (ip6e.ip6e_len + 2) << 2;
553 			nxt = ip6e.ip6e_nxt;
554 			break;
555 		case IPPROTO_ICMP:
556 		default:
557 			/* XXX Intermediate headers??? */
558 			spidx->ul_proto = nxt;
559 			goto done_proto;
560 		}
561 	}
562 done:
563 	spidx->ul_proto = IPSEC_ULPROTO_ANY;
564 done_proto:
565 	spidx->src.sin.sin_port = IPSEC_PORT_ANY;
566 	spidx->dst.sin.sin_port = IPSEC_PORT_ANY;
567 	KEYDBG(IPSEC_DUMP,
568 	    printf("%s: ", __func__); kdebug_secpolicyindex(spidx, NULL));
569 }
570 
571 static void
572 ipsec4_setspidx_ipaddr(const struct mbuf *m, struct secpolicyindex *spidx)
573 {
574 
575 	ipsec4_setsockaddrs(m, &spidx->src, &spidx->dst);
576 	spidx->prefs = sizeof(struct in_addr) << 3;
577 	spidx->prefd = sizeof(struct in_addr) << 3;
578 }
579 
580 static struct secpolicy *
581 ipsec4_getpolicy(const struct mbuf *m, struct inpcb *inp, u_int dir,
582     int needport)
583 {
584 	struct secpolicyindex spidx;
585 	struct secpolicy *sp;
586 
587 	sp = ipsec_getpcbpolicy(inp, dir);
588 	if (sp == NULL && key_havesp(dir)) {
589 		/* Make an index to look for a policy. */
590 		ipsec4_setspidx_ipaddr(m, &spidx);
591 		ipsec4_get_ulp(m, &spidx, needport);
592 		spidx.dir = dir;
593 		sp = key_allocsp(&spidx, dir);
594 	}
595 	if (sp == NULL)		/* No SP found, use system default. */
596 		sp = key_allocsp_default();
597 	return (sp);
598 }
599 
600 /*
601  * Check security policy for *OUTBOUND* IPv4 packet.
602  */
603 struct secpolicy *
604 ipsec4_checkpolicy(const struct mbuf *m, struct inpcb *inp, int *error,
605     int needport)
606 {
607 	struct secpolicy *sp;
608 
609 	*error = 0;
610 	sp = ipsec4_getpolicy(m, inp, IPSEC_DIR_OUTBOUND, needport);
611 	if (sp != NULL)
612 		sp = ipsec_checkpolicy(sp, inp, error);
613 	if (sp == NULL) {
614 		switch (*error) {
615 		case 0: /* No IPsec required: BYPASS or NONE */
616 			break;
617 		case -EINVAL:
618 			IPSECSTAT_INC(ips_out_polvio);
619 			break;
620 		default:
621 			IPSECSTAT_INC(ips_out_inval);
622 		}
623 	}
624 	KEYDBG(IPSEC_STAMP,
625 	    printf("%s: using SP(%p), error %d\n", __func__, sp, *error));
626 	if (sp != NULL)
627 		KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp));
628 	return (sp);
629 }
630 
631 /*
632  * Check IPv4 packet against *INBOUND* security policy.
633  * This function is called from tcp_input(), udp_input(),
634  * rip_input() and sctp_input().
635  */
636 int
637 ipsec4_in_reject(const struct mbuf *m, struct inpcb *inp)
638 {
639 	struct secpolicy *sp;
640 	int result;
641 
642 	sp = ipsec4_getpolicy(m, inp, IPSEC_DIR_INBOUND, 0);
643 	result = ipsec_in_reject(sp, inp, m);
644 	key_freesp(&sp);
645 	if (result != 0)
646 		IPSECSTAT_INC(ips_in_polvio);
647 	return (result);
648 }
649 
650 /*
651  * IPSEC_CAP() method implementation for IPv4.
652  */
653 int
654 ipsec4_capability(struct mbuf *m, u_int cap)
655 {
656 
657 	switch (cap) {
658 	case IPSEC_CAP_BYPASS_FILTER:
659 		/*
660 		 * Bypass packet filtering for packets previously handled
661 		 * by IPsec.
662 		 */
663 		if (!V_ip4_filtertunnel &&
664 		    m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL)
665 			return (1);
666 		return (0);
667 	case IPSEC_CAP_OPERABLE:
668 		/* Do we have active security policies? */
669 		if (key_havesp(IPSEC_DIR_INBOUND) != 0 ||
670 		    key_havesp(IPSEC_DIR_OUTBOUND) != 0)
671 			return (1);
672 		return (0);
673 	};
674 	return (EOPNOTSUPP);
675 }
676 
677 #endif /* INET */
678 
679 #ifdef INET6
680 static void
681 ipsec6_get_ulp(const struct mbuf *m, struct secpolicyindex *spidx,
682     int needport)
683 {
684 	struct tcphdr th;
685 	struct udphdr uh;
686 	struct icmp6_hdr ih;
687 	int off, nxt;
688 
689 	IPSEC_ASSERT(m->m_pkthdr.len >= sizeof(struct ip6_hdr),
690 	    ("packet too short"));
691 
692 	/* Set default. */
693 	spidx->ul_proto = IPSEC_ULPROTO_ANY;
694 	spidx->src.sin6.sin6_port = IPSEC_PORT_ANY;
695 	spidx->dst.sin6.sin6_port = IPSEC_PORT_ANY;
696 
697 	nxt = -1;
698 	off = ip6_lasthdr(m, 0, IPPROTO_IPV6, &nxt);
699 	if (off < 0 || m->m_pkthdr.len < off)
700 		return;
701 
702 	switch (nxt) {
703 	case IPPROTO_TCP:
704 		spidx->ul_proto = nxt;
705 		if (!needport)
706 			break;
707 		if (off + sizeof(struct tcphdr) > m->m_pkthdr.len)
708 			break;
709 		m_copydata(m, off, sizeof(th), (caddr_t)&th);
710 		spidx->src.sin6.sin6_port = th.th_sport;
711 		spidx->dst.sin6.sin6_port = th.th_dport;
712 		break;
713 	case IPPROTO_UDP:
714 		spidx->ul_proto = nxt;
715 		if (!needport)
716 			break;
717 		if (off + sizeof(struct udphdr) > m->m_pkthdr.len)
718 			break;
719 		m_copydata(m, off, sizeof(uh), (caddr_t)&uh);
720 		spidx->src.sin6.sin6_port = uh.uh_sport;
721 		spidx->dst.sin6.sin6_port = uh.uh_dport;
722 		break;
723 	case IPPROTO_ICMPV6:
724 		spidx->ul_proto = nxt;
725 		if (off + sizeof(struct icmp6_hdr) > m->m_pkthdr.len)
726 			break;
727 		m_copydata(m, off, sizeof(ih), (caddr_t)&ih);
728 		spidx->src.sin6.sin6_port = htons((uint16_t)ih.icmp6_type);
729 		spidx->dst.sin6.sin6_port = htons((uint16_t)ih.icmp6_code);
730 		break;
731 	default:
732 		/* XXX Intermediate headers??? */
733 		spidx->ul_proto = nxt;
734 		break;
735 	}
736 	KEYDBG(IPSEC_DUMP,
737 	    printf("%s: ", __func__); kdebug_secpolicyindex(spidx, NULL));
738 }
739 
740 static void
741 ipsec6_setspidx_ipaddr(const struct mbuf *m, struct secpolicyindex *spidx)
742 {
743 
744 	ipsec6_setsockaddrs(m, &spidx->src, &spidx->dst);
745 	spidx->prefs = sizeof(struct in6_addr) << 3;
746 	spidx->prefd = sizeof(struct in6_addr) << 3;
747 }
748 
749 static struct secpolicy *
750 ipsec6_getpolicy(const struct mbuf *m, struct inpcb *inp, u_int dir,
751     int needport)
752 {
753 	struct secpolicyindex spidx;
754 	struct secpolicy *sp;
755 
756 	sp = ipsec_getpcbpolicy(inp, dir);
757 	if (sp == NULL && key_havesp(dir)) {
758 		/* Make an index to look for a policy. */
759 		ipsec6_setspidx_ipaddr(m, &spidx);
760 		ipsec6_get_ulp(m, &spidx, needport);
761 		spidx.dir = dir;
762 		sp = key_allocsp(&spidx, dir);
763 	}
764 	if (sp == NULL)		/* No SP found, use system default. */
765 		sp = key_allocsp_default();
766 	return (sp);
767 }
768 
769 /*
770  * Check security policy for *OUTBOUND* IPv6 packet.
771  */
772 struct secpolicy *
773 ipsec6_checkpolicy(const struct mbuf *m, struct inpcb *inp, int *error,
774     int needport)
775 {
776 	struct secpolicy *sp;
777 
778 	*error = 0;
779 	sp = ipsec6_getpolicy(m, inp, IPSEC_DIR_OUTBOUND, needport);
780 	if (sp != NULL)
781 		sp = ipsec_checkpolicy(sp, inp, error);
782 	if (sp == NULL) {
783 		switch (*error) {
784 		case 0: /* No IPsec required: BYPASS or NONE */
785 			break;
786 		case -EINVAL:
787 			IPSEC6STAT_INC(ips_out_polvio);
788 			break;
789 		default:
790 			IPSEC6STAT_INC(ips_out_inval);
791 		}
792 	}
793 	KEYDBG(IPSEC_STAMP,
794 	    printf("%s: using SP(%p), error %d\n", __func__, sp, *error));
795 	if (sp != NULL)
796 		KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp));
797 	return (sp);
798 }
799 
800 /*
801  * Check IPv6 packet against inbound security policy.
802  * This function is called from tcp6_input(), udp6_input(),
803  * rip6_input() and sctp_input().
804  */
805 int
806 ipsec6_in_reject(const struct mbuf *m, struct inpcb *inp)
807 {
808 	struct secpolicy *sp;
809 	int result;
810 
811 	sp = ipsec6_getpolicy(m, inp, IPSEC_DIR_INBOUND, 0);
812 	result = ipsec_in_reject(sp, inp, m);
813 	key_freesp(&sp);
814 	if (result)
815 		IPSEC6STAT_INC(ips_in_polvio);
816 	return (result);
817 }
818 
819 /*
820  * IPSEC_CAP() method implementation for IPv6.
821  */
822 int
823 ipsec6_capability(struct mbuf *m, u_int cap)
824 {
825 
826 	switch (cap) {
827 	case IPSEC_CAP_BYPASS_FILTER:
828 		/*
829 		 * Bypass packet filtering for packets previously handled
830 		 * by IPsec.
831 		 */
832 		if (!V_ip6_filtertunnel &&
833 		    m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL)
834 			return (1);
835 		return (0);
836 	case IPSEC_CAP_OPERABLE:
837 		/* Do we have active security policies? */
838 		if (key_havesp(IPSEC_DIR_INBOUND) != 0 ||
839 		    key_havesp(IPSEC_DIR_OUTBOUND) != 0)
840 			return (1);
841 		return (0);
842 	};
843 	return (EOPNOTSUPP);
844 }
845 #endif /* INET6 */
846 
847 int
848 ipsec_run_hhooks(struct ipsec_ctx_data *ctx, int type)
849 {
850 	int idx;
851 
852 	switch (ctx->af) {
853 #ifdef INET
854 	case AF_INET:
855 		idx = HHOOK_IPSEC_INET;
856 		break;
857 #endif
858 #ifdef INET6
859 	case AF_INET6:
860 		idx = HHOOK_IPSEC_INET6;
861 		break;
862 #endif
863 	default:
864 		return (EPFNOSUPPORT);
865 	}
866 	if (type == HHOOK_TYPE_IPSEC_IN)
867 		HHOOKS_RUN_IF(V_ipsec_hhh_in[idx], ctx, NULL);
868 	else
869 		HHOOKS_RUN_IF(V_ipsec_hhh_out[idx], ctx, NULL);
870 	if (*ctx->mp == NULL)
871 		return (EACCES);
872 	return (0);
873 }
874 
875 /*
876  * Return current level.
877  * Either IPSEC_LEVEL_USE or IPSEC_LEVEL_REQUIRE are always returned.
878  */
879 u_int
880 ipsec_get_reqlevel(struct secpolicy *sp, u_int idx)
881 {
882 	struct ipsecrequest *isr;
883 	u_int esp_trans_deflev, esp_net_deflev;
884 	u_int ah_trans_deflev, ah_net_deflev;
885 	u_int level = 0;
886 
887 	IPSEC_ASSERT(idx < sp->tcount, ("Wrong IPsec request index %d", idx));
888 /* XXX Note that we have ipseclog() expanded here - code sync issue. */
889 #define IPSEC_CHECK_DEFAULT(lev) \
890 	(((lev) != IPSEC_LEVEL_USE && (lev) != IPSEC_LEVEL_REQUIRE &&	\
891 	  (lev) != IPSEC_LEVEL_UNIQUE)					\
892 		? (V_ipsec_debug  ?					\
893 		log(LOG_INFO, "fixed system default level " #lev ":%d->%d\n",\
894 		(lev), IPSEC_LEVEL_REQUIRE) : 0),			\
895 		(lev) = IPSEC_LEVEL_REQUIRE, (lev) : (lev))
896 
897 	/*
898 	 * IPsec VTI uses unique security policy with fake spidx filled
899 	 * with zeroes. Just return IPSEC_LEVEL_REQUIRE instead of doing
900 	 * full level lookup for such policies.
901 	 */
902 	if (sp->state == IPSEC_SPSTATE_IFNET) {
903 		IPSEC_ASSERT(sp->req[idx]->level == IPSEC_LEVEL_UNIQUE,
904 		    ("Wrong IPsec request level %d", sp->req[idx]->level));
905 		return (IPSEC_LEVEL_REQUIRE);
906 	}
907 
908 	/* Set default level. */
909 	switch (sp->spidx.src.sa.sa_family) {
910 #ifdef INET
911 	case AF_INET:
912 		esp_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip4_esp_trans_deflev);
913 		esp_net_deflev = IPSEC_CHECK_DEFAULT(V_ip4_esp_net_deflev);
914 		ah_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip4_ah_trans_deflev);
915 		ah_net_deflev = IPSEC_CHECK_DEFAULT(V_ip4_ah_net_deflev);
916 		break;
917 #endif
918 #ifdef INET6
919 	case AF_INET6:
920 		esp_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip6_esp_trans_deflev);
921 		esp_net_deflev = IPSEC_CHECK_DEFAULT(V_ip6_esp_net_deflev);
922 		ah_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip6_ah_trans_deflev);
923 		ah_net_deflev = IPSEC_CHECK_DEFAULT(V_ip6_ah_net_deflev);
924 		break;
925 #endif /* INET6 */
926 	default:
927 		panic("%s: unknown af %u",
928 			__func__, sp->spidx.src.sa.sa_family);
929 	}
930 
931 #undef IPSEC_CHECK_DEFAULT
932 
933 	isr = sp->req[idx];
934 	/* Set level. */
935 	switch (isr->level) {
936 	case IPSEC_LEVEL_DEFAULT:
937 		switch (isr->saidx.proto) {
938 		case IPPROTO_ESP:
939 			if (isr->saidx.mode == IPSEC_MODE_TUNNEL)
940 				level = esp_net_deflev;
941 			else
942 				level = esp_trans_deflev;
943 			break;
944 		case IPPROTO_AH:
945 			if (isr->saidx.mode == IPSEC_MODE_TUNNEL)
946 				level = ah_net_deflev;
947 			else
948 				level = ah_trans_deflev;
949 			break;
950 		case IPPROTO_IPCOMP:
951 			/*
952 			 * We don't really care, as IPcomp document says that
953 			 * we shouldn't compress small packets.
954 			 */
955 			level = IPSEC_LEVEL_USE;
956 			break;
957 		default:
958 			panic("%s: Illegal protocol defined %u\n", __func__,
959 				isr->saidx.proto);
960 		}
961 		break;
962 
963 	case IPSEC_LEVEL_USE:
964 	case IPSEC_LEVEL_REQUIRE:
965 		level = isr->level;
966 		break;
967 	case IPSEC_LEVEL_UNIQUE:
968 		level = IPSEC_LEVEL_REQUIRE;
969 		break;
970 
971 	default:
972 		panic("%s: Illegal IPsec level %u\n", __func__, isr->level);
973 	}
974 
975 	return (level);
976 }
977 
978 static int
979 ipsec_check_history(const struct mbuf *m, struct secpolicy *sp, u_int idx)
980 {
981 	struct xform_history *xh;
982 	struct m_tag *mtag;
983 
984 	mtag = NULL;
985 	while ((mtag = m_tag_find(__DECONST(struct mbuf *, m),
986 	    PACKET_TAG_IPSEC_IN_DONE, mtag)) != NULL) {
987 		xh = (struct xform_history *)(mtag + 1);
988 		KEYDBG(IPSEC_DATA,
989 		    char buf[IPSEC_ADDRSTRLEN];
990 		    printf("%s: mode %s proto %u dst %s\n", __func__,
991 			kdebug_secasindex_mode(xh->mode), xh->proto,
992 			ipsec_address(&xh->dst, buf, sizeof(buf))));
993 		if (xh->proto != sp->req[idx]->saidx.proto)
994 			continue;
995 		/* If SA had IPSEC_MODE_ANY, consider this as match. */
996 		if (xh->mode != sp->req[idx]->saidx.mode &&
997 		    xh->mode != IPSEC_MODE_ANY)
998 			continue;
999 		/*
1000 		 * For transport mode IPsec request doesn't contain
1001 		 * addresses. We need to use address from spidx.
1002 		 */
1003 		if (sp->req[idx]->saidx.mode == IPSEC_MODE_TRANSPORT) {
1004 			if (key_sockaddrcmp_withmask(&xh->dst.sa,
1005 			    &sp->spidx.dst.sa, sp->spidx.prefd) != 0)
1006 				continue;
1007 		} else {
1008 			if (key_sockaddrcmp(&xh->dst.sa,
1009 			    &sp->req[idx]->saidx.dst.sa, 0) != 0)
1010 				continue;
1011 		}
1012 		return (0); /* matched */
1013 	}
1014 	return (1);
1015 }
1016 
1017 /*
1018  * Check security policy requirements against the actual
1019  * packet contents.  Return one if the packet should be
1020  * reject as "invalid"; otherwiser return zero to have the
1021  * packet treated as "valid".
1022  *
1023  * OUT:
1024  *	0: valid
1025  *	1: invalid
1026  */
1027 static int
1028 ipsec_in_reject(struct secpolicy *sp, struct inpcb *inp, const struct mbuf *m)
1029 {
1030 	int i;
1031 
1032 	KEYDBG(IPSEC_STAMP,
1033 	    printf("%s: PCB(%p): using SP(%p)\n", __func__, inp, sp));
1034 	KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp));
1035 
1036 	if (inp != NULL && inp->inp_sp != NULL && inp->inp_sp->sp_in == NULL)
1037 		ipsec_cachepolicy(inp, sp, IPSEC_DIR_INBOUND);
1038 
1039 	/* Check policy. */
1040 	switch (sp->policy) {
1041 	case IPSEC_POLICY_DISCARD:
1042 		return (1);
1043 	case IPSEC_POLICY_BYPASS:
1044 	case IPSEC_POLICY_NONE:
1045 		return (0);
1046 	}
1047 
1048 	IPSEC_ASSERT(sp->policy == IPSEC_POLICY_IPSEC,
1049 		("invalid policy %u", sp->policy));
1050 
1051 	/*
1052 	 * ipsec[46]_common_input_cb after each transform adds
1053 	 * PACKET_TAG_IPSEC_IN_DONE mbuf tag. It contains SPI, proto, mode
1054 	 * and destination address from saidx. We can compare info from
1055 	 * these tags with requirements in SP.
1056 	 */
1057 	for (i = 0; i < sp->tcount; i++) {
1058 		/*
1059 		 * Do not check IPcomp, since IPcomp document
1060 		 * says that we shouldn't compress small packets.
1061 		 * IPComp policy should always be treated as being
1062 		 * in "use" level.
1063 		 */
1064 		if (sp->req[i]->saidx.proto == IPPROTO_IPCOMP ||
1065 		    ipsec_get_reqlevel(sp, i) != IPSEC_LEVEL_REQUIRE)
1066 			continue;
1067 		if (V_check_policy_history != 0 &&
1068 		    ipsec_check_history(m, sp, i) != 0)
1069 			return (1);
1070 		else switch (sp->req[i]->saidx.proto) {
1071 		case IPPROTO_ESP:
1072 			if ((m->m_flags & M_DECRYPTED) == 0) {
1073 				KEYDBG(IPSEC_DUMP,
1074 				    printf("%s: ESP m_flags:%x\n", __func__,
1075 					    m->m_flags));
1076 				return (1);
1077 			}
1078 			break;
1079 		case IPPROTO_AH:
1080 			if ((m->m_flags & M_AUTHIPHDR) == 0) {
1081 				KEYDBG(IPSEC_DUMP,
1082 				    printf("%s: AH m_flags:%x\n", __func__,
1083 					    m->m_flags));
1084 				return (1);
1085 			}
1086 			break;
1087 		}
1088 	}
1089 	return (0);		/* Valid. */
1090 }
1091 
1092 /*
1093  * Compute the byte size to be occupied by IPsec header.
1094  * In case it is tunnelled, it includes the size of outer IP header.
1095  */
1096 size_t
1097 ipsec_hdrsiz_internal(struct secpolicy *sp)
1098 {
1099 	size_t size;
1100 	int i;
1101 
1102 	KEYDBG(IPSEC_STAMP, printf("%s: using SP(%p)\n", __func__, sp));
1103 	KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp));
1104 
1105 	switch (sp->policy) {
1106 	case IPSEC_POLICY_DISCARD:
1107 	case IPSEC_POLICY_BYPASS:
1108 	case IPSEC_POLICY_NONE:
1109 		return (0);
1110 	}
1111 
1112 	IPSEC_ASSERT(sp->policy == IPSEC_POLICY_IPSEC,
1113 		("invalid policy %u", sp->policy));
1114 
1115 	/*
1116 	 * XXX: for each transform we need to lookup suitable SA
1117 	 * and use info from SA to calculate headers size.
1118 	 * XXX: for NAT-T we need to cosider UDP header size.
1119 	 */
1120 	size = 0;
1121 	for (i = 0; i < sp->tcount; i++) {
1122 		switch (sp->req[i]->saidx.proto) {
1123 		case IPPROTO_ESP:
1124 			size += esp_hdrsiz(NULL);
1125 			break;
1126 		case IPPROTO_AH:
1127 			size += ah_hdrsiz(NULL);
1128 			break;
1129 		case IPPROTO_IPCOMP:
1130 			size += sizeof(struct ipcomp);
1131 			break;
1132 		}
1133 
1134 		if (sp->req[i]->saidx.mode == IPSEC_MODE_TUNNEL) {
1135 			switch (sp->req[i]->saidx.dst.sa.sa_family) {
1136 #ifdef INET
1137 			case AF_INET:
1138 				size += sizeof(struct ip);
1139 				break;
1140 #endif
1141 #ifdef INET6
1142 			case AF_INET6:
1143 				size += sizeof(struct ip6_hdr);
1144 				break;
1145 #endif
1146 			default:
1147 				ipseclog((LOG_ERR, "%s: unknown AF %d in "
1148 				    "IPsec tunnel SA\n", __func__,
1149 				    sp->req[i]->saidx.dst.sa.sa_family));
1150 				break;
1151 			}
1152 		}
1153 	}
1154 	return (size);
1155 }
1156 
1157 /*
1158  * Compute ESP/AH header size for protocols with PCB, including
1159  * outer IP header. Currently only tcp_output() uses it.
1160  */
1161 size_t
1162 ipsec_hdrsiz_inpcb(struct inpcb *inp)
1163 {
1164 	struct secpolicyindex spidx;
1165 	struct secpolicy *sp;
1166 	size_t sz;
1167 
1168 	sp = ipsec_getpcbpolicy(inp, IPSEC_DIR_OUTBOUND);
1169 	if (sp == NULL && key_havesp(IPSEC_DIR_OUTBOUND)) {
1170 		ipsec_setspidx_inpcb(inp, &spidx, IPSEC_DIR_OUTBOUND);
1171 		sp = key_allocsp(&spidx, IPSEC_DIR_OUTBOUND);
1172 	}
1173 	if (sp == NULL)
1174 		sp = key_allocsp_default();
1175 	sz = ipsec_hdrsiz_internal(sp);
1176 	key_freesp(&sp);
1177 	return (sz);
1178 }
1179 
1180 
1181 #define IPSEC_BITMAP_INDEX_MASK(w)	(w - 1)
1182 #define IPSEC_REDUNDANT_BIT_SHIFTS	5
1183 #define IPSEC_REDUNDANT_BITS		(1 << IPSEC_REDUNDANT_BIT_SHIFTS)
1184 #define IPSEC_BITMAP_LOC_MASK		(IPSEC_REDUNDANT_BITS - 1)
1185 
1186 /*
1187  * Functions below are responsible for checking and updating bitmap.
1188  * These are used to separate ipsec_chkreplay() and ipsec_updatereplay()
1189  * from window implementation
1190  *
1191  * Based on RFC 6479. Blocks are 32 bits unsigned integers
1192  */
1193 
1194 static inline int
1195 check_window(const struct secreplay *replay, uint64_t seq)
1196 {
1197 	int index, bit_location;
1198 
1199 	bit_location = seq & IPSEC_BITMAP_LOC_MASK;
1200 	index = (seq >> IPSEC_REDUNDANT_BIT_SHIFTS)
1201 		& IPSEC_BITMAP_INDEX_MASK(replay->bitmap_size);
1202 
1203 	/* This packet already seen? */
1204 	return ((replay->bitmap)[index] & (1 << bit_location));
1205 }
1206 
1207 static inline void
1208 advance_window(const struct secreplay *replay, uint64_t seq)
1209 {
1210 	int i;
1211 	uint64_t index, index_cur, diff;
1212 
1213 	index_cur = replay->last >> IPSEC_REDUNDANT_BIT_SHIFTS;
1214 	index = seq >> IPSEC_REDUNDANT_BIT_SHIFTS;
1215 	diff = index - index_cur;
1216 
1217 	if (diff > replay->bitmap_size) {
1218 		/* something unusual in this case */
1219 		diff = replay->bitmap_size;
1220 	}
1221 
1222 	for (i = 0; i < diff; i++) {
1223 		replay->bitmap[(i + index_cur + 1)
1224 		& IPSEC_BITMAP_INDEX_MASK(replay->bitmap_size)] = 0;
1225 	}
1226 }
1227 
1228 static inline void
1229 set_window(const struct secreplay *replay, uint64_t seq)
1230 {
1231 	int index, bit_location;
1232 
1233 	bit_location = seq & IPSEC_BITMAP_LOC_MASK;
1234 	index = (seq >> IPSEC_REDUNDANT_BIT_SHIFTS)
1235 		& IPSEC_BITMAP_INDEX_MASK(replay->bitmap_size);
1236 
1237 	replay->bitmap[index] |= (1 << bit_location);
1238 }
1239 
1240 /*
1241  * Check the variable replay window.
1242  * ipsec_chkreplay() performs replay check before ICV verification.
1243  * ipsec_updatereplay() updates replay bitmap.  This must be called after
1244  * ICV verification (it also performs replay check, which is usually done
1245  * beforehand).
1246  * 0 (zero) is returned if packet disallowed, 1 if packet permitted.
1247  *
1248  * Based on RFC 4303
1249  */
1250 
1251 int
1252 ipsec_chkreplay(uint32_t seq, uint32_t *seqhigh, struct secasvar *sav)
1253 {
1254 	char buf[128];
1255 	struct secreplay *replay;
1256 	uint32_t window;
1257 	uint32_t tl, th, bl;
1258 	uint32_t seqh;
1259 
1260 	IPSEC_ASSERT(sav != NULL, ("Null SA"));
1261 	IPSEC_ASSERT(sav->replay != NULL, ("Null replay state"));
1262 
1263 	replay = sav->replay;
1264 
1265 	/* No need to check replay if disabled. */
1266 	if (replay->wsize == 0)
1267 		return (1);
1268 
1269 	/* Zero sequence number is not allowed. */
1270 	if (seq == 0 && replay->last == 0)
1271 		return (0);
1272 
1273 	window = replay->wsize << 3;		/* Size of window */
1274 	tl = (uint32_t)replay->last;		/* Top of window, lower part */
1275 	th = (uint32_t)(replay->last >> 32);	/* Top of window, high part */
1276 	bl = tl - window + 1;			/* Bottom of window, lower part */
1277 
1278 	/*
1279 	 * We keep the high part intact when:
1280 	 * 1) the seq is within [bl, 0xffffffff] and the whole window is
1281 	 *    within one subspace;
1282 	 * 2) the seq is within [0, bl) and window spans two subspaces.
1283 	 */
1284 	if ((tl >= window - 1 && seq >= bl) ||
1285 	    (tl < window - 1 && seq < bl)) {
1286 		*seqhigh = th;
1287 		if (seq <= tl) {
1288 			/* Sequence number inside window - check against replay */
1289 			if (check_window(replay, seq))
1290 				return (0);
1291 		}
1292 
1293 		/* Sequence number above top of window or not found in bitmap */
1294 		return (1);
1295 	}
1296 
1297 	/*
1298 	 * If ESN is not enabled and packet with highest sequence number
1299 	 * was received we should report overflow
1300 	 */
1301 	if (tl == 0xffffffff && !(sav->flags & SADB_X_SAFLAGS_ESN)) {
1302 		/* Set overflow flag. */
1303 		replay->overflow++;
1304 
1305 		if ((sav->flags & SADB_X_EXT_CYCSEQ) == 0) {
1306 			if (sav->sah->saidx.proto == IPPROTO_ESP)
1307 				ESPSTAT_INC(esps_wrap);
1308 			else if (sav->sah->saidx.proto == IPPROTO_AH)
1309 				AHSTAT_INC(ahs_wrap);
1310 			return (0);
1311 		}
1312 
1313 		ipseclog((LOG_WARNING, "%s: replay counter made %d cycle. %s\n",
1314 		    __func__, replay->overflow,
1315 		    ipsec_sa2str(sav, buf, sizeof(buf))));
1316 	}
1317 
1318 	/*
1319 	 * Seq is within [bl, 0xffffffff] and bl is within
1320 	 * [0xffffffff-window, 0xffffffff].  This means we got a seq
1321 	 * which is within our replay window, but in the previous
1322 	 * subspace.
1323 	 */
1324 	if (tl < window - 1 && seq >= bl) {
1325 		if (th == 0)
1326 			return (0);
1327 		*seqhigh = th - 1;
1328 		seqh = th - 1;
1329 		if (check_window(replay, seq))
1330 			return (0);
1331 		return (1);
1332 	}
1333 
1334 	/*
1335 	 * Seq is within [0, bl) but the whole window is within one subspace.
1336 	 * This means that seq has wrapped and is in next subspace
1337 	 */
1338 	*seqhigh = th + 1;
1339 	seqh = th + 1;
1340 
1341 	/* Don't let high part wrap. */
1342 	if (seqh == 0) {
1343 		/* Set overflow flag. */
1344 		replay->overflow++;
1345 
1346 		if ((sav->flags & SADB_X_EXT_CYCSEQ) == 0) {
1347 			if (sav->sah->saidx.proto == IPPROTO_ESP)
1348 				ESPSTAT_INC(esps_wrap);
1349 			else if (sav->sah->saidx.proto == IPPROTO_AH)
1350 				AHSTAT_INC(ahs_wrap);
1351 			return (0);
1352 		}
1353 
1354 		ipseclog((LOG_WARNING, "%s: replay counter made %d cycle. %s\n",
1355 		    __func__, replay->overflow,
1356 		    ipsec_sa2str(sav, buf, sizeof(buf))));
1357 	}
1358 
1359 	return (1);
1360 }
1361 
1362 /*
1363  * Check replay counter whether to update or not.
1364  * OUT:	0:	OK
1365  *	1:	NG
1366  */
1367 int
1368 ipsec_updatereplay(uint32_t seq, struct secasvar *sav)
1369 {
1370 	struct secreplay *replay;
1371 	uint32_t window;
1372 	uint32_t tl, th, bl;
1373 	uint32_t seqh;
1374 
1375 	IPSEC_ASSERT(sav != NULL, ("Null SA"));
1376 	IPSEC_ASSERT(sav->replay != NULL, ("Null replay state"));
1377 
1378 	replay = sav->replay;
1379 
1380 	/* No need to check replay if disabled. */
1381 	if (replay->wsize == 0)
1382 		return (0);
1383 
1384 	/* Zero sequence number is not allowed. */
1385 	if (seq == 0 && replay->last == 0)
1386 		return (1);
1387 
1388 	window = replay->wsize << 3;		/* Size of window */
1389 	tl = (uint32_t)replay->last;		/* Top of window, lower part */
1390 	th = (uint32_t)(replay->last >> 32);	/* Top of window, high part */
1391 	bl = tl - window + 1;			/* Bottom of window, lower part */
1392 
1393 	/*
1394 	 * We keep the high part intact when:
1395 	 * 1) the seq is within [bl, 0xffffffff] and the whole window is
1396 	 *    within one subspace;
1397 	 * 2) the seq is within [0, bl) and window spans two subspaces.
1398 	 */
1399 	if ((tl >= window - 1 && seq >= bl) ||
1400 	    (tl < window - 1 && seq < bl)) {
1401 		seqh = th;
1402 		if (seq <= tl) {
1403 			/* Sequence number inside window - check against replay */
1404 			if (check_window(replay, seq))
1405 				return (1);
1406 			set_window(replay, seq);
1407 		} else {
1408 			advance_window(replay, ((uint64_t)seqh << 32) | seq);
1409 			set_window(replay, seq);
1410 			replay->last = ((uint64_t)seqh << 32) | seq;
1411 		}
1412 
1413 		/* Sequence number above top of window or not found in bitmap */
1414 		replay->count++;
1415 		return (0);
1416 	}
1417 
1418 	if (!(sav->flags & SADB_X_SAFLAGS_ESN))
1419 		return (1);
1420 
1421 	/*
1422 	 * Seq is within [bl, 0xffffffff] and bl is within
1423 	 * [0xffffffff-window, 0xffffffff].  This means we got a seq
1424 	 * which is within our replay window, but in the previous
1425 	 * subspace.
1426 	 */
1427 	if (tl < window - 1 && seq >= bl) {
1428 		if (th == 0)
1429 			return (1);
1430 		if (check_window(replay, seq))
1431 			return (1);
1432 
1433 		set_window(replay, seq);
1434 		replay->count++;
1435 		return (0);
1436 	}
1437 
1438 	/*
1439 	 * Seq is within [0, bl) but the whole window is within one subspace.
1440 	 * This means that seq has wrapped and is in next subspace
1441 	 */
1442 	seqh = th + 1;
1443 
1444 	/* Don't let high part wrap. */
1445 	if (seqh == 0)
1446 		return (1);
1447 
1448 	advance_window(replay, ((uint64_t)seqh << 32) | seq);
1449 	set_window(replay, seq);
1450 	replay->last = ((uint64_t)seqh << 32) | seq;
1451 	replay->count++;
1452 	return (0);
1453 }
1454 int
1455 ipsec_updateid(struct secasvar *sav, crypto_session_t *new,
1456     crypto_session_t *old)
1457 {
1458 	crypto_session_t tmp;
1459 
1460 	/*
1461 	 * tdb_cryptoid is initialized by xform_init().
1462 	 * Then it can be changed only when some crypto error occurred or
1463 	 * when SA is deleted. We stored used cryptoid in the xform_data
1464 	 * structure. In case when crypto error occurred and crypto
1465 	 * subsystem has reinited the session, it returns new cryptoid
1466 	 * and EAGAIN error code.
1467 	 *
1468 	 * This function will be called when we got EAGAIN from crypto
1469 	 * subsystem.
1470 	 * *new is cryptoid that was returned by crypto subsystem in
1471 	 * the crp_sid.
1472 	 * *old is the original cryptoid that we stored in xform_data.
1473 	 *
1474 	 * For first failed request *old == sav->tdb_cryptoid, then
1475 	 * we update sav->tdb_cryptoid and redo crypto_dispatch().
1476 	 * For next failed request *old != sav->tdb_cryptoid, then
1477 	 * we store cryptoid from first request into the *new variable
1478 	 * and crp_sid from this second session will be returned via
1479 	 * *old pointer, so caller can release second session.
1480 	 *
1481 	 * XXXAE: check this more carefully.
1482 	 */
1483 	KEYDBG(IPSEC_STAMP,
1484 	    printf("%s: SA(%p) moves cryptoid %p -> %p\n",
1485 		__func__, sav, *old, *new));
1486 	KEYDBG(IPSEC_DATA, kdebug_secasv(sav));
1487 	SECASVAR_LOCK(sav);
1488 	if (sav->tdb_cryptoid != *old) {
1489 		/* cryptoid was already updated */
1490 		tmp = *new;
1491 		*new = sav->tdb_cryptoid;
1492 		*old = tmp;
1493 		SECASVAR_UNLOCK(sav);
1494 		return (1);
1495 	}
1496 	sav->tdb_cryptoid = *new;
1497 	SECASVAR_UNLOCK(sav);
1498 	return (0);
1499 }
1500 
1501 int
1502 ipsec_initialized(void)
1503 {
1504 
1505 	return (V_def_policy != NULL);
1506 }
1507 
1508 static void
1509 def_policy_init(const void *unused __unused)
1510 {
1511 
1512 	V_def_policy = key_newsp();
1513 	if (V_def_policy != NULL) {
1514 		V_def_policy->policy = IPSEC_POLICY_NONE;
1515 		/* Force INPCB SP cache invalidation */
1516 		key_bumpspgen();
1517 	} else
1518 		printf("%s: failed to initialize default policy\n", __func__);
1519 }
1520 
1521 static void
1522 def_policy_uninit(const void *unused __unused)
1523 {
1524 
1525 	if (V_def_policy != NULL) {
1526 		key_freesp(&V_def_policy);
1527 		key_bumpspgen();
1528 	}
1529 }
1530 
1531 VNET_SYSINIT(def_policy_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST,
1532     def_policy_init, NULL);
1533 VNET_SYSUNINIT(def_policy_uninit, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST,
1534     def_policy_uninit, NULL);
1535