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