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