/*

 * Copyright (c) 2008-2020 Apple Inc. All rights reserved.

 *

 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

 *

 * This file contains Original Code and/or Modifications of Original Code

 * as defined in and that are subject to the Apple Public Source License

 * Version 2.0 (the 'License'). You may not use this file except in

 * compliance with the License. The rights granted to you under the License

 * may not be used to create, or enable the creation or redistribution of,

 * unlawful or unlicensed copies of an Apple operating system, or to

 * circumvent, violate, or enable the circumvention or violation of, any

 * terms of an Apple operating system software license agreement.

 *

 * Please obtain a copy of the License at

 * http://www.opensource.apple.com/apsl/ and read it before using this file.

 *

 * The Original Code and all software distributed under the License are

 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,

 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.

 * Please see the License for the specific language governing rights and

 * limitations under the License.

 *

 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

 */

/*  $FreeBSD: src/sys/netkey/key.c,v 1.16.2.13 2002/07/24 18:17:40 ume Exp $  */

/*  $KAME: key.c,v 1.191 2001/06/27 10:46:49 sakane Exp $ */

/*

 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the project nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/*

 * This code is referd to RFC 2367

 */

#include <machine/endian.h>

#include <sys/types.h>

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/kernel.h>

#include <sys/mbuf.h>

#include <sys/domain.h>

#include <sys/protosw.h>

#include <sys/malloc.h>

#include <sys/socket.h>

#include <sys/socketvar.h>

#include <sys/sysctl.h>

#include <sys/errno.h>

#include <sys/proc.h>

#include <sys/queue.h>

#include <sys/syslog.h>

#include <sys/mcache.h>

#include <kern/locks.h>

#include <net/if.h>

#include <net/route.h>

#include <net/raw_cb.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/in_var.h>

#include <netinet/ip6.h>

#include <netinet6/in6_var.h>

#include <netinet6/ip6_var.h>

#include <net/pfkeyv2.h>

#include <netkey/keydb.h>

#include <netkey/key.h>

#include <netkey/keysock.h>

#include <netkey/key_debug.h>

#include <stdarg.h>

#include <libkern/crypto/rand.h>

#include <netinet6/ipsec.h>

#include <netinet6/ipsec6.h>

#include <netinet6/ah.h>

#include <netinet6/ah6.h>

#if IPSEC_ESP

#include <netinet6/esp.h>

#include <netinet6/esp6.h>

#endif

/* randomness */

#include <sys/random.h>

#include <net/net_osdep.h>

#define FULLMASK        0xff

lck_grp_t         *sadb_mutex_grp;

lck_grp_attr_t    *sadb_mutex_grp_attr;

lck_attr_t        *sadb_mutex_attr;

decl_lck_mtx_data(, sadb_mutex_data);

lck_mtx_t         *sadb_mutex = &sadb_mutex_data;

lck_grp_t         *pfkey_stat_mutex_grp;

lck_grp_attr_t    *pfkey_stat_mutex_grp_attr;

lck_attr_t        *pfkey_stat_mutex_attr;

decl_lck_mtx_data(, pfkey_stat_mutex_data);

lck_mtx_t         *pfkey_stat_mutex = &pfkey_stat_mutex_data;

/*

 * Note on SA reference counting:

 * - SAs that are not in DEAD state will have (total external reference + 1)

 *   following value in reference count field.  they cannot be freed and are

 *   referenced from SA header.

 * - SAs that are in DEAD state will have (total external reference)

 *   in reference count field.  they are ready to be freed.  reference from

 *   SA header will be removed in key_delsav(), when the reference count

 *   field hits 0 (= no external reference other than from SA header.

 */

u_int32_t key_debug_level = 0; //### our sysctl is not dynamic

static int key_timehandler_running = 0;

static u_int key_spi_trycnt = 1000;

static u_int32_t key_spi_minval = 0x100;

static u_int32_t key_spi_maxval = 0x0fffffff;   /* XXX */

static u_int32_t policy_id = 0;

static u_int key_int_random = 60;       /*interval to initialize randseed,1(m)*/

static u_int key_larval_lifetime = 30;  /* interval to expire acquiring, 30(s)*/

static int key_blockacq_count = 10;     /* counter for blocking SADB_ACQUIRE.*/

static int key_blockacq_lifetime = 20;  /* lifetime for blocking SADB_ACQUIRE.*/

static int key_preferred_oldsa = 0;     /* preferred old sa rather than new sa.*/

__private_extern__ int natt_keepalive_interval = 20;    /* interval between natt keepalives.*/

static u_int32_t ipsec_policy_count = 0;

static u_int32_t ipsec_sav_count = 0;

static u_int32_t acq_seq = 0;

static int key_tick_init_random = 0;

static u_int64_t up_time = 0;

__private_extern__ u_int64_t natt_now = 0;

static LIST_HEAD(_sptree, secpolicy) sptree[IPSEC_DIR_MAX];     /* SPD */

static LIST_HEAD(_sahtree, secashead) sahtree;                  /* SAD */

static LIST_HEAD(_regtree, secreg) regtree[SADB_SATYPE_MAX + 1];

static LIST_HEAD(_custom_sahtree, secashead) custom_sahtree;

/* registed list */

#define SPIHASHSIZE     128

#define SPIHASH(x)      (((x) ^ ((x) >> 16)) % SPIHASHSIZE)

static LIST_HEAD(_spihash, secasvar) spihash[SPIHASHSIZE];

#ifndef IPSEC_NONBLOCK_ACQUIRE

static LIST_HEAD(_acqtree, secacq) acqtree;             /* acquiring list */

#endif

static LIST_HEAD(_spacqtree, secspacq) spacqtree;       /* SP acquiring list */

struct key_cb key_cb;

/* search order for SAs */

static const u_int saorder_state_valid_prefer_old[] = {

  SADB_SASTATE_DYING, SADB_SASTATE_MATURE,

};

static const u_int saorder_state_valid_prefer_new[] = {

  SADB_SASTATE_MATURE, SADB_SASTATE_DYING,

};

static const u_int saorder_state_alive[] = {

  /* except DEAD */

  SADB_SASTATE_MATURE, SADB_SASTATE_DYING, SADB_SASTATE_LARVAL

};

static const u_int saorder_state_any[] = {

  SADB_SASTATE_MATURE, SADB_SASTATE_DYING,

  SADB_SASTATE_LARVAL, SADB_SASTATE_DEAD

};

static const int minsize[] = {

  sizeof(struct sadb_msg),        /* SADB_EXT_RESERVED */

  sizeof(struct sadb_sa),         /* SADB_EXT_SA */

  sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_CURRENT */

  sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_HARD */

  sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_SOFT */

  sizeof(struct sadb_address),    /* SADB_EXT_ADDRESS_SRC */

  sizeof(struct sadb_address),    /* SADB_EXT_ADDRESS_DST */

  sizeof(struct sadb_address),    /* SADB_EXT_ADDRESS_PROXY */

  sizeof(struct sadb_key),        /* SADB_EXT_KEY_AUTH */

  sizeof(struct sadb_key),        /* SADB_EXT_KEY_ENCRYPT */

  sizeof(struct sadb_ident),      /* SADB_EXT_IDENTITY_SRC */

  sizeof(struct sadb_ident),      /* SADB_EXT_IDENTITY_DST */

  sizeof(struct sadb_sens),       /* SADB_EXT_SENSITIVITY */

  sizeof(struct sadb_prop),       /* SADB_EXT_PROPOSAL */

  sizeof(struct sadb_supported),  /* SADB_EXT_SUPPORTED_AUTH */

  sizeof(struct sadb_supported),  /* SADB_EXT_SUPPORTED_ENCRYPT */

  sizeof(struct sadb_spirange),   /* SADB_EXT_SPIRANGE */

  0,                              /* SADB_X_EXT_KMPRIVATE */

  sizeof(struct sadb_x_policy),   /* SADB_X_EXT_POLICY */

  sizeof(struct sadb_x_sa2),      /* SADB_X_SA2 */

  sizeof(struct sadb_session_id), /* SADB_EXT_SESSION_ID */

  sizeof(struct sadb_sastat),     /* SADB_EXT_SASTAT */

  sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_IPSECIF */

  sizeof(struct sadb_address),    /* SADB_X_EXT_ADDR_RANGE_SRC_START */

  sizeof(struct sadb_address),    /* SADB_X_EXT_ADDR_RANGE_SRC_END */

  sizeof(struct sadb_address),    /* SADB_X_EXT_ADDR_RANGE_DST_START */

  sizeof(struct sadb_address),    /* SADB_X_EXT_ADDR_RANGE_DST_END */

  sizeof(struct sadb_address),    /* SADB_EXT_MIGRATE_ADDRESS_SRC */

  sizeof(struct sadb_address),    /* SADB_EXT_MIGRATE_ADDRESS_DST */

  sizeof(struct sadb_x_ipsecif),  /* SADB_X_EXT_MIGRATE_IPSECIF */

};

static const int maxsize[] = {

  sizeof(struct sadb_msg),        /* SADB_EXT_RESERVED */

  sizeof(struct sadb_sa_2),               /* SADB_EXT_SA */

  sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_CURRENT */

  sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_HARD */

  sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_SOFT */

  0,                              /* SADB_EXT_ADDRESS_SRC */

  0,                              /* SADB_EXT_ADDRESS_DST */

  0,                              /* SADB_EXT_ADDRESS_PROXY */

  0,                              /* SADB_EXT_KEY_AUTH */

  0,                              /* SADB_EXT_KEY_ENCRYPT */

  0,                              /* SADB_EXT_IDENTITY_SRC */

  0,                              /* SADB_EXT_IDENTITY_DST */

  0,                              /* SADB_EXT_SENSITIVITY */

  0,                              /* SADB_EXT_PROPOSAL */

  0,                              /* SADB_EXT_SUPPORTED_AUTH */

  0,                              /* SADB_EXT_SUPPORTED_ENCRYPT */

  sizeof(struct sadb_spirange),   /* SADB_EXT_SPIRANGE */

  0,                              /* SADB_X_EXT_KMPRIVATE */

  0,                              /* SADB_X_EXT_POLICY */

  sizeof(struct sadb_x_sa2),      /* SADB_X_SA2 */

  0,                              /* SADB_EXT_SESSION_ID */

  0,                              /* SADB_EXT_SASTAT */

  sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_IPSECIF */

  0,          /* SADB_X_EXT_ADDR_RANGE_SRC_START */

  0,              /* SADB_X_EXT_ADDR_RANGE_SRC_END */

  0,          /* SADB_X_EXT_ADDR_RANGE_DST_START */

  0,              /* SADB_X_EXT_ADDR_RANGE_DST_END */

  0,              /* SADB_EXT_MIGRATE_ADDRESS_SRC */

  0,              /* SADB_EXT_MIGRATE_ADDRESS_DST */

  sizeof(struct sadb_x_ipsecif), /* SADB_X_EXT_MIGRATE_IPSECIF */

};

static int ipsec_esp_keymin = 256;

static int ipsec_esp_auth = 0;

static int ipsec_ah_keymin = 128;

SYSCTL_DECL(_net_key);

/* Thread safe: no accumulated state */

SYSCTL_INT(_net_key, KEYCTL_DEBUG_LEVEL, debug, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_debug_level, 0, "");

/* max count of trial for the decision of spi value */

SYSCTL_INT(_net_key, KEYCTL_SPI_TRY, spi_trycnt, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_spi_trycnt, 0, "");

/* minimum spi value to allocate automatically. */

SYSCTL_INT(_net_key, KEYCTL_SPI_MIN_VALUE, spi_minval, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_spi_minval, 0, "");

/* maximun spi value to allocate automatically. */

SYSCTL_INT(_net_key, KEYCTL_SPI_MAX_VALUE, spi_maxval, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_spi_maxval, 0, "");

/* interval to initialize randseed */

SYSCTL_INT(_net_key, KEYCTL_RANDOM_INT, int_random, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_int_random, 0, "");

/* lifetime for larval SA; thread safe due to > compare */

SYSCTL_INT(_net_key, KEYCTL_LARVAL_LIFETIME, larval_lifetime, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_larval_lifetime, 0, "");

/* counter for blocking to send SADB_ACQUIRE to IKEd */

SYSCTL_INT(_net_key, KEYCTL_BLOCKACQ_COUNT, blockacq_count, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_blockacq_count, 0, "");

/* lifetime for blocking to send SADB_ACQUIRE to IKEd: Thread safe, > compare */

SYSCTL_INT(_net_key, KEYCTL_BLOCKACQ_LIFETIME, blockacq_lifetime, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_blockacq_lifetime, 0, "");

/* ESP auth */

SYSCTL_INT(_net_key, KEYCTL_ESP_AUTH, esp_auth, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &ipsec_esp_auth, 0, "");

/* minimum ESP key length */

SYSCTL_INT(_net_key, KEYCTL_ESP_KEYMIN, esp_keymin, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &ipsec_esp_keymin, 0, "");

/* minimum AH key length */

SYSCTL_INT(_net_key, KEYCTL_AH_KEYMIN, ah_keymin, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &ipsec_ah_keymin, 0, "");

/* perfered old SA rather than new SA */

SYSCTL_INT(_net_key, KEYCTL_PREFERED_OLDSA, prefered_oldsa, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &key_preferred_oldsa, 0, "");

/* time between NATT keepalives in seconds, 0 disabled  */

SYSCTL_INT(_net_key, KEYCTL_NATT_KEEPALIVE_INTERVAL, natt_keepalive_interval, CTLFLAG_RW | CTLFLAG_LOCKED, \

        &natt_keepalive_interval, 0, "");

/* PF_KEY statistics */

SYSCTL_STRUCT(_net_key, KEYCTL_PFKEYSTAT, pfkeystat, CTLFLAG_RD | CTLFLAG_LOCKED, \

        &pfkeystat, pfkeystat, "");

#ifndef LIST_FOREACH

#define LIST_FOREACH(elm, head, field)                                     \

for (elm = LIST_FIRST(head); elm; elm = LIST_NEXT(elm, field))

#endif

#define __LIST_CHAINED(elm) \

(!((elm)->chain.le_next == NULL && (elm)->chain.le_prev == NULL))

#define LIST_INSERT_TAIL(head, elm, type, field) \

do {\

struct type *curelm = LIST_FIRST(head); \

if (curelm == NULL) {\

LIST_INSERT_HEAD(head, elm, field); \

} else { \

while (LIST_NEXT(curelm, field)) \

curelm = LIST_NEXT(curelm, field);\

LIST_INSERT_AFTER(curelm, elm, field);\

}\

} while (0)

#define KEY_CHKSASTATE(head, sav, name) \

do { \

if ((head) != (sav)) {                                          \

ipseclog((LOG_DEBUG, "%s: state mismatched (TREE=%d SA=%d)\n", \

(name), (head), (sav)));                        \

continue;                                               \

}                                                               \

} while (0)

#define KEY_CHKSPDIR(head, sp, name) \

do { \

if ((head) != (sp)) {                                           \

ipseclog((LOG_DEBUG, "%s: direction mismatched (TREE=%d SP=%d), " \

"anyway continue.\n",                           \

(name), (head), (sp)));                         \

}                                                               \

} while (0)

#if 1

#define KMALLOC_WAIT(p, t, n)                                                     \

((p) = (t) _MALLOC((n), M_SECA, M_WAITOK))

#define KMALLOC_NOWAIT(p, t, n)                                              \

((p) = (t) _MALLOC((n), M_SECA, M_NOWAIT))

#define KFREE(p)                                                             \

_FREE((caddr_t)(p), M_SECA);

#else

#define KMALLOC_WAIT(p, t, n) \

do { \

((p) = (t)_MALLOC((u_int32_t)(n), M_SECA, M_WAITOK));             \

printf("%s %d: %p <- KMALLOC_WAIT(%s, %d)\n",                             \

__FILE__, __LINE__, (p), #t, n);                             \

} while (0)

#define KMALLOC_NOWAIT(p, t, n) \

do { \

((p) = (t)_MALLOC((u_int32_t)(n), M_SECA, M_NOWAIT));             \

printf("%s %d: %p <- KMALLOC_NOWAIT(%s, %d)\n",                             \

__FILE__, __LINE__, (p), #t, n);                             \

} while (0)

#define KFREE(p)                                                             \

do {                                                                 \

printf("%s %d: %p -> KFREE()\n", __FILE__, __LINE__, (p));   \

_FREE((caddr_t)(p), M_SECA);                                  \

} while (0)

#endif

/*

 * set parameters into secpolicyindex buffer.

 * Must allocate secpolicyindex buffer passed to this function.

 */

#define KEY_SETSECSPIDX(_dir, s, d, ps, pd, ulp, ifp, s_s, s_e, d_s, d_e, idx) \

do { \

bzero((idx), sizeof(struct secpolicyindex));                         \

(idx)->dir = (_dir);                                                 \

(idx)->prefs = (ps);                                                 \

(idx)->prefd = (pd);                                                 \

(idx)->ul_proto = (ulp);                                             \

(idx)->internal_if = (ifp);                                          \

if (s) bcopy((s), &(idx)->src, ((struct sockaddr *)(s))->sa_len);    \

if (d) bcopy((d), &(idx)->dst, ((struct sockaddr *)(d))->sa_len);    \

if (s_s) bcopy((s_s), &(idx)->src_range.start, ((struct sockaddr *)(s_s))->sa_len);   \

if (s_e) bcopy((s_e), &(idx)->src_range.end, ((struct sockaddr *)(s_e))->sa_len);     \

if (d_s) bcopy((d_s), &(idx)->dst_range.start, ((struct sockaddr *)(d_s))->sa_len);   \

if (d_e) bcopy((d_e), &(idx)->dst_range.end, ((struct sockaddr *)(d_e))->sa_len);     \

} while (0)

/*

 * set parameters into secasindex buffer.

 * Must allocate secasindex buffer before calling this function.

 */

#define KEY_SETSECASIDX(p, m, r, s, d, ifi, idx) \

do { \

bzero((idx), sizeof(struct secasindex));                             \

(idx)->proto = (p);                                                  \

(idx)->mode = (m);                                                   \

(idx)->reqid = (r);                                                  \

bcopy((s), &(idx)->src, ((const struct sockaddr *)(s))->sa_len);           \

bcopy((d), &(idx)->dst, ((const struct sockaddr *)(d))->sa_len);           \

(idx)->ipsec_ifindex = (ifi);                                                                           \

} while (0)

/* key statistics */

struct _keystat {

  u_int32_t getspi_count; /* the avarage of count to try to get new SPI */

} keystat;

struct sadb_msghdr {

  struct sadb_msg *msg;

  struct sadb_ext *ext[SADB_EXT_MAX + 1];

  int extoff[SADB_EXT_MAX + 1];

  int extlen[SADB_EXT_MAX + 1];

};

static struct secpolicy *__key_getspbyid(u_int32_t id);

static struct secasvar *key_do_allocsa_policy(struct secashead *, u_int, u_int16_t);

static int key_do_get_translated_port(struct secashead *, struct secasvar *, u_int);

static void key_delsp(struct secpolicy *);

static struct secpolicy *key_getsp(struct secpolicyindex *);

static u_int16_t key_newreqid(void);

static struct mbuf *key_gather_mbuf(struct mbuf *,

    const struct sadb_msghdr *, int, int, int *);

static int key_spdadd(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static u_int32_t key_getnewspid(void);

static int key_spddelete(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_spddelete2(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_spdenable(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_spddisable(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_spdget(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_spdflush(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_spddump(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static struct mbuf *key_setdumpsp(struct secpolicy *,

    u_int8_t, u_int32_t, u_int32_t);

static u_int key_getspreqmsglen(struct secpolicy *);

static int key_spdexpire(struct secpolicy *);

static struct secashead *key_newsah(struct secasindex *, ifnet_t, u_int, u_int8_t, u_int16_t);

static struct secasvar *key_newsav(struct mbuf *,

    const struct sadb_msghdr *, struct secashead *, int *,

    struct socket *);

static struct secashead *key_getsah(struct secasindex *, u_int16_t);

static struct secasvar *key_checkspidup(struct secasindex *, u_int32_t);

static void key_setspi __P((struct secasvar *, u_int32_t));

static struct secasvar *key_getsavbyspi(struct secashead *, u_int32_t);

static int key_setsaval(struct secasvar *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_mature(struct secasvar *);

static struct mbuf *key_setdumpsa(struct secasvar *, u_int8_t,

    u_int8_t, u_int32_t, u_int32_t);

static struct mbuf *key_setsadbmsg(u_int8_t, u_int16_t, u_int8_t,

    u_int32_t, pid_t, u_int16_t);

static struct mbuf *key_setsadbsa(struct secasvar *);

static struct mbuf *key_setsadbaddr(u_int16_t,

    struct sockaddr *, size_t, u_int8_t);

static struct mbuf *key_setsadbipsecif(ifnet_t, ifnet_t, ifnet_t, u_int8_t);

static struct mbuf *key_setsadbxsa2(u_int8_t, u_int32_t, u_int32_t, u_int16_t);

static struct mbuf *key_setsadbxpolicy(u_int16_t, u_int8_t,

    u_int32_t);

static void *key_newbuf(const void *, u_int);

static int key_ismyaddr6(struct sockaddr_in6 *);

static void key_update_natt_keepalive_timestamp(struct secasvar *, struct secasvar *);

/* flags for key_cmpsaidx() */

#define CMP_HEAD        0x1     /* protocol, addresses. */

#define CMP_PORT        0x2     /* additionally HEAD, reqid, mode. */

#define CMP_REQID       0x4     /* additionally HEAD, reqid. */

#define CMP_MODE        0x8       /* additionally mode. */

#define CMP_EXACTLY     0xF     /* all elements. */

static int key_cmpsaidx(struct secasindex *, struct secasindex *, int);

static int key_cmpspidx_exactly(struct secpolicyindex *,

    struct secpolicyindex *);

static int key_cmpspidx_withmask(struct secpolicyindex *,

    struct secpolicyindex *);

static int key_sockaddrcmp(struct sockaddr *, struct sockaddr *, int);

static int key_is_addr_in_range(struct sockaddr_storage *, struct secpolicyaddrrange *);

static int key_bbcmp(caddr_t, caddr_t, u_int);

static void key_srandom(void);

static u_int8_t key_satype2proto(u_int8_t);

static u_int8_t key_proto2satype(u_int16_t);

static int key_getspi(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static u_int32_t key_do_getnewspi(struct sadb_spirange *, struct secasindex *);

static int key_update(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_add(struct socket *, struct mbuf *, const struct sadb_msghdr *);

static struct mbuf *key_getmsgbuf_x1(struct mbuf *, const struct sadb_msghdr *);

static int key_delete(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_get(struct socket *, struct mbuf *, const struct sadb_msghdr *);

static void key_getcomb_setlifetime(struct sadb_comb *);

#if IPSEC_ESP

static struct mbuf *key_getcomb_esp(void);

#endif

static struct mbuf *key_getcomb_ah(void);

static struct mbuf *key_getprop(const struct secasindex *);

static int key_acquire(struct secasindex *, struct secpolicy *);

#ifndef IPSEC_NONBLOCK_ACQUIRE

static struct secacq *key_newacq(struct secasindex *);

static struct secacq *key_getacq(struct secasindex *);

static struct secacq *key_getacqbyseq(u_int32_t);

#endif

static struct secspacq *key_newspacq(struct secpolicyindex *);

static struct secspacq *key_getspacq(struct secpolicyindex *);

static int key_acquire2(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_register(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_expire(struct secasvar *);

static int key_flush(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_dump(struct socket *, struct mbuf *, const struct sadb_msghdr *);

static int key_promisc(struct socket *, struct mbuf *,

    const struct sadb_msghdr *);

static int key_senderror(struct socket *, struct mbuf *, int);

static int key_validate_ext(const struct sadb_ext *, int);

static int key_align(struct mbuf *, struct sadb_msghdr *);

static struct mbuf *key_alloc_mbuf(int);

static int key_getsastat(struct socket *, struct mbuf *, const struct sadb_msghdr *);

static int key_migrate(struct socket *, struct mbuf *, const struct sadb_msghdr *);

static void bzero_keys(const struct sadb_msghdr *);

extern int ipsec_bypass;

extern int esp_udp_encap_port;

int ipsec_send_natt_keepalive(struct secasvar *sav);

bool ipsec_fill_offload_frame(ifnet_t ifp, struct secasvar *sav, struct ifnet_keepalive_offload_frame *frame, size_t frame_data_offset);

void key_init(struct protosw *, struct domain *);

/*

 * PF_KEY init

 * setup locks, call raw_init(), and then init timer and associated data

 *

 */

void

key_init(struct protosw *pp, struct domain *dp)

{

  static int key_initialized = 0;

  int i;

  VERIFY((pp->pr_flags & (PR_INITIALIZED | PR_ATTACHED)) == PR_ATTACHED);

  _CASSERT(PFKEY_ALIGN8(sizeof(struct sadb_msg)) <= _MHLEN);

  _CASSERT(MAX_REPLAY_WINDOWS == MBUF_TC_MAX);

  if (key_initialized) {

    return;

  }

  key_initialized = 1;

  sadb_mutex_grp_attr = lck_grp_attr_alloc_init();

  sadb_mutex_grp = lck_grp_alloc_init("sadb", sadb_mutex_grp_attr);

  sadb_mutex_attr = lck_attr_alloc_init();

  lck_mtx_init(sadb_mutex, sadb_mutex_grp, sadb_mutex_attr);

  pfkey_stat_mutex_grp_attr = lck_grp_attr_alloc_init();

  pfkey_stat_mutex_grp = lck_grp_alloc_init("pfkey_stat", pfkey_stat_mutex_grp_attr);

  pfkey_stat_mutex_attr = lck_attr_alloc_init();

  lck_mtx_init(pfkey_stat_mutex, pfkey_stat_mutex_grp, pfkey_stat_mutex_attr);

  for (i = 0; i < SPIHASHSIZE; i++) {

    LIST_INIT(&spihash[i]);

  }

  raw_init(pp, dp);

  bzero((caddr_t)&key_cb, sizeof(key_cb));

  for (i = 0; i < IPSEC_DIR_MAX; i++) {

    LIST_INIT(&sptree[i]);

  }

  ipsec_policy_count = 0;

  LIST_INIT(&sahtree);

  LIST_INIT(&custom_sahtree);

  for (i = 0; i <= SADB_SATYPE_MAX; i++) {

    LIST_INIT(&regtree[i]);

  }

  ipsec_sav_count = 0;

#ifndef IPSEC_NONBLOCK_ACQUIRE

  LIST_INIT(&acqtree);

#endif

  LIST_INIT(&spacqtree);

  /* system default */

#if INET

  ip4_def_policy.policy = IPSEC_POLICY_NONE;

  ip4_def_policy.refcnt++;        /*never reclaim this*/

#endif

  ip6_def_policy.policy = IPSEC_POLICY_NONE;

  ip6_def_policy.refcnt++;        /*never reclaim this*/

  key_timehandler_running = 0;

  /* initialize key statistics */

  keystat.getspi_count = 1;

  esp_init();

#ifndef __APPLE__

  printf("IPsec: Initialized Security Association Processing.\n");

#endif

}

static void

key_start_timehandler(void)

{

  /* must be called while locked */

  LCK_MTX_ASSERT(sadb_mutex, LCK_MTX_ASSERT_OWNED);

  if (key_timehandler_running == 0) {

    key_timehandler_running = 1;

    (void)timeout((void *)key_timehandler, (void *)0, hz);

  }

  /* Turn off the ipsec bypass */

  if (ipsec_bypass != 0) {

    ipsec_bypass = 0;

  }

}

/* %%% IPsec policy management */

/*

 * allocating a SP for OUTBOUND or INBOUND packet.

 * Must call key_freesp() later.

 * OUT: NULL: not found

 *  others: found and return the pointer.

 */

struct secpolicy *

key_allocsp(

  struct secpolicyindex *spidx,

  u_int dir)

{

  struct secpolicy *sp;

  struct timeval tv;

  LCK_MTX_ASSERT(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);

  /* sanity check */

  if (spidx == NULL) {

    panic("key_allocsp: NULL pointer is passed.\n");

  }

  /* check direction */

  switch (dir) {

  case IPSEC_DIR_INBOUND:

  case IPSEC_DIR_OUTBOUND:

    break;

  default:

    panic("key_allocsp: Invalid direction is passed.\n");

  }

  /* get a SP entry */

  KEYDEBUG(KEYDEBUG_IPSEC_DATA,

      printf("*** objects\n");

      kdebug_secpolicyindex(spidx));

  lck_mtx_lock(sadb_mutex);

  LIST_FOREACH(sp, &sptree[dir], chain) {

    KEYDEBUG(KEYDEBUG_IPSEC_DATA,

        printf("*** in SPD\n");

        kdebug_secpolicyindex(&sp->spidx));

    if (sp->state == IPSEC_SPSTATE_DEAD) {

      continue;

    }

    /* If the policy is disabled, skip */

    if (sp->disabled > 0) {

      continue;

    }

    /* If the incoming spidx specifies bound if,

     *  ignore unbound policies*/

    if (spidx->internal_if != NULL

        && (sp->spidx.internal_if == NULL || sp->ipsec_if == NULL)) {

      continue;

    }

    if (key_cmpspidx_withmask(&sp->spidx, spidx)) {

      goto found;

    }

  }

  lck_mtx_unlock(sadb_mutex);

  return NULL;

found:

  /* found a SPD entry */

  microtime(&tv);

  sp->lastused = tv.tv_sec;

  sp->refcnt++;

  lck_mtx_unlock(sadb_mutex);

  /* sanity check */

  KEY_CHKSPDIR(sp->spidx.dir, dir, "key_allocsp");

  KEYDEBUG(KEYDEBUG_IPSEC_STAMP,

      printf("DP key_allocsp cause refcnt++:%d SP:0x%llx\n",

      sp->refcnt, (uint64_t)VM_KERNEL_ADDRPERM(sp)));

  return sp;

}

/*

 * return a policy that matches this particular inbound packet.

 * XXX slow

 */

struct secpolicy *

key_gettunnel(

  struct sockaddr *osrc,

  struct sockaddr *odst,

  struct sockaddr *isrc,

  struct sockaddr *idst)

{

  struct secpolicy *sp;

  const int dir = IPSEC_DIR_INBOUND;

  struct timeval tv;

  struct ipsecrequest *r1, *r2, *p;

  struct sockaddr *os, *od, *is, *id;

  struct secpolicyindex spidx;

  if (isrc->sa_family != idst->sa_family) {

    ipseclog((LOG_ERR, "protocol family mismatched %d != %d\n.",

        isrc->sa_family, idst->sa_family));

    return NULL;

  }

  lck_mtx_lock(sadb_mutex);

  LIST_FOREACH(sp, &sptree[dir], chain) {

    if (sp->state == IPSEC_SPSTATE_DEAD) {

      continue;

    }

    r1 = r2 = NULL;

    for (p = sp->req; p; p = p->next) {

      if (p->saidx.mode != IPSEC_MODE_TUNNEL) {

        continue;

      }

      r1 = r2;

      r2 = p;

      if (!r1) {

        /* here we look at address matches only */

        spidx = sp->spidx;

        if (isrc->sa_len > sizeof(spidx.src) ||

            idst->sa_len > sizeof(spidx.dst)) {

          continue;

        }

        bcopy(isrc, &spidx.src, isrc->sa_len);

        bcopy(idst, &spidx.dst, idst->sa_len);

        if (!key_cmpspidx_withmask(&sp->spidx, &spidx)) {

          continue;

        }

      } else {

        is = (struct sockaddr *)&r1->saidx.src;

        id = (struct sockaddr *)&r1->saidx.dst;

        if (key_sockaddrcmp(is, isrc, 0) ||

            key_sockaddrcmp(id, idst, 0)) {

          continue;

        }

      }

      os = (struct sockaddr *)&r2->saidx.src;

      od = (struct sockaddr *)&r2->saidx.dst;

      if (key_sockaddrcmp(os, osrc, 0) ||

          key_sockaddrcmp(od, odst, 0)) {

        continue;

      }

      goto found;

    }

  }

  lck_mtx_unlock(sadb_mutex);

  return NULL;

found:

  microtime(&tv);

  sp->lastused = tv.tv_sec;

  sp->refcnt++;

  lck_mtx_unlock(sadb_mutex);

  return sp;

}

struct secasvar *

key_alloc_outbound_sav_for_interface(ifnet_t interface, int family,

    struct sockaddr *src,

    struct sockaddr *dst)

{

  struct secashead *sah;

  struct secasvar *sav;

  u_int stateidx;

  u_int state;

  const u_int *saorder_state_valid;

  int arraysize;

  struct sockaddr_in *sin;

  u_int16_t dstport;

  bool strict = true;

  if (interface == NULL) {

    return NULL;

  }

  LCK_MTX_ASSERT(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);

  lck_mtx_lock(sadb_mutex);

  do {

    LIST_FOREACH(sah, &sahtree, chain) {

      if (sah->state == SADB_SASTATE_DEAD) {

        continue;

      }

      if (sah->ipsec_if == interface &&

          (family == AF_INET6 || family == AF_INET) &&

          sah->dir == IPSEC_DIR_OUTBOUND) {

        if (strict &&

            sah->saidx.mode == IPSEC_MODE_TRANSPORT &&

            src != NULL && dst != NULL) {

          // Validate addresses for transport mode

          if (key_sockaddrcmp((struct sockaddr *)&sah->saidx.src, src, 0) != 0) {

            // Source doesn't match

            continue;

          }

          if (key_sockaddrcmp((struct sockaddr *)&sah->saidx.dst, dst, 0) != 0) {

            // Destination doesn't match

            continue;

          }

        }

        /* This SAH is linked to the IPsec interface, and the right family. We found it! */

        if (key_preferred_oldsa) {

          saorder_state_valid = saorder_state_valid_prefer_old;

          arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);

        } else {

          saorder_state_valid = saorder_state_valid_prefer_new;

          arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);

        }

        sin = (struct sockaddr_in *)&sah->saidx.dst;

        dstport = sin->sin_port;

        if (sah->saidx.mode == IPSEC_MODE_TRANSPORT) {

          sin->sin_port = IPSEC_PORT_ANY;

        }

        for (stateidx = 0; stateidx < arraysize; stateidx++) {

          state = saorder_state_valid[stateidx];

          sav = key_do_allocsa_policy(sah, state, dstport);

          if (sav != NULL) {

            lck_mtx_unlock(sadb_mutex);

            return sav;

          }

        }

        break;

      }

    }

    if (strict) {

      // If we didn't find anything, try again without strict

      strict = false;

    } else {

      // We already were on the second try, bail

      break;

    }

  } while (true);

  lck_mtx_unlock(sadb_mutex);

  return NULL;

}

/*

 * allocating an SA entry for an *OUTBOUND* packet.

 * checking each request entries in SP, and acquire an SA if need.

 * OUT: 0: there are valid requests.

 *  ENOENT: policy may be valid, but SA with REQUIRE is on acquiring.

 */

int

key_checkrequest(

  struct ipsecrequest *isr,

  struct secasindex *saidx,

  struct secasvar **sav)

{

  u_int level;

  int error;

  struct sockaddr_in *sin;

  LCK_MTX_ASSERT(sadb_mutex, LCK_MTX_ASSERT_NOTOWNED);

  *sav = NULL;

  /* sanity check */

  if (isr == NULL || saidx == NULL) {

    panic("key_checkrequest: NULL pointer is passed.\n");

  }

  /* check mode */

  switch (saidx->mode) {

  case IPSEC_MODE_TRANSPORT:

  case IPSEC_MODE_TUNNEL:

    break;

  case IPSEC_MODE_ANY:

  default:

    panic("key_checkrequest: Invalid policy defined.\n");

  }

  /* get current level */

  level = ipsec_get_reqlevel(isr);

  /*

   * key_allocsa_policy should allocate the oldest SA available.

   * See key_do_allocsa_policy(), and draft-jenkins-ipsec-rekeying-03.txt.

   */

  if (*sav == NULL) {

    *sav = key_allocsa_policy(saidx);

  }

  /* When there is SA. */

  if (*sav != NULL) {

    return 0;

  }

  /* There is no SA.

   *

   * Remove dst port - used for special natt support - don't call

   * key_acquire with it.

   */

  if (saidx->mode == IPSEC_MODE_TRANSPORT) {

    sin = (struct sockaddr_in *)&saidx->dst;

    sin->sin_port = IPSEC_PORT_ANY;

  }

  if ((error = key_acquire(saidx, isr->sp)) != 0) {

    /* XXX What should I do ? */

    ipseclog((LOG_DEBUG, "key_checkrequest: error %d returned "

        "from key_acquire.\n", error));

    return error;

  }

  return level == IPSEC_LEVEL_REQUIRE ? ENOENT : 0;

}

/*

 * allocating a SA for policy entry from SAD.

 * NOTE: searching SAD of aliving state.

 * OUT: NULL: not found.

 *  others: found and return the pointer.

 */

u_int32_t sah_search_calls = 0;

u_int32_t sah_search_count = 0;

struct secasvar *

key_allocsa_policy(

  struct secasindex *saidx)

{

  struct secashead *sah;

  struct secasvar *sav;

  u_int stateidx, state;

  const u_int *saorder_state_valid;

  int arraysize;

  struct sockaddr_in *sin;

  u_int16_t       dstport;

  lck_mtx_lock(sadb_mutex);