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_esp_trans_deflev) = IPSEC_LEVEL_USE; 116 VNET_DEFINE(int, ip4_esp_net_deflev) = IPSEC_LEVEL_USE; 117 VNET_DEFINE(int, ip4_ah_trans_deflev) = IPSEC_LEVEL_USE; 118 VNET_DEFINE(int, ip4_ah_net_deflev) = IPSEC_LEVEL_USE; 119 /* ECN ignore(-1)/forbidden(0)/allowed(1) */ 120 VNET_DEFINE(int, ip4_ipsec_ecn) = 0; 121 122 VNET_DEFINE_STATIC(int, ip4_filtertunnel) = 0; 123 #define V_ip4_filtertunnel VNET(ip4_filtertunnel) 124 VNET_DEFINE_STATIC(int, check_policy_history) = 0; 125 #define V_check_policy_history VNET(check_policy_history) 126 VNET_DEFINE_STATIC(struct secpolicy *, def_policy) = NULL; 127 #define V_def_policy VNET(def_policy) 128 static int 129 sysctl_def_policy(SYSCTL_HANDLER_ARGS) 130 { 131 int error, value; 132 133 value = V_def_policy->policy; 134 error = sysctl_handle_int(oidp, &value, 0, req); 135 if (error == 0) { 136 if (value != IPSEC_POLICY_DISCARD && 137 value != IPSEC_POLICY_NONE) 138 return (EINVAL); 139 V_def_policy->policy = value; 140 } 141 return (error); 142 } 143 144 /* 145 * Crypto support requirements: 146 * 147 * 1 require hardware support 148 * -1 require software support 149 * 0 take anything 150 */ 151 VNET_DEFINE(int, crypto_support) = CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE; 152 153 /* 154 * Use asynchronous mode to parallelize crypto jobs: 155 * 156 * 0 - disabled 157 * 1 - enabled 158 */ 159 VNET_DEFINE(int, async_crypto) = 0; 160 161 /* 162 * TCP/UDP checksum handling policy for transport mode NAT-T (RFC3948) 163 * 164 * 0 - auto: incrementally recompute, when checksum delta is known; 165 * if checksum delta isn't known, reset checksum to zero for UDP, 166 * and mark csum_flags as valid for TCP. 167 * 1 - fully recompute TCP/UDP checksum. 168 */ 169 VNET_DEFINE(int, natt_cksum_policy) = 0; 170 171 FEATURE(ipsec, "Internet Protocol Security (IPsec)"); 172 FEATURE(ipsec_natt, "UDP Encapsulation of IPsec ESP Packets ('NAT-T')"); 173 174 SYSCTL_DECL(_net_inet_ipsec); 175 176 /* net.inet.ipsec */ 177 SYSCTL_PROC(_net_inet_ipsec, IPSECCTL_DEF_POLICY, def_policy, 178 CTLTYPE_INT | CTLFLAG_VNET | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 179 0, 0, sysctl_def_policy, "I", 180 "IPsec default policy."); 181 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_ESP_TRANSLEV, esp_trans_deflev, 182 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_esp_trans_deflev), 0, 183 "Default ESP transport mode level"); 184 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_ESP_NETLEV, esp_net_deflev, 185 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_esp_net_deflev), 0, 186 "Default ESP tunnel mode level."); 187 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_AH_TRANSLEV, ah_trans_deflev, 188 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ah_trans_deflev), 0, 189 "AH transfer mode default level."); 190 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DEF_AH_NETLEV, ah_net_deflev, 191 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ah_net_deflev), 0, 192 "AH tunnel mode default level."); 193 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_AH_CLEARTOS, ah_cleartos, 194 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ah_cleartos), 0, 195 "If set, clear type-of-service field when doing AH computation."); 196 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_DFBIT, dfbit, 197 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ipsec_dfbit), 0, 198 "Do not fragment bit on encap."); 199 SYSCTL_INT(_net_inet_ipsec, IPSECCTL_ECN, ecn, 200 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_ipsec_ecn), 0, 201 "Explicit Congestion Notification handling."); 202 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, crypto_support, 203 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(crypto_support), 0, 204 "Crypto driver selection."); 205 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, async_crypto, 206 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(async_crypto), 0, 207 "Use asynchronous mode to parallelize crypto jobs."); 208 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, check_policy_history, 209 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(check_policy_history), 0, 210 "Use strict check of inbound packets to security policy compliance."); 211 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, natt_cksum_policy, 212 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(natt_cksum_policy), 0, 213 "Method to fix TCP/UDP checksum for transport mode IPsec after NAT."); 214 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, filtertunnel, 215 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip4_filtertunnel), 0, 216 "If set, filter packets from an IPsec tunnel."); 217 SYSCTL_VNET_PCPUSTAT(_net_inet_ipsec, OID_AUTO, ipsecstats, struct ipsecstat, 218 ipsec4stat, "IPsec IPv4 statistics."); 219 220 #ifdef REGRESSION 221 /* 222 * When set to 1, IPsec will send packets with the same sequence number. 223 * This allows to verify if the other side has proper replay attacks detection. 224 */ 225 VNET_DEFINE(int, ipsec_replay) = 0; 226 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, test_replay, 227 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ipsec_replay), 0, 228 "Emulate replay attack"); 229 /* 230 * When set 1, IPsec will send packets with corrupted HMAC. 231 * This allows to verify if the other side properly detects modified packets. 232 */ 233 VNET_DEFINE(int, ipsec_integrity) = 0; 234 SYSCTL_INT(_net_inet_ipsec, OID_AUTO, test_integrity, 235 CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ipsec_integrity), 0, 236 "Emulate man-in-the-middle attack"); 237 #endif 238 239 #ifdef INET6 240 VNET_PCPUSTAT_DEFINE(struct ipsecstat, ipsec6stat); 241 VNET_PCPUSTAT_SYSINIT(ipsec6stat); 242 243 #ifdef VIMAGE 244 VNET_PCPUSTAT_SYSUNINIT(ipsec6stat); 245 #endif /* VIMAGE */ 246 247 VNET_DEFINE(int, ip6_esp_trans_deflev) = IPSEC_LEVEL_USE; 248 VNET_DEFINE(int, ip6_esp_net_deflev) = IPSEC_LEVEL_USE; 249 VNET_DEFINE(int, ip6_ah_trans_deflev) = IPSEC_LEVEL_USE; 250 VNET_DEFINE(int, ip6_ah_net_deflev) = IPSEC_LEVEL_USE; 251 VNET_DEFINE(int, ip6_ipsec_ecn) = 0; /* ECN ignore(-1)/forbidden(0)/allowed(1) */ 252 253 VNET_DEFINE_STATIC(int, ip6_filtertunnel) = 0; 254 #define V_ip6_filtertunnel VNET(ip6_filtertunnel) 255 256 SYSCTL_DECL(_net_inet6_ipsec6); 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 int result; 637 638 sp = ipsec4_getpolicy(m, inp, IPSEC_DIR_INBOUND, 0); 639 result = ipsec_in_reject(sp, inp, m); 640 key_freesp(&sp); 641 if (result != 0) 642 IPSECSTAT_INC(ips_in_polvio); 643 return (result); 644 } 645 646 /* 647 * IPSEC_CAP() method implementation for IPv4. 648 */ 649 int 650 ipsec4_capability(struct mbuf *m, u_int cap) 651 { 652 653 switch (cap) { 654 case IPSEC_CAP_BYPASS_FILTER: 655 /* 656 * Bypass packet filtering for packets previously handled 657 * by IPsec. 658 */ 659 if (!V_ip4_filtertunnel && 660 m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL) 661 return (1); 662 return (0); 663 case IPSEC_CAP_OPERABLE: 664 /* Do we have active security policies? */ 665 if (key_havesp(IPSEC_DIR_INBOUND) != 0 || 666 key_havesp(IPSEC_DIR_OUTBOUND) != 0) 667 return (1); 668 return (0); 669 }; 670 return (EOPNOTSUPP); 671 } 672 673 #endif /* INET */ 674 675 #ifdef INET6 676 static void 677 ipsec6_get_ulp(const struct mbuf *m, struct secpolicyindex *spidx, 678 int needport) 679 { 680 struct tcphdr th; 681 struct udphdr uh; 682 struct icmp6_hdr ih; 683 int off, nxt; 684 685 IPSEC_ASSERT(m->m_pkthdr.len >= sizeof(struct ip6_hdr), 686 ("packet too short")); 687 688 /* Set default. */ 689 spidx->ul_proto = IPSEC_ULPROTO_ANY; 690 spidx->src.sin6.sin6_port = IPSEC_PORT_ANY; 691 spidx->dst.sin6.sin6_port = IPSEC_PORT_ANY; 692 693 nxt = -1; 694 off = ip6_lasthdr(m, 0, IPPROTO_IPV6, &nxt); 695 if (off < 0 || m->m_pkthdr.len < off) 696 return; 697 698 switch (nxt) { 699 case IPPROTO_TCP: 700 spidx->ul_proto = nxt; 701 if (!needport) 702 break; 703 if (off + sizeof(struct tcphdr) > m->m_pkthdr.len) 704 break; 705 m_copydata(m, off, sizeof(th), (caddr_t)&th); 706 spidx->src.sin6.sin6_port = th.th_sport; 707 spidx->dst.sin6.sin6_port = th.th_dport; 708 break; 709 case IPPROTO_UDP: 710 spidx->ul_proto = nxt; 711 if (!needport) 712 break; 713 if (off + sizeof(struct udphdr) > m->m_pkthdr.len) 714 break; 715 m_copydata(m, off, sizeof(uh), (caddr_t)&uh); 716 spidx->src.sin6.sin6_port = uh.uh_sport; 717 spidx->dst.sin6.sin6_port = uh.uh_dport; 718 break; 719 case IPPROTO_ICMPV6: 720 spidx->ul_proto = nxt; 721 if (off + sizeof(struct icmp6_hdr) > m->m_pkthdr.len) 722 break; 723 m_copydata(m, off, sizeof(ih), (caddr_t)&ih); 724 spidx->src.sin6.sin6_port = htons((uint16_t)ih.icmp6_type); 725 spidx->dst.sin6.sin6_port = htons((uint16_t)ih.icmp6_code); 726 break; 727 default: 728 /* XXX Intermediate headers??? */ 729 spidx->ul_proto = nxt; 730 break; 731 } 732 KEYDBG(IPSEC_DUMP, 733 printf("%s: ", __func__); kdebug_secpolicyindex(spidx, NULL)); 734 } 735 736 static void 737 ipsec6_setspidx_ipaddr(const struct mbuf *m, struct secpolicyindex *spidx) 738 { 739 740 ipsec6_setsockaddrs(m, &spidx->src, &spidx->dst); 741 spidx->prefs = sizeof(struct in6_addr) << 3; 742 spidx->prefd = sizeof(struct in6_addr) << 3; 743 } 744 745 static struct secpolicy * 746 ipsec6_getpolicy(const struct mbuf *m, struct inpcb *inp, u_int dir, 747 int needport) 748 { 749 struct secpolicyindex spidx; 750 struct secpolicy *sp; 751 752 sp = ipsec_getpcbpolicy(inp, dir); 753 if (sp == NULL && key_havesp(dir)) { 754 /* Make an index to look for a policy. */ 755 ipsec6_setspidx_ipaddr(m, &spidx); 756 ipsec6_get_ulp(m, &spidx, needport); 757 spidx.dir = dir; 758 sp = key_allocsp(&spidx, dir); 759 } 760 if (sp == NULL) /* No SP found, use system default. */ 761 sp = key_allocsp_default(); 762 return (sp); 763 } 764 765 /* 766 * Check security policy for *OUTBOUND* IPv6 packet. 767 */ 768 struct secpolicy * 769 ipsec6_checkpolicy(const struct mbuf *m, struct inpcb *inp, int *error, 770 int needport) 771 { 772 struct secpolicy *sp; 773 774 *error = 0; 775 sp = ipsec6_getpolicy(m, inp, IPSEC_DIR_OUTBOUND, needport); 776 if (sp != NULL) 777 sp = ipsec_checkpolicy(sp, inp, error); 778 if (sp == NULL) { 779 switch (*error) { 780 case 0: /* No IPsec required: BYPASS or NONE */ 781 break; 782 case -EINVAL: 783 IPSEC6STAT_INC(ips_out_polvio); 784 break; 785 default: 786 IPSEC6STAT_INC(ips_out_inval); 787 } 788 } 789 KEYDBG(IPSEC_STAMP, 790 printf("%s: using SP(%p), error %d\n", __func__, sp, *error)); 791 if (sp != NULL) 792 KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp)); 793 return (sp); 794 } 795 796 /* 797 * Check IPv6 packet against inbound security policy. 798 * This function is called from tcp6_input(), udp6_input(), 799 * rip6_input() and sctp_input(). 800 */ 801 int 802 ipsec6_in_reject(const struct mbuf *m, struct inpcb *inp) 803 { 804 struct secpolicy *sp; 805 int result; 806 807 sp = ipsec6_getpolicy(m, inp, IPSEC_DIR_INBOUND, 0); 808 result = ipsec_in_reject(sp, inp, m); 809 key_freesp(&sp); 810 if (result) 811 IPSEC6STAT_INC(ips_in_polvio); 812 return (result); 813 } 814 815 /* 816 * IPSEC_CAP() method implementation for IPv6. 817 */ 818 int 819 ipsec6_capability(struct mbuf *m, u_int cap) 820 { 821 822 switch (cap) { 823 case IPSEC_CAP_BYPASS_FILTER: 824 /* 825 * Bypass packet filtering for packets previously handled 826 * by IPsec. 827 */ 828 if (!V_ip6_filtertunnel && 829 m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL) 830 return (1); 831 return (0); 832 case IPSEC_CAP_OPERABLE: 833 /* Do we have active security policies? */ 834 if (key_havesp(IPSEC_DIR_INBOUND) != 0 || 835 key_havesp(IPSEC_DIR_OUTBOUND) != 0) 836 return (1); 837 return (0); 838 }; 839 return (EOPNOTSUPP); 840 } 841 #endif /* INET6 */ 842 843 int 844 ipsec_run_hhooks(struct ipsec_ctx_data *ctx, int type) 845 { 846 int idx; 847 848 switch (ctx->af) { 849 #ifdef INET 850 case AF_INET: 851 idx = HHOOK_IPSEC_INET; 852 break; 853 #endif 854 #ifdef INET6 855 case AF_INET6: 856 idx = HHOOK_IPSEC_INET6; 857 break; 858 #endif 859 default: 860 return (EPFNOSUPPORT); 861 } 862 if (type == HHOOK_TYPE_IPSEC_IN) 863 HHOOKS_RUN_IF(V_ipsec_hhh_in[idx], ctx, NULL); 864 else 865 HHOOKS_RUN_IF(V_ipsec_hhh_out[idx], ctx, NULL); 866 if (*ctx->mp == NULL) 867 return (EACCES); 868 return (0); 869 } 870 871 /* 872 * Return current level. 873 * Either IPSEC_LEVEL_USE or IPSEC_LEVEL_REQUIRE are always returned. 874 */ 875 u_int 876 ipsec_get_reqlevel(struct secpolicy *sp, u_int idx) 877 { 878 struct ipsecrequest *isr; 879 u_int esp_trans_deflev, esp_net_deflev; 880 u_int ah_trans_deflev, ah_net_deflev; 881 u_int level = 0; 882 883 IPSEC_ASSERT(idx < sp->tcount, ("Wrong IPsec request index %d", idx)); 884 /* XXX Note that we have ipseclog() expanded here - code sync issue. */ 885 #define IPSEC_CHECK_DEFAULT(lev) \ 886 (((lev) != IPSEC_LEVEL_USE && (lev) != IPSEC_LEVEL_REQUIRE && \ 887 (lev) != IPSEC_LEVEL_UNIQUE) \ 888 ? (V_ipsec_debug ? \ 889 log(LOG_INFO, "fixed system default level " #lev ":%d->%d\n",\ 890 (lev), IPSEC_LEVEL_REQUIRE) : 0), \ 891 (lev) = IPSEC_LEVEL_REQUIRE, (lev) : (lev)) 892 893 /* 894 * IPsec VTI uses unique security policy with fake spidx filled 895 * with zeroes. Just return IPSEC_LEVEL_REQUIRE instead of doing 896 * full level lookup for such policies. 897 */ 898 if (sp->state == IPSEC_SPSTATE_IFNET) { 899 IPSEC_ASSERT(sp->req[idx]->level == IPSEC_LEVEL_UNIQUE, 900 ("Wrong IPsec request level %d", sp->req[idx]->level)); 901 return (IPSEC_LEVEL_REQUIRE); 902 } 903 904 /* Set default level. */ 905 switch (sp->spidx.src.sa.sa_family) { 906 #ifdef INET 907 case AF_INET: 908 esp_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip4_esp_trans_deflev); 909 esp_net_deflev = IPSEC_CHECK_DEFAULT(V_ip4_esp_net_deflev); 910 ah_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip4_ah_trans_deflev); 911 ah_net_deflev = IPSEC_CHECK_DEFAULT(V_ip4_ah_net_deflev); 912 break; 913 #endif 914 #ifdef INET6 915 case AF_INET6: 916 esp_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip6_esp_trans_deflev); 917 esp_net_deflev = IPSEC_CHECK_DEFAULT(V_ip6_esp_net_deflev); 918 ah_trans_deflev = IPSEC_CHECK_DEFAULT(V_ip6_ah_trans_deflev); 919 ah_net_deflev = IPSEC_CHECK_DEFAULT(V_ip6_ah_net_deflev); 920 break; 921 #endif /* INET6 */ 922 default: 923 panic("%s: unknown af %u", 924 __func__, sp->spidx.src.sa.sa_family); 925 } 926 927 #undef IPSEC_CHECK_DEFAULT 928 929 isr = sp->req[idx]; 930 /* Set level. */ 931 switch (isr->level) { 932 case IPSEC_LEVEL_DEFAULT: 933 switch (isr->saidx.proto) { 934 case IPPROTO_ESP: 935 if (isr->saidx.mode == IPSEC_MODE_TUNNEL) 936 level = esp_net_deflev; 937 else 938 level = esp_trans_deflev; 939 break; 940 case IPPROTO_AH: 941 if (isr->saidx.mode == IPSEC_MODE_TUNNEL) 942 level = ah_net_deflev; 943 else 944 level = ah_trans_deflev; 945 break; 946 case IPPROTO_IPCOMP: 947 /* 948 * We don't really care, as IPcomp document says that 949 * we shouldn't compress small packets. 950 */ 951 level = IPSEC_LEVEL_USE; 952 break; 953 default: 954 panic("%s: Illegal protocol defined %u\n", __func__, 955 isr->saidx.proto); 956 } 957 break; 958 959 case IPSEC_LEVEL_USE: 960 case IPSEC_LEVEL_REQUIRE: 961 level = isr->level; 962 break; 963 case IPSEC_LEVEL_UNIQUE: 964 level = IPSEC_LEVEL_REQUIRE; 965 break; 966 967 default: 968 panic("%s: Illegal IPsec level %u\n", __func__, isr->level); 969 } 970 971 return (level); 972 } 973 974 static int 975 ipsec_check_history(const struct mbuf *m, struct secpolicy *sp, u_int idx) 976 { 977 struct xform_history *xh; 978 struct m_tag *mtag; 979 980 mtag = NULL; 981 while ((mtag = m_tag_find(__DECONST(struct mbuf *, m), 982 PACKET_TAG_IPSEC_IN_DONE, mtag)) != NULL) { 983 xh = (struct xform_history *)(mtag + 1); 984 KEYDBG(IPSEC_DATA, 985 char buf[IPSEC_ADDRSTRLEN]; 986 printf("%s: mode %s proto %u dst %s\n", __func__, 987 kdebug_secasindex_mode(xh->mode), xh->proto, 988 ipsec_address(&xh->dst, buf, sizeof(buf)))); 989 if (xh->proto != sp->req[idx]->saidx.proto) 990 continue; 991 /* If SA had IPSEC_MODE_ANY, consider this as match. */ 992 if (xh->mode != sp->req[idx]->saidx.mode && 993 xh->mode != IPSEC_MODE_ANY) 994 continue; 995 /* 996 * For transport mode IPsec request doesn't contain 997 * addresses. We need to use address from spidx. 998 */ 999 if (sp->req[idx]->saidx.mode == IPSEC_MODE_TRANSPORT) { 1000 if (key_sockaddrcmp_withmask(&xh->dst.sa, 1001 &sp->spidx.dst.sa, sp->spidx.prefd) != 0) 1002 continue; 1003 } else { 1004 if (key_sockaddrcmp(&xh->dst.sa, 1005 &sp->req[idx]->saidx.dst.sa, 0) != 0) 1006 continue; 1007 } 1008 return (0); /* matched */ 1009 } 1010 return (1); 1011 } 1012 1013 /* 1014 * Check security policy requirements against the actual 1015 * packet contents. Return one if the packet should be 1016 * reject as "invalid"; otherwiser return zero to have the 1017 * packet treated as "valid". 1018 * 1019 * OUT: 1020 * 0: valid 1021 * 1: invalid 1022 */ 1023 static int 1024 ipsec_in_reject(struct secpolicy *sp, struct inpcb *inp, const struct mbuf *m) 1025 { 1026 int i; 1027 1028 KEYDBG(IPSEC_STAMP, 1029 printf("%s: PCB(%p): using SP(%p)\n", __func__, inp, sp)); 1030 KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp)); 1031 1032 if (inp != NULL && inp->inp_sp != NULL && inp->inp_sp->sp_in == NULL) 1033 ipsec_cachepolicy(inp, sp, IPSEC_DIR_INBOUND); 1034 1035 /* Check policy. */ 1036 switch (sp->policy) { 1037 case IPSEC_POLICY_DISCARD: 1038 return (1); 1039 case IPSEC_POLICY_BYPASS: 1040 case IPSEC_POLICY_NONE: 1041 return (0); 1042 } 1043 1044 IPSEC_ASSERT(sp->policy == IPSEC_POLICY_IPSEC, 1045 ("invalid policy %u", sp->policy)); 1046 1047 /* 1048 * ipsec[46]_common_input_cb after each transform adds 1049 * PACKET_TAG_IPSEC_IN_DONE mbuf tag. It contains SPI, proto, mode 1050 * and destination address from saidx. We can compare info from 1051 * these tags with requirements in SP. 1052 */ 1053 for (i = 0; i < sp->tcount; i++) { 1054 /* 1055 * Do not check IPcomp, since IPcomp document 1056 * says that we shouldn't compress small packets. 1057 * IPComp policy should always be treated as being 1058 * in "use" level. 1059 */ 1060 if (sp->req[i]->saidx.proto == IPPROTO_IPCOMP || 1061 ipsec_get_reqlevel(sp, i) != IPSEC_LEVEL_REQUIRE) 1062 continue; 1063 if (V_check_policy_history != 0 && 1064 ipsec_check_history(m, sp, i) != 0) 1065 return (1); 1066 else switch (sp->req[i]->saidx.proto) { 1067 case IPPROTO_ESP: 1068 if ((m->m_flags & M_DECRYPTED) == 0) { 1069 KEYDBG(IPSEC_DUMP, 1070 printf("%s: ESP m_flags:%x\n", __func__, 1071 m->m_flags)); 1072 return (1); 1073 } 1074 break; 1075 case IPPROTO_AH: 1076 if ((m->m_flags & M_AUTHIPHDR) == 0) { 1077 KEYDBG(IPSEC_DUMP, 1078 printf("%s: AH m_flags:%x\n", __func__, 1079 m->m_flags)); 1080 return (1); 1081 } 1082 break; 1083 } 1084 } 1085 return (0); /* Valid. */ 1086 } 1087 1088 /* 1089 * Compute the byte size to be occupied by IPsec header. 1090 * In case it is tunnelled, it includes the size of outer IP header. 1091 */ 1092 static size_t 1093 ipsec_hdrsiz_internal(struct secpolicy *sp) 1094 { 1095 size_t size; 1096 int i; 1097 1098 KEYDBG(IPSEC_STAMP, printf("%s: using SP(%p)\n", __func__, sp)); 1099 KEYDBG(IPSEC_DATA, kdebug_secpolicy(sp)); 1100 1101 switch (sp->policy) { 1102 case IPSEC_POLICY_DISCARD: 1103 case IPSEC_POLICY_BYPASS: 1104 case IPSEC_POLICY_NONE: 1105 return (0); 1106 } 1107 1108 IPSEC_ASSERT(sp->policy == IPSEC_POLICY_IPSEC, 1109 ("invalid policy %u", sp->policy)); 1110 1111 /* 1112 * XXX: for each transform we need to lookup suitable SA 1113 * and use info from SA to calculate headers size. 1114 * XXX: for NAT-T we need to cosider UDP header size. 1115 */ 1116 size = 0; 1117 for (i = 0; i < sp->tcount; i++) { 1118 switch (sp->req[i]->saidx.proto) { 1119 case IPPROTO_ESP: 1120 size += esp_hdrsiz(NULL); 1121 break; 1122 case IPPROTO_AH: 1123 size += ah_hdrsiz(NULL); 1124 break; 1125 case IPPROTO_IPCOMP: 1126 size += sizeof(struct ipcomp); 1127 break; 1128 } 1129 1130 if (sp->req[i]->saidx.mode == IPSEC_MODE_TUNNEL) { 1131 switch (sp->req[i]->saidx.dst.sa.sa_family) { 1132 #ifdef INET 1133 case AF_INET: 1134 size += sizeof(struct ip); 1135 break; 1136 #endif 1137 #ifdef INET6 1138 case AF_INET6: 1139 size += sizeof(struct ip6_hdr); 1140 break; 1141 #endif 1142 default: 1143 ipseclog((LOG_ERR, "%s: unknown AF %d in " 1144 "IPsec tunnel SA\n", __func__, 1145 sp->req[i]->saidx.dst.sa.sa_family)); 1146 break; 1147 } 1148 } 1149 } 1150 return (size); 1151 } 1152 1153 /* 1154 * Compute ESP/AH header size for protocols with PCB, including 1155 * outer IP header. Currently only tcp_output() uses it. 1156 */ 1157 size_t 1158 ipsec_hdrsiz_inpcb(struct inpcb *inp) 1159 { 1160 struct secpolicyindex spidx; 1161 struct secpolicy *sp; 1162 size_t sz; 1163 1164 sp = ipsec_getpcbpolicy(inp, IPSEC_DIR_OUTBOUND); 1165 if (sp == NULL && key_havesp(IPSEC_DIR_OUTBOUND)) { 1166 ipsec_setspidx_inpcb(inp, &spidx, IPSEC_DIR_OUTBOUND); 1167 sp = key_allocsp(&spidx, IPSEC_DIR_OUTBOUND); 1168 } 1169 if (sp == NULL) 1170 sp = key_allocsp_default(); 1171 sz = ipsec_hdrsiz_internal(sp); 1172 key_freesp(&sp); 1173 return (sz); 1174 } 1175 1176 1177 #define IPSEC_BITMAP_INDEX_MASK(w) (w - 1) 1178 #define IPSEC_REDUNDANT_BIT_SHIFTS 5 1179 #define IPSEC_REDUNDANT_BITS (1 << IPSEC_REDUNDANT_BIT_SHIFTS) 1180 #define IPSEC_BITMAP_LOC_MASK (IPSEC_REDUNDANT_BITS - 1) 1181 1182 /* 1183 * Functions below are responsible for checking and updating bitmap. 1184 * These are used to separate ipsec_chkreplay() and ipsec_updatereplay() 1185 * from window implementation 1186 * 1187 * Based on RFC 6479. Blocks are 32 bits unsigned integers 1188 */ 1189 1190 static inline int 1191 check_window(const struct secreplay *replay, uint64_t seq) 1192 { 1193 int index, bit_location; 1194 1195 bit_location = seq & IPSEC_BITMAP_LOC_MASK; 1196 index = (seq >> IPSEC_REDUNDANT_BIT_SHIFTS) 1197 & IPSEC_BITMAP_INDEX_MASK(replay->bitmap_size); 1198 1199 /* This packet already seen? */ 1200 return ((replay->bitmap)[index] & (1 << bit_location)); 1201 } 1202 1203 static inline void 1204 advance_window(const struct secreplay *replay, uint64_t seq) 1205 { 1206 int i; 1207 uint64_t index, index_cur, diff; 1208 1209 index_cur = replay->last >> IPSEC_REDUNDANT_BIT_SHIFTS; 1210 index = seq >> IPSEC_REDUNDANT_BIT_SHIFTS; 1211 diff = index - index_cur; 1212 1213 if (diff > replay->bitmap_size) { 1214 /* something unusual in this case */ 1215 diff = replay->bitmap_size; 1216 } 1217 1218 for (i = 0; i < diff; i++) { 1219 replay->bitmap[(i + index_cur + 1) 1220 & IPSEC_BITMAP_INDEX_MASK(replay->bitmap_size)] = 0; 1221 } 1222 } 1223 1224 static inline void 1225 set_window(const struct secreplay *replay, uint64_t seq) 1226 { 1227 int index, bit_location; 1228 1229 bit_location = seq & IPSEC_BITMAP_LOC_MASK; 1230 index = (seq >> IPSEC_REDUNDANT_BIT_SHIFTS) 1231 & IPSEC_BITMAP_INDEX_MASK(replay->bitmap_size); 1232 1233 replay->bitmap[index] |= (1 << bit_location); 1234 } 1235 1236 /* 1237 * Check the variable replay window. 1238 * ipsec_chkreplay() performs replay check before ICV verification. 1239 * ipsec_updatereplay() updates replay bitmap. This must be called after 1240 * ICV verification (it also performs replay check, which is usually done 1241 * beforehand). 1242 * 0 (zero) is returned if packet disallowed, 1 if packet permitted. 1243 * 1244 * Based on RFC 4303 1245 */ 1246 1247 int 1248 ipsec_chkreplay(uint32_t seq, uint32_t *seqhigh, struct secasvar *sav) 1249 { 1250 char buf[128]; 1251 struct secreplay *replay; 1252 uint32_t window; 1253 uint32_t tl, th, bl; 1254 uint32_t seqh; 1255 1256 IPSEC_ASSERT(sav != NULL, ("Null SA")); 1257 IPSEC_ASSERT(sav->replay != NULL, ("Null replay state")); 1258 1259 replay = sav->replay; 1260 1261 /* No need to check replay if disabled. */ 1262 if (replay->wsize == 0) 1263 return (1); 1264 1265 /* Zero sequence number is not allowed. */ 1266 if (seq == 0 && replay->last == 0) 1267 return (0); 1268 1269 window = replay->wsize << 3; /* Size of window */ 1270 tl = (uint32_t)replay->last; /* Top of window, lower part */ 1271 th = (uint32_t)(replay->last >> 32); /* Top of window, high part */ 1272 bl = tl - window + 1; /* Bottom of window, lower part */ 1273 1274 /* 1275 * We keep the high part intact when: 1276 * 1) the seq is within [bl, 0xffffffff] and the whole window is 1277 * within one subspace; 1278 * 2) the seq is within [0, bl) and window spans two subspaces. 1279 */ 1280 if ((tl >= window - 1 && seq >= bl) || 1281 (tl < window - 1 && seq < bl)) { 1282 *seqhigh = th; 1283 if (seq <= tl) { 1284 /* Sequence number inside window - check against replay */ 1285 if (check_window(replay, seq)) 1286 return (0); 1287 } 1288 1289 /* Sequence number above top of window or not found in bitmap */ 1290 return (1); 1291 } 1292 1293 /* 1294 * If ESN is not enabled and packet with highest sequence number 1295 * was received we should report overflow 1296 */ 1297 if (tl == 0xffffffff && !(sav->flags & SADB_X_SAFLAGS_ESN)) { 1298 /* Set overflow flag. */ 1299 replay->overflow++; 1300 1301 if ((sav->flags & SADB_X_EXT_CYCSEQ) == 0) { 1302 if (sav->sah->saidx.proto == IPPROTO_ESP) 1303 ESPSTAT_INC(esps_wrap); 1304 else if (sav->sah->saidx.proto == IPPROTO_AH) 1305 AHSTAT_INC(ahs_wrap); 1306 return (0); 1307 } 1308 1309 ipseclog((LOG_WARNING, "%s: replay counter made %d cycle. %s\n", 1310 __func__, replay->overflow, 1311 ipsec_sa2str(sav, buf, sizeof(buf)))); 1312 } 1313 1314 /* 1315 * Seq is within [bl, 0xffffffff] and bl is within 1316 * [0xffffffff-window, 0xffffffff]. This means we got a seq 1317 * which is within our replay window, but in the previous 1318 * subspace. 1319 */ 1320 if (tl < window - 1 && seq >= bl) { 1321 if (th == 0) 1322 return (0); 1323 *seqhigh = th - 1; 1324 seqh = th - 1; 1325 if (check_window(replay, seq)) 1326 return (0); 1327 return (1); 1328 } 1329 1330 /* 1331 * Seq is within [0, bl) but the whole window is within one subspace. 1332 * This means that seq has wrapped and is in next subspace 1333 */ 1334 *seqhigh = th + 1; 1335 seqh = th + 1; 1336 1337 /* Don't let high part wrap. */ 1338 if (seqh == 0) { 1339 /* Set overflow flag. */ 1340 replay->overflow++; 1341 1342 if ((sav->flags & SADB_X_EXT_CYCSEQ) == 0) { 1343 if (sav->sah->saidx.proto == IPPROTO_ESP) 1344 ESPSTAT_INC(esps_wrap); 1345 else if (sav->sah->saidx.proto == IPPROTO_AH) 1346 AHSTAT_INC(ahs_wrap); 1347 return (0); 1348 } 1349 1350 ipseclog((LOG_WARNING, "%s: replay counter made %d cycle. %s\n", 1351 __func__, replay->overflow, 1352 ipsec_sa2str(sav, buf, sizeof(buf)))); 1353 } 1354 1355 return (1); 1356 } 1357 1358 /* 1359 * Check replay counter whether to update or not. 1360 * OUT: 0: OK 1361 * 1: NG 1362 */ 1363 int 1364 ipsec_updatereplay(uint32_t seq, struct secasvar *sav) 1365 { 1366 struct secreplay *replay; 1367 uint32_t window; 1368 uint32_t tl, th, bl; 1369 uint32_t seqh; 1370 1371 IPSEC_ASSERT(sav != NULL, ("Null SA")); 1372 IPSEC_ASSERT(sav->replay != NULL, ("Null replay state")); 1373 1374 replay = sav->replay; 1375 1376 /* No need to check replay if disabled. */ 1377 if (replay->wsize == 0) 1378 return (0); 1379 1380 /* Zero sequence number is not allowed. */ 1381 if (seq == 0 && replay->last == 0) 1382 return (1); 1383 1384 window = replay->wsize << 3; /* Size of window */ 1385 tl = (uint32_t)replay->last; /* Top of window, lower part */ 1386 th = (uint32_t)(replay->last >> 32); /* Top of window, high part */ 1387 bl = tl - window + 1; /* Bottom of window, lower part */ 1388 1389 /* 1390 * We keep the high part intact when: 1391 * 1) the seq is within [bl, 0xffffffff] and the whole window is 1392 * within one subspace; 1393 * 2) the seq is within [0, bl) and window spans two subspaces. 1394 */ 1395 if ((tl >= window - 1 && seq >= bl) || 1396 (tl < window - 1 && seq < bl)) { 1397 seqh = th; 1398 if (seq <= tl) { 1399 /* Sequence number inside window - check against replay */ 1400 if (check_window(replay, seq)) 1401 return (1); 1402 set_window(replay, seq); 1403 } else { 1404 advance_window(replay, ((uint64_t)seqh << 32) | seq); 1405 set_window(replay, seq); 1406 replay->last = ((uint64_t)seqh << 32) | seq; 1407 } 1408 1409 /* Sequence number above top of window or not found in bitmap */ 1410 replay->count++; 1411 return (0); 1412 } 1413 1414 if (!(sav->flags & SADB_X_SAFLAGS_ESN)) 1415 return (1); 1416 1417 /* 1418 * Seq is within [bl, 0xffffffff] and bl is within 1419 * [0xffffffff-window, 0xffffffff]. This means we got a seq 1420 * which is within our replay window, but in the previous 1421 * subspace. 1422 */ 1423 if (tl < window - 1 && seq >= bl) { 1424 if (th == 0) 1425 return (1); 1426 if (check_window(replay, seq)) 1427 return (1); 1428 1429 set_window(replay, seq); 1430 replay->count++; 1431 return (0); 1432 } 1433 1434 /* 1435 * Seq is within [0, bl) but the whole window is within one subspace. 1436 * This means that seq has wrapped and is in next subspace 1437 */ 1438 seqh = th + 1; 1439 1440 /* Don't let high part wrap. */ 1441 if (seqh == 0) 1442 return (1); 1443 1444 advance_window(replay, ((uint64_t)seqh << 32) | seq); 1445 set_window(replay, seq); 1446 replay->last = ((uint64_t)seqh << 32) | seq; 1447 replay->count++; 1448 return (0); 1449 } 1450 int 1451 ipsec_updateid(struct secasvar *sav, crypto_session_t *new, 1452 crypto_session_t *old) 1453 { 1454 crypto_session_t tmp; 1455 1456 /* 1457 * tdb_cryptoid is initialized by xform_init(). 1458 * Then it can be changed only when some crypto error occurred or 1459 * when SA is deleted. We stored used cryptoid in the xform_data 1460 * structure. In case when crypto error occurred and crypto 1461 * subsystem has reinited the session, it returns new cryptoid 1462 * and EAGAIN error code. 1463 * 1464 * This function will be called when we got EAGAIN from crypto 1465 * subsystem. 1466 * *new is cryptoid that was returned by crypto subsystem in 1467 * the crp_sid. 1468 * *old is the original cryptoid that we stored in xform_data. 1469 * 1470 * For first failed request *old == sav->tdb_cryptoid, then 1471 * we update sav->tdb_cryptoid and redo crypto_dispatch(). 1472 * For next failed request *old != sav->tdb_cryptoid, then 1473 * we store cryptoid from first request into the *new variable 1474 * and crp_sid from this second session will be returned via 1475 * *old pointer, so caller can release second session. 1476 * 1477 * XXXAE: check this more carefully. 1478 */ 1479 KEYDBG(IPSEC_STAMP, 1480 printf("%s: SA(%p) moves cryptoid %p -> %p\n", 1481 __func__, sav, *old, *new)); 1482 KEYDBG(IPSEC_DATA, kdebug_secasv(sav)); 1483 SECASVAR_LOCK(sav); 1484 if (sav->tdb_cryptoid != *old) { 1485 /* cryptoid was already updated */ 1486 tmp = *new; 1487 *new = sav->tdb_cryptoid; 1488 *old = tmp; 1489 SECASVAR_UNLOCK(sav); 1490 return (1); 1491 } 1492 sav->tdb_cryptoid = *new; 1493 SECASVAR_UNLOCK(sav); 1494 return (0); 1495 } 1496 1497 int 1498 ipsec_initialized(void) 1499 { 1500 1501 return (V_def_policy != NULL); 1502 } 1503 1504 static void 1505 def_policy_init(const void *unused __unused) 1506 { 1507 1508 V_def_policy = key_newsp(); 1509 if (V_def_policy != NULL) { 1510 V_def_policy->policy = IPSEC_POLICY_NONE; 1511 /* Force INPCB SP cache invalidation */ 1512 key_bumpspgen(); 1513 } else 1514 printf("%s: failed to initialize default policy\n", __func__); 1515 } 1516 1517 static void 1518 def_policy_uninit(const void *unused __unused) 1519 { 1520 1521 if (V_def_policy != NULL) { 1522 key_freesp(&V_def_policy); 1523 key_bumpspgen(); 1524 } 1525 } 1526 1527 VNET_SYSINIT(def_policy_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST, 1528 def_policy_init, NULL); 1529 VNET_SYSUNINIT(def_policy_uninit, SI_SUB_PROTO_DOMAIN, SI_ORDER_FIRST, 1530 def_policy_uninit, NULL); 1531