sys/netinet6/ip6_ipsec.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1988, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include "opt_inet.h"
  34 #include "opt_sctp.h"
  35 #include "opt_ipsec.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/mac.h>
  41 #include <sys/malloc.h>
  42 #include <sys/mbuf.h>
  43 #include <sys/protosw.h>
  44 #include <sys/socket.h>
  45 #include <sys/socketvar.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/syslog.h>
  48
  49 #include <net/if.h>
  50 #include <net/if_var.h>
  51 #include <net/vnet.h>
  52
  53 #include <netinet/in.h>
  54 #include <netinet/in_systm.h>
  55 #include <netinet/in_var.h>
  56 #include <netinet/ip.h>
  57 #include <netinet/ip6.h>
  58 #include <netinet/in_pcb.h>
  59 #include <netinet/ip_var.h>
  60 #include <netinet/ip_options.h>
  61 #ifdef SCTP
  62 #include <netinet/sctp_crc32.h>
  63 #endif
  64
  65 #include <machine/in_cksum.h>
  66
  67 #include <netipsec/ipsec.h>
  68 #include <netipsec/ipsec6.h>
  69 #include <netipsec/xform.h>
  70 #include <netipsec/key.h>
  71 #ifdef IPSEC_DEBUG
  72 #include <netipsec/key_debug.h>
  73 #else
  74 #define KEYDEBUG(lev,arg)
  75 #endif
  76
  77 #include <netinet6/ip6_ipsec.h>
  78 #include <netinet6/ip6_var.h>
  79
  80 extern  struct protosw inet6sw[];
  81
  82 static VNET_DEFINE(int, ip6_ipsec6_filtertunnel) = 0;
  83 #define V_ip6_ipsec6_filtertunnel       VNET(ip6_ipsec6_filtertunnel)
  84
  85 SYSCTL_DECL(_net_inet6_ipsec6);
  86 SYSCTL_INT(_net_inet6_ipsec6, OID_AUTO, filtertunnel,
  87         CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip6_ipsec6_filtertunnel),  0,
  88         "If set filter packets from an IPsec tunnel.");
  89
  90 /*
  91  * Check if we have to jump over firewall processing for this packet.
  92  * Called from ip6_input().
  93  * 1 = jump over firewall, 0 = packet goes through firewall.
  94  */
  95 int
  96 ip6_ipsec_filtertunnel(struct mbuf *m)
  97 {
  98
  99         /*
 100          * Bypass packet filtering for packets previously handled by IPsec.
 101          */
 102         if (!V_ip6_ipsec6_filtertunnel &&
 103             m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL)
 104                 return (1);
 105         return (0);
 106 }
 107
 108 /*
 109  * Check if this packet has an active SA and needs to be dropped instead
 110  * of forwarded.
 111  * Called from ip6_forward().
 112  * 1 = drop packet, 0 = forward packet.
 113  */
 114 int
 115 ip6_ipsec_fwd(struct mbuf *m)
 116 {
 117
 118         return (ipsec6_in_reject(m, NULL));
 119 }
 120
 121 /*
 122  * Check if protocol type doesn't have a further header and do IPSEC
 123  * decryption or reject right now.  Protocols with further headers get
 124  * their IPSEC treatment within the protocol specific processing.
 125  * Called from ip6_input().
 126  * 1 = drop packet, 0 = continue processing packet.
 127  */
 128 int
 129 ip6_ipsec_input(struct mbuf *m, int nxt)
 130 {
 131
 132         /*
 133          * enforce IPsec policy checking if we are seeing last header.
 134          * note that we do not visit this with protocols with pcb layer
 135          * code - like udp/tcp/raw ip.
 136          */
 137         if ((inet6sw[ip6_protox[nxt]].pr_flags & PR_LASTHDR) != 0)
 138                 return (ipsec6_in_reject(m, NULL));
 139         return (0);
 140 }
 141
 142 /*
 143  * Called from ip6_output().
 144  * 1 = drop packet, 0 = continue processing packet,
 145  * -1 = packet was reinjected and stop processing packet
 146  */
 147
 148 int
 149 ip6_ipsec_output(struct mbuf **m, struct inpcb *inp, int *error)
 150 {
 151         struct secpolicy *sp;
 152
 153         /*
 154          * Check the security policy (SP) for the packet and, if
 155          * required, do IPsec-related processing.  There are two
 156          * cases here; the first time a packet is sent through
 157          * it will be untagged and handled by ipsec4_checkpolicy.
 158          * If the packet is resubmitted to ip6_output (e.g. after
 159          * AH, ESP, etc. processing), there will be a tag to bypass
 160          * the lookup and related policy checking.
 161          */
 162         if (m_tag_find(*m, PACKET_TAG_IPSEC_OUT_DONE, NULL) != NULL) {
 163                 *error = 0;
 164                 return (0);
 165         }
 166         sp = ipsec4_checkpolicy(*m, IPSEC_DIR_OUTBOUND, error, inp);
 167         /*
 168          * There are four return cases:
 169          *    sp != NULL                    apply IPsec policy
 170          *    sp == NULL, error == 0        no IPsec handling needed
 171          *    sp == NULL, error == -EINVAL  discard packet w/o error
 172          *    sp == NULL, error != 0        discard packet, report error
 173          */
 174         if (sp != NULL) {
 175                 /*
 176                  * Do delayed checksums now because we send before
 177                  * this is done in the normal processing path.
 178                  */
 179 #ifdef INET
 180                 if ((*m)->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 181                         in_delayed_cksum(*m);
 182                         (*m)->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 183                 }
 184 #endif
 185                 if ((*m)->m_pkthdr.csum_flags & CSUM_DELAY_DATA_IPV6) {
 186                         in6_delayed_cksum(*m, (*m)->m_pkthdr.len - sizeof(struct ip6_hdr),
 187                                                         sizeof(struct ip6_hdr));
 188                         (*m)->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA_IPV6;
 189                 }
 190 #ifdef SCTP
 191                 if ((*m)->m_pkthdr.csum_flags & CSUM_SCTP_IPV6) {
 192                         sctp_delayed_cksum(*m, sizeof(struct ip6_hdr));
 193                         (*m)->m_pkthdr.csum_flags &= ~CSUM_SCTP_IPV6;
 194                 }
 195 #endif
 196
 197                 /* NB: callee frees mbuf */
 198                 *error = ipsec6_process_packet(*m, sp->req);
 199                 KEY_FREESP(&sp);
 200                 if (*error == EJUSTRETURN) {
 201                         /*
 202                          * We had a SP with a level of 'use' and no SA. We
 203                          * will just continue to process the packet without
 204                          * IPsec processing.
 205                          */
 206                         *error = 0;
 207                         goto done;
 208                 }
 209
 210                 /*
 211                  * Preserve KAME behaviour: ENOENT can be returned
 212                  * when an SA acquire is in progress.  Don't propagate
 213                  * this to user-level; it confuses applications.
 214                  *
 215                  * XXX this will go away when the SADB is redone.
 216                  */
 217                 if (*error == ENOENT)
 218                         *error = 0;
 219                 goto reinjected;
 220         } else {        /* sp == NULL */
 221                 if (*error != 0) {
 222                         /*
 223                          * Hack: -EINVAL is used to signal that a packet
 224                          * should be silently discarded.  This is typically
 225                          * because we asked key management for an SA and
 226                          * it was delayed (e.g. kicked up to IKE).
 227                          */
 228                         if (*error == -EINVAL)
 229                                 *error = 0;
 230                         goto bad;
 231                 }
 232                 /* No IPsec processing for this packet. */
 233         }
 234 done:
 235         return (0);
 236 reinjected:
 237         return (-1);
 238 bad:
 239         if (sp != NULL)
 240                 KEY_FREESP(&sp);
 241         return (1);
 242 }
 243
 244 #if 0
 245 /*
 246  * Compute the MTU for a forwarded packet that gets IPSEC encapsulated.
 247  * Called from ip_forward().
 248  * Returns MTU suggestion for ICMP needfrag reply.
 249  */
 250 int
 251 ip6_ipsec_mtu(struct mbuf *m)
 252 {
 253         int mtu = 0;
 254         /*
 255          * If the packet is routed over IPsec tunnel, tell the
 256          * originator the tunnel MTU.
 257          *      tunnel MTU = if MTU - sizeof(IP) - ESP/AH hdrsiz
 258          * XXX quickhack!!!
 259          */
 260 #ifdef IPSEC
 261         struct secpolicy *sp = NULL;
 262         int ipsecerror;
 263         int ipsechdr;
 264         struct route *ro;
 265         sp = ipsec_getpolicybyaddr(m,
 266                                    IPSEC_DIR_OUTBOUND,
 267                                    IP_FORWARDING,
 268                                    &ipsecerror);
 269         if (sp != NULL) {
 270                 /* count IPsec header size */
 271                 ipsechdr = ipsec_hdrsiz(m, IPSEC_DIR_OUTBOUND, NULL);
 272
 273                 /*
 274                  * find the correct route for outer IPv4
 275                  * header, compute tunnel MTU.
 276                  */
 277                 if (sp->req != NULL &&
 278                     sp->req->sav != NULL &&
 279                     sp->req->sav->sah != NULL) {
 280                         ro = &sp->req->sav->sah->route_cache.sa_route;
 281                         if (ro->ro_rt && ro->ro_rt->rt_ifp) {
 282                                 mtu = ro->ro_rt->rt_mtu ? ro->ro_rt->rt_mtu :
 283                                     ro->ro_rt->rt_ifp->if_mtu;
 284                                 mtu -= ipsechdr;
 285                         }
 286                 }
 287                 KEY_FREESP(&sp);
 288         }
 289 #endif /* IPSEC */
 290         /* XXX else case missing. */
 291         return mtu;
 292 }
 293 #endif