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