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