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