4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright (c) 2012 Nexenta Systems, Inc. All rights reserved.
34 #include <inet/ipsec_info.h>
35 #include <sys/crypto/common.h>
36 #include <sys/crypto/api.h>
39 #define IPSA_MAX_ADDRLEN 4 /* Max address len. (in 32-bits) for an SA. */
44 * For combined mode ciphers, store the crypto_mechanism_t in the
45 * per-packet ipsec_in_t/ipsec_out_t structures. This is because the PARAMS
46 * and nonce values change for each packet. For non-combined mode
47 * ciphers, these values are constant for the life of the SA.
49 typedef struct ipsa_cm_mech_s
{
50 crypto_mechanism_t combined_mech
;
52 CK_AES_CCM_PARAMS paramu_ccm
;
53 CK_AES_GCM_PARAMS paramu_gcm
;
55 uint8_t nonce
[MAXSALTSIZE
+ sizeof (uint64_t)];
56 #define param_ulMACSize paramu.paramu_ccm.ulMACSize
57 #define param_ulNonceSize paramu.paramu_ccm.ipsa_ulNonceSize
58 #define param_ulAuthDataSize paramu.paramu_ccm.ipsa_ulAuthDataSize
59 #define param_ulDataSize paramu.paramu_ccm.ipsa_ulDataSize
60 #define param_nonce paramu.paramu_ccm.nonce
61 #define param_authData paramu.paramu_ccm.authData
62 #define param_pIv paramu.paramu_gcm.ipsa_pIv
63 #define param_ulIvLen paramu.paramu_gcm.ulIvLen
64 #define param_ulIvBits paramu.paramu_gcm.ulIvBits
65 #define param_pAAD paramu.paramu_gcm.pAAD
66 #define param_ulAADLen paramu.paramu_gcm.ulAADLen
67 #define param_ulTagBits paramu.paramu_gcm.ulTagBits
71 * The Initialization Vector (also known as IV or Nonce) used to
72 * initialize the Block Cipher, is made up of a Counter and a Salt.
73 * The Counter is fixed at 64 bits and is incremented for each packet.
74 * The Salt value can be any whole byte value upto 64 bits. This is
75 * algorithm mode specific and can be configured with ipsecalgs(1m).
77 * We only support whole byte salt lengths, this is because the salt is
78 * stored in an array of uint8_t's. This is enforced by ipsecalgs(1m)
79 * which configures the salt length as a number of bytes. Checks are
80 * made to ensure the salt length defined in ipsecalgs(1m) fits in
83 * The Salt value remains constant for the life of the SA, the Salt is
84 * know to both peers, but NOT transmitted on the network. The Counter
85 * portion of the nonce is transmitted over the network with each packet
86 * and is confusingly described as the Initialization Vector by RFCs
89 * The maximum Initialization Vector length is 128 bits, if the actual
90 * size is less, its padded internally by the algorithm.
92 * The nonce structure is defined like this in the SA (ipsa_t)to ensure
93 * the Initilization Vector (counter) is 64 bit aligned, because it will
94 * be incremented as an uint64_t. The nonce as used by the algorithms is
95 * a straight uint8_t array.
97 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
99 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
100 * salt_offset <------>
101 * ipsa_saltlen <------->
102 * ipsa_nonce_buf------^
103 * ipsa_salt-------------~~~~~~^
104 * ipsa_nonce------------~~~~~~^
105 * ipsa_iv-----------------------------^
107 typedef struct ipsec_nonce_s
{
108 uint8_t salt
[MAXSALTSIZE
];
113 * IP security association. Synchronization assumes 32-bit loads, so
114 * the 64-bit quantities can't even be be read w/o locking it down!
118 typedef struct ipsa_key_s
{
119 uint8_t *sak_key
; /* Algorithm key. */
120 uint_t sak_keylen
; /* Algorithm key length (in bytes). */
121 uint_t sak_keybits
; /* Algorithm key length (in bits) */
122 uint_t sak_algid
; /* Algorithm ID number. */
125 typedef struct ipsa_s
{
126 struct ipsa_s
*ipsa_next
; /* Next in hash bucket */
127 struct ipsa_s
**ipsa_ptpn
; /* Pointer to previous next pointer. */
128 kmutex_t
*ipsa_linklock
; /* Pointer to hash-chain lock. */
129 void (*ipsa_freefunc
)(struct ipsa_s
*); /* freeassoc function */
130 void (*ipsa_noncefunc
)(struct ipsa_s
*, uchar_t
*,
131 uint_t
, uchar_t
*, ipsa_cm_mech_t
*, crypto_data_t
*);
133 * NOTE: I may need more pointers, depending on future SA
136 ipsa_key_t ipsa_authkeydata
;
137 #define ipsa_authkey ipsa_authkeydata.sak_key
138 #define ipsa_authkeylen ipsa_authkeydata.sak_keylen
139 #define ipsa_authkeybits ipsa_authkeydata.sak_keybits
140 #define ipsa_auth_alg ipsa_authkeydata.sak_algid
141 ipsa_key_t ipsa_encrkeydata
;
142 #define ipsa_encrkey ipsa_encrkeydata.sak_key
143 #define ipsa_encrkeylen ipsa_encrkeydata.sak_keylen
144 #define ipsa_encrkeybits ipsa_encrkeydata.sak_keybits
145 #define ipsa_encr_alg ipsa_encrkeydata.sak_algid
147 struct ipsid_s
*ipsa_src_cid
; /* Source certificate identity */
148 struct ipsid_s
*ipsa_dst_cid
; /* Destination certificate identity */
149 mblk_t
*ipsa_lpkt
; /* Packet received while larval (CAS me) */
150 mblk_t
*ipsa_bpkt_head
; /* Packets received while idle */
151 mblk_t
*ipsa_bpkt_tail
;
152 #define SADB_MAX_IDLEPKTS 100
153 uint8_t ipsa_mblkcnt
; /* Number of packets received while idle */
156 * PF_KEYv2 supports a replay window size of 255. Hence there is a
157 * need a bit vector to support a replay window of 255. 256 is a nice
158 * round number, so I support that.
160 * Use an array of uint64_t for best performance on 64-bit
161 * processors. (And hope that 32-bit compilers can handle things
162 * okay.) The " >> 6 " is to get the appropriate number of 64-bit
165 #define SADB_MAX_REPLAY 256 /* Must be 0 mod 64. */
166 uint64_t ipsa_replay_arr
[SADB_MAX_REPLAY
>> 6];
168 uint64_t ipsa_unique_id
; /* Non-zero for unique SAs */
169 uint64_t ipsa_unique_mask
; /* mask value for unique_id */
172 * Reference count semantics:
174 * An SA has a reference count of 1 if something's pointing
175 * to it. This includes being in a hash table. So if an
176 * SA is in a hash table, it has a reference count of at least 1.
178 * When a ptr. to an IPSA is assigned, you MUST REFHOLD after
179 * said assignment. When a ptr. to an IPSA is released
180 * you MUST REFRELE. When the refcount hits 0, REFRELE
181 * will free the IPSA.
183 kmutex_t ipsa_lock
; /* Locks non-linkage/refcnt fields. */
184 /* Q: Since I may be doing refcnts differently, will I need cv? */
185 uint_t ipsa_refcnt
; /* Reference count. */
188 * The following four time fields are the ones monitored by ah_ager()
189 * and esp_ager() respectively. They are all absolute wall-clock
190 * times. The times of creation (i.e. add time) and first use are
191 * pretty straightforward. The soft and hard expire times are
192 * derived from the times of first use and creation, plus the minimum
193 * expiration times in the fields that follow this.
195 * For example, if I had a hard add time of 30 seconds, and a hard
196 * use time of 15, the ipsa_hardexpiretime would be time of add, plus
197 * 30 seconds. If I USE the SA such that time of first use plus 15
198 * seconds would be earlier than the add time plus 30 seconds, then
199 * ipsa_hardexpiretime would become this earlier time.
201 time_t ipsa_addtime
; /* Time I was added. */
202 time_t ipsa_usetime
; /* Time of my first use. */
203 time_t ipsa_lastuse
; /* Time of my last use. */
204 time_t ipsa_idletime
; /* Seconds of idle time */
205 time_t ipsa_last_nat_t_ka
; /* Time of my last NAT-T keepalive. */
206 time_t ipsa_softexpiretime
; /* Time of my first soft expire. */
207 time_t ipsa_hardexpiretime
; /* Time of my first hard expire. */
208 time_t ipsa_idleexpiretime
; /* Time of my next idle expire time */
210 struct ipsec_nonce_s
*ipsa_nonce_buf
;
212 uint_t ipsa_nonce_len
;
214 uint_t ipsa_saltbits
;
218 uint64_t ipsa_iv_hardexpire
;
219 uint64_t ipsa_iv_softexpire
;
221 * The following fields are directly reflected in PF_KEYv2 LIFETIME
222 * extensions. The time_ts are in number-of-seconds, and the bytes
225 time_t ipsa_softaddlt
; /* Seconds of soft lifetime after add. */
226 time_t ipsa_softuselt
; /* Seconds of soft lifetime after first use. */
227 time_t ipsa_hardaddlt
; /* Seconds of hard lifetime after add. */
228 time_t ipsa_harduselt
; /* Seconds of hard lifetime after first use. */
229 time_t ipsa_idleaddlt
; /* Seconds of idle time after add */
230 time_t ipsa_idleuselt
; /* Seconds of idle time after first use */
231 uint64_t ipsa_softbyteslt
; /* Bytes of soft lifetime. */
232 uint64_t ipsa_hardbyteslt
; /* Bytes of hard lifetime. */
233 uint64_t ipsa_bytes
; /* Bytes encrypted/authed by this SA. */
236 * "Allocations" are a concept mentioned in PF_KEYv2. We do not
237 * support them, except to record them per the PF_KEYv2 spec.
239 uint_t ipsa_softalloc
; /* Allocations allowed (soft). */
240 uint_t ipsa_hardalloc
; /* Allocations allowed (hard). */
241 uint_t ipsa_alloc
; /* Allocations made. */
243 uint_t ipsa_type
; /* Type of security association. (AH/etc.) */
244 uint_t ipsa_state
; /* State of my association. */
245 uint_t ipsa_replay_wsize
; /* Size of replay window */
246 uint32_t ipsa_flags
; /* Flags for security association. */
247 uint32_t ipsa_spi
; /* Security parameters index. */
248 uint32_t ipsa_replay
; /* Highest seen replay value for this SA. */
249 uint32_t ipsa_kmp
; /* key management proto */
250 uint32_t ipsa_kmc
; /* key management cookie */
252 boolean_t ipsa_haspeer
; /* Has peer in another table. */
256 * The source address can be INADDR_ANY, IN6ADDR_ANY, etc.
258 * Address families (per sys/socket.h) guide us. We could have just
259 * used sockaddr_storage
261 sa_family_t ipsa_addrfam
;
262 sa_family_t ipsa_innerfam
; /* Inner AF can be != src/dst AF. */
264 uint32_t ipsa_srcaddr
[IPSA_MAX_ADDRLEN
];
265 uint32_t ipsa_dstaddr
[IPSA_MAX_ADDRLEN
];
266 uint32_t ipsa_innersrc
[IPSA_MAX_ADDRLEN
];
267 uint32_t ipsa_innerdst
[IPSA_MAX_ADDRLEN
];
269 uint8_t ipsa_innersrcpfx
;
270 uint8_t ipsa_innerdstpfx
;
272 uint16_t ipsa_inbound_cksum
; /* cksum correction for inbound packets */
273 uint16_t ipsa_local_nat_port
; /* Local NAT-T port. (0 --> 4500) */
274 uint16_t ipsa_remote_nat_port
; /* The other port that isn't 4500 */
276 /* these can only be v4 */
277 uint32_t ipsa_natt_addr_loc
;
278 uint32_t ipsa_natt_addr_rem
;
281 * icmp type and code. *_end are to specify ranges. if only
282 * a single value, * and *_end are the same value.
284 uint8_t ipsa_icmp_type
;
285 uint8_t ipsa_icmp_type_end
;
286 uint8_t ipsa_icmp_code
;
287 uint8_t ipsa_icmp_code_end
;
290 * For the kernel crypto framework.
292 crypto_key_t ipsa_kcfauthkey
; /* authentication key */
293 crypto_key_t ipsa_kcfencrkey
; /* encryption key */
294 crypto_ctx_template_t ipsa_authtmpl
; /* auth context template */
295 crypto_ctx_template_t ipsa_encrtmpl
; /* encr context template */
296 crypto_mechanism_t ipsa_amech
; /* auth mech type and ICV len */
297 crypto_mechanism_t ipsa_emech
; /* encr mech type */
298 size_t ipsa_mac_len
; /* auth MAC/ICV length */
299 size_t ipsa_iv_len
; /* encr IV length */
300 size_t ipsa_datalen
; /* block length in bytes. */
303 * Input and output processing functions called from IP.
304 * The mblk_t is the data; the IPsec information is in the attributes
305 * Returns NULL if the mblk is consumed which it is if there was
306 * a failure or if pending. If failure then
307 * the ipIfInDiscards/OutDiscards counters are increased.
309 mblk_t
*(*ipsa_output_func
)(mblk_t
*, ip_xmit_attr_t
*);
310 mblk_t
*(*ipsa_input_func
)(mblk_t
*, void *, ip_recv_attr_t
*);
313 * Soft reference to paired SA
315 uint32_t ipsa_otherspi
;
316 netstack_t
*ipsa_netstack
; /* Does not have a netstack_hold */
318 uint8_t ipsa_mac_exempt
; /* MLS: mac exempt flag */
319 uchar_t ipsa_opt_storage
[IP_MAX_OPT_LENGTH
];
323 * ipsa_t address handling macros. We want these to be inlined, and deal
324 * with 32-bit words to avoid bcmp/bcopy calls.
326 * Assume we only have AF_INET and AF_INET6 addresses for now. Also assume
327 * that we have 32-bit alignment on everything.
329 #define IPSA_IS_ADDR_UNSPEC(addr, fam) ((((uint32_t *)(addr))[0] == 0) && \
330 (((fam) == AF_INET) || (((uint32_t *)(addr))[3] == 0 && \
331 ((uint32_t *)(addr))[2] == 0 && ((uint32_t *)(addr))[1] == 0)))
332 #define IPSA_ARE_ADDR_EQUAL(addr1, addr2, fam) \
333 ((((uint32_t *)(addr1))[0] == ((uint32_t *)(addr2))[0]) && \
334 (((fam) == AF_INET) || \
335 (((uint32_t *)(addr1))[3] == ((uint32_t *)(addr2))[3] && \
336 ((uint32_t *)(addr1))[2] == ((uint32_t *)(addr2))[2] && \
337 ((uint32_t *)(addr1))[1] == ((uint32_t *)(addr2))[1])))
338 #define IPSA_COPY_ADDR(dstaddr, srcaddr, fam) { \
339 ((uint32_t *)(dstaddr))[0] = ((uint32_t *)(srcaddr))[0]; \
340 if ((fam) == AF_INET6) {\
341 ((uint32_t *)(dstaddr))[1] = ((uint32_t *)(srcaddr))[1]; \
342 ((uint32_t *)(dstaddr))[2] = ((uint32_t *)(srcaddr))[2]; \
343 ((uint32_t *)(dstaddr))[3] = ((uint32_t *)(srcaddr))[3]; } }
346 * ipsa_t reference hold/release macros.
348 * If you have a pointer, you REFHOLD. If you are releasing a pointer, you
349 * REFRELE. An ipsa_t that is newly inserted into the table should have
350 * a reference count of 1 (for the table's pointer), plus 1 more for every
351 * pointer that is referencing the ipsa_t.
354 #define IPSA_REFHOLD(ipsa) { \
355 atomic_inc_32(&(ipsa)->ipsa_refcnt); \
356 ASSERT((ipsa)->ipsa_refcnt != 0); \
360 * Decrement the reference count on the SA.
361 * In architectures e.g sun4u, where atomic_add_32_nv is just
362 * a cas, we need to maintain the right memory barrier semantics
363 * as that of mutex_exit i.e all the loads and stores should complete
364 * before the cas is executed. membar_exit() does that here.
367 #define IPSA_REFRELE(ipsa) { \
368 ASSERT((ipsa)->ipsa_refcnt != 0); \
370 if (atomic_dec_32_nv(&(ipsa)->ipsa_refcnt) == 0) \
371 ((ipsa)->ipsa_freefunc)(ipsa); \
375 * Security association hash macros and definitions. For now, assume the
376 * IPsec model, and hash outbounds on destination address, and inbounds on
380 #define IPSEC_DEFAULT_HASH_SIZE 256
382 #define INBOUND_HASH(sadb, spi) ((spi) % ((sadb)->sdb_hashsize))
383 #define OUTBOUND_HASH_V4(sadb, v4addr) ((v4addr) % ((sadb)->sdb_hashsize))
384 #define OUTBOUND_HASH_V6(sadb, v6addr) OUTBOUND_HASH_V4((sadb), \
385 (*(uint32_t *)&(v6addr)) ^ (*(((uint32_t *)&(v6addr)) + 1)) ^ \
386 (*(((uint32_t *)&(v6addr)) + 2)) ^ (*(((uint32_t *)&(v6addr)) + 3)))
389 * Syntactic sugar to find the appropriate hash bucket directly.
392 #define INBOUND_BUCKET(sadb, spi) &(((sadb)->sdb_if)[INBOUND_HASH(sadb, spi)])
393 #define OUTBOUND_BUCKET_V4(sadb, v4addr) \
394 &(((sadb)->sdb_of)[OUTBOUND_HASH_V4(sadb, v4addr)])
395 #define OUTBOUND_BUCKET_V6(sadb, v6addr) \
396 &(((sadb)->sdb_of)[OUTBOUND_HASH_V6(sadb, v6addr)])
398 #define IPSA_F_PFS SADB_SAFLAGS_PFS /* PFS in use for this SA? */
399 #define IPSA_F_NOREPFLD SADB_SAFLAGS_NOREPLAY /* No replay field, for */
400 /* backward compat. */
401 #define IPSA_F_USED SADB_X_SAFLAGS_USED /* SA has been used. */
402 #define IPSA_F_UNIQUE SADB_X_SAFLAGS_UNIQUE /* SA is unique */
403 #define IPSA_F_AALG1 SADB_X_SAFLAGS_AALG1 /* Auth alg flag 1 */
404 #define IPSA_F_AALG2 SADB_X_SAFLAGS_AALG2 /* Auth alg flag 2 */
405 #define IPSA_F_EALG1 SADB_X_SAFLAGS_EALG1 /* Encrypt alg flag 1 */
406 #define IPSA_F_EALG2 SADB_X_SAFLAGS_EALG2 /* Encrypt alg flag 2 */
408 #define IPSA_F_ASYNC 0x200000 /* Call KCF asynchronously? */
409 #define IPSA_F_NATT_LOC SADB_X_SAFLAGS_NATT_LOC
410 #define IPSA_F_NATT_REM SADB_X_SAFLAGS_NATT_REM
411 #define IPSA_F_BEHIND_NAT SADB_X_SAFLAGS_NATTED
412 #define IPSA_F_NATT (SADB_X_SAFLAGS_NATT_LOC | SADB_X_SAFLAGS_NATT_REM | \
413 SADB_X_SAFLAGS_NATTED)
414 #define IPSA_F_CINVALID 0x40000 /* SA shouldn't be cached */
415 #define IPSA_F_PAIRED SADB_X_SAFLAGS_PAIRED /* SA is one of a pair */
416 #define IPSA_F_OUTBOUND SADB_X_SAFLAGS_OUTBOUND /* SA direction bit */
417 #define IPSA_F_INBOUND SADB_X_SAFLAGS_INBOUND /* SA direction bit */
418 #define IPSA_F_TUNNEL SADB_X_SAFLAGS_TUNNEL
420 * These flags are only defined here to prevent a flag value collision.
422 #define IPSA_F_COMBINED SADB_X_SAFLAGS_EALG1 /* Defined in pfkeyv2.h */
423 #define IPSA_F_COUNTERMODE SADB_X_SAFLAGS_EALG2 /* Defined in pfkeyv2.h */
426 * Sets of flags that are allowed to by set or modified by PF_KEY apps.
428 #define AH_UPDATE_SETTABLE_FLAGS \
429 (SADB_X_SAFLAGS_PAIRED | SADB_SAFLAGS_NOREPLAY | \
430 SADB_X_SAFLAGS_OUTBOUND | SADB_X_SAFLAGS_INBOUND | \
431 SADB_X_SAFLAGS_KM1 | SADB_X_SAFLAGS_KM2 | \
432 SADB_X_SAFLAGS_KM3 | SADB_X_SAFLAGS_KM4)
434 /* AH can't set NAT flags (or even use NAT). Add NAT flags to the ESP set. */
435 #define ESP_UPDATE_SETTABLE_FLAGS (AH_UPDATE_SETTABLE_FLAGS | IPSA_F_NATT)
437 #define AH_ADD_SETTABLE_FLAGS \
438 (AH_UPDATE_SETTABLE_FLAGS | SADB_X_SAFLAGS_AALG1 | \
439 SADB_X_SAFLAGS_AALG2 | SADB_X_SAFLAGS_TUNNEL | \
440 SADB_SAFLAGS_NOREPLAY)
442 /* AH can't set NAT flags (or even use NAT). Add NAT flags to the ESP set. */
443 #define ESP_ADD_SETTABLE_FLAGS (AH_ADD_SETTABLE_FLAGS | IPSA_F_NATT | \
444 SADB_X_SAFLAGS_EALG1 | SADB_X_SAFLAGS_EALG2)
448 /* SA states are important for handling UPDATE PF_KEY messages. */
449 #define IPSA_STATE_LARVAL SADB_SASTATE_LARVAL
450 #define IPSA_STATE_MATURE SADB_SASTATE_MATURE
451 #define IPSA_STATE_DYING SADB_SASTATE_DYING
452 #define IPSA_STATE_DEAD SADB_SASTATE_DEAD
453 #define IPSA_STATE_IDLE SADB_X_SASTATE_IDLE
454 #define IPSA_STATE_ACTIVE_ELSEWHERE SADB_X_SASTATE_ACTIVE_ELSEWHERE
457 * NOTE: If the document authors do things right in defining algorithms, we'll
458 * probably have flags for what all is here w.r.t. replay, ESP w/HMAC,
462 #define IPSA_T_ACQUIRE SEC_TYPE_NONE /* If this typed returned, sa needed */
463 #define IPSA_T_AH SEC_TYPE_AH /* IPsec AH association */
464 #define IPSA_T_ESP SEC_TYPE_ESP /* IPsec ESP association */
466 #define IPSA_AALG_NONE SADB_AALG_NONE /* No auth. algorithm */
467 #define IPSA_AALG_MD5H SADB_AALG_MD5HMAC /* MD5-HMAC algorithm */
468 #define IPSA_AALG_SHA1H SADB_AALG_SHA1HMAC /* SHA1-HMAC algorithm */
470 #define IPSA_EALG_NONE SADB_EALG_NONE /* No encryption algorithm */
471 #define IPSA_EALG_DES_CBC SADB_EALG_DESCBC
472 #define IPSA_EALG_3DES SADB_EALG_3DESCBC
475 * Protect each ipsa_t bucket (and linkage) with a lock.
478 typedef struct isaf_s
{
485 * ACQUIRE record. If AH/ESP/whatever cannot find an association for outbound
486 * traffic, it sends up an SADB_ACQUIRE message and create an ACQUIRE record.
489 #define IPSACQ_MAXPACKETS 4 /* Number of packets that can be queued up */
490 /* waiting for an ACQUIRE to finish. */
492 typedef struct ipsacq_s
{
493 struct ipsacq_s
*ipsacq_next
;
494 struct ipsacq_s
**ipsacq_ptpn
;
495 kmutex_t
*ipsacq_linklock
;
496 struct ipsec_policy_s
*ipsacq_policy
;
497 struct ipsec_action_s
*ipsacq_act
;
499 sa_family_t ipsacq_addrfam
; /* Address family. */
500 sa_family_t ipsacq_inneraddrfam
; /* Inner-packet address family. */
501 int ipsacq_numpackets
; /* How many packets queued up so far. */
502 uint32_t ipsacq_seq
; /* PF_KEY sequence number. */
503 uint64_t ipsacq_unique_id
; /* Unique ID for SAs that need it. */
505 kmutex_t ipsacq_lock
; /* Protects non-linkage fields. */
506 time_t ipsacq_expire
; /* Wall-clock time when this record expires. */
507 mblk_t
*ipsacq_mp
; /* List of datagrams waiting for an SA. */
509 /* These two point inside the last mblk inserted. */
510 uint32_t *ipsacq_srcaddr
;
511 uint32_t *ipsacq_dstaddr
;
513 /* Cache these instead of point so we can mask off accordingly */
514 uint32_t ipsacq_innersrc
[IPSA_MAX_ADDRLEN
];
515 uint32_t ipsacq_innerdst
[IPSA_MAX_ADDRLEN
];
517 /* These may change per-acquire. */
518 uint16_t ipsacq_srcport
;
519 uint16_t ipsacq_dstport
;
520 uint8_t ipsacq_proto
;
521 uint8_t ipsacq_inner_proto
;
522 uint8_t ipsacq_innersrcpfx
;
523 uint8_t ipsacq_innerdstpfx
;
525 /* icmp type and code of triggering packet (if applicable) */
526 uint8_t ipsacq_icmp_type
;
527 uint8_t ipsacq_icmp_code
;
532 * Kernel-generated sequence numbers will be no less than 0x80000000 to
533 * forestall any cretinous problems with manual keying accidentally updating
536 #define IACQF_LOWEST_SEQ 0x80000000
538 #define SADB_AGE_INTERVAL_DEFAULT 8000
541 * ACQUIRE fanout. Protect each linkage with a lock.
544 typedef struct iacqf_s
{
545 ipsacq_t
*iacqf_ipsacq
;
550 * A (network protocol, ipsec protocol) specific SADB.
551 * (i.e., one each for {ah, esp} and {v4, v6}.
553 * Keep outbound assocs in a simple hash table for now.
554 * One danger point, multiple SAs for a single dest will clog a bucket.
555 * For the future, consider two-level hashing (2nd hash on IPC?), then probe.
558 typedef struct sadb_s
567 * A pair of SADB's (one for v4, one for v6), and related state (including
568 * acquire callbacks).
571 typedef struct sadbp_s
574 uint32_t *s_acquire_timeout
;
575 void (*s_acqfn
)(ipsacq_t
*, mblk_t
*, netstack_t
*);
579 uint32_t s_updateflags
;
583 * A pair of SA's for a single connection, the structure contains a
584 * pointer to a SA and the SA its paired with (opposite direction) as well
585 * as the SA's respective hash buckets.
587 typedef struct ipsap_s
589 boolean_t in_inbound_table
;
590 isaf_t
*ipsap_bucket
;
591 ipsa_t
*ipsap_sa_ptr
;
592 isaf_t
*ipsap_pbucket
;
593 ipsa_t
*ipsap_psa_ptr
;
596 typedef struct templist_s
599 struct templist_s
*next
;
602 /* Pointer to an all-zeroes IPv6 address. */
603 #define ALL_ZEROES_PTR ((uint32_t *)&ipv6_all_zeros)
606 * Form unique id from ip_xmit_attr_t.
608 #define SA_FORM_UNIQUE_ID(ixa) \
609 SA_UNIQUE_ID((ixa)->ixa_ipsec_src_port, (ixa)->ixa_ipsec_dst_port, \
610 (((ixa)->ixa_flags & IXAF_IPSEC_TUNNEL) ? \
611 ((ixa)->ixa_ipsec_inaf == AF_INET6 ? \
612 IPPROTO_IPV6 : IPPROTO_ENCAP) : \
613 (ixa)->ixa_ipsec_proto), \
614 (((ixa)->ixa_flags & IXAF_IPSEC_TUNNEL) ? \
615 (ixa)->ixa_ipsec_proto : 0))
618 * This macro is used to generate unique ids (along with the addresses, both
619 * inner and outer) for outbound datagrams that require unique SAs.
621 * N.B. casts and unsigned shift amounts discourage unwarranted
622 * sign extension of dstport, proto, and iproto.
624 * Unique ID is 64-bits allocated as follows (pardon my big-endian bias):
628 * +---------------*-------+-------+--------------+---------------+
629 * | MUST-BE-ZERO |<iprot>|<proto>| <src port> | <dest port> |
630 * +---------------*-------+-------+--------------+---------------+
632 * If there are inner addresses (tunnel mode) the ports come from the
633 * inner addresses. If there are no inner addresses, the ports come from
634 * the outer addresses (transport mode). Tunnel mode MUST have <proto>
635 * set to either IPPROTO_ENCAP or IPPPROTO_IPV6.
637 #define SA_UNIQUE_ID(srcport, dstport, proto, iproto) \
638 ((srcport) | ((uint64_t)(dstport) << 16U) | \
639 ((uint64_t)(proto) << 32U) | ((uint64_t)(iproto) << 40U))
642 * SA_UNIQUE_MASK generates a mask value to use when comparing the unique value
643 * from a packet to an SA.
646 #define SA_UNIQUE_MASK(srcport, dstport, proto, iproto) \
647 SA_UNIQUE_ID((srcport != 0) ? 0xffff : 0, \
648 (dstport != 0) ? 0xffff : 0, \
649 (proto != 0) ? 0xff : 0, \
650 (iproto != 0) ? 0xff : 0)
653 * Decompose unique id back into its original fields.
655 #define SA_IPROTO(ipsa) ((ipsa)->ipsa_unique_id>>40)&0xff
656 #define SA_PROTO(ipsa) ((ipsa)->ipsa_unique_id>>32)&0xff
657 #define SA_SRCPORT(ipsa) ((ipsa)->ipsa_unique_id & 0xffff)
658 #define SA_DSTPORT(ipsa) (((ipsa)->ipsa_unique_id >> 16) & 0xffff)
660 typedef struct ipsa_query_s ipsa_query_t
;
662 typedef boolean_t (*ipsa_match_fn_t
)(ipsa_query_t
*, ipsa_t
*);
664 #define IPSA_NMATCH 10
667 * SADB query structure.
669 * Provide a generalized mechanism for matching entries in the SADB;
670 * one of these structures is initialized using sadb_form_query(),
671 * and then can be used as a parameter to sadb_match_query() which returns
672 * B_TRUE if the SA matches the query.
674 * Under the covers, sadb_form_query populates the matchers[] array with
675 * functions which are called one at a time until one fails to match.
677 struct ipsa_query_s
{
679 sadb_address_t
*srcext
, *dstext
;
680 sadb_ident_t
*srcid
, *dstid
;
681 sadb_x_kmc_t
*kmcext
;
684 struct sockaddr_in
*src
;
685 struct sockaddr_in6
*src6
;
686 struct sockaddr_in
*dst
;
687 struct sockaddr_in6
*dst6
;
689 uint32_t *srcaddr
, *dstaddr
;
692 char *didstr
, *sidstr
;
693 uint16_t didtype
, sidtype
;
696 isaf_t
*inbound
, *outbound
;
699 ipsa_match_fn_t matchers
[IPSA_NMATCH
];
702 #define IPSA_Q_SA 0x00000001
703 #define IPSA_Q_DST 0x00000002
704 #define IPSA_Q_SRC 0x00000004
705 #define IPSA_Q_DSTID 0x00000008
706 #define IPSA_Q_SRCID 0x00000010
707 #define IPSA_Q_KMC 0x00000020
708 #define IPSA_Q_INBOUND 0x00000040 /* fill in inbound isaf_t */
709 #define IPSA_Q_OUTBOUND 0x00000080 /* fill in outbound isaf_t */
711 int sadb_form_query(keysock_in_t
*, uint32_t, uint32_t, ipsa_query_t
*, int *);
712 boolean_t
sadb_match_query(ipsa_query_t
*q
, ipsa_t
*sa
);
716 * All functions that return an ipsa_t will return it with IPSA_REFHOLD()
720 /* SA retrieval (inbound and outbound) */
721 ipsa_t
*ipsec_getassocbyspi(isaf_t
*, uint32_t, uint32_t *, uint32_t *,
723 ipsa_t
*ipsec_getassocbyconn(isaf_t
*, ip_xmit_attr_t
*, uint32_t *, uint32_t *,
724 sa_family_t
, uint8_t);
727 int sadb_insertassoc(ipsa_t
*, isaf_t
*);
729 /* SA table construction and destruction. */
730 void sadbp_init(const char *name
, sadbp_t
*, int, int, netstack_t
*);
731 void sadbp_flush(sadbp_t
*, netstack_t
*);
732 void sadbp_destroy(sadbp_t
*, netstack_t
*);
734 /* SA insertion and deletion. */
735 int sadb_insertassoc(ipsa_t
*, isaf_t
*);
736 void sadb_unlinkassoc(ipsa_t
*);
738 /* Support routines to interface a keysock consumer to PF_KEY. */
739 mblk_t
*sadb_keysock_out(minor_t
);
740 int sadb_hardsoftchk(sadb_lifetime_t
*, sadb_lifetime_t
*, sadb_lifetime_t
*);
741 void sadb_pfkey_echo(queue_t
*, mblk_t
*, sadb_msg_t
*, struct keysock_in_s
*,
743 void sadb_pfkey_error(queue_t
*, mblk_t
*, int, int, uint_t
);
744 void sadb_keysock_hello(queue_t
**, queue_t
*, mblk_t
*, void (*)(void *),
745 void *, timeout_id_t
*, int);
746 int sadb_addrcheck(queue_t
*, mblk_t
*, sadb_ext_t
*, uint_t
, netstack_t
*);
747 boolean_t
sadb_addrfix(keysock_in_t
*, queue_t
*, mblk_t
*, netstack_t
*);
748 int sadb_addrset(ire_t
*);
749 int sadb_delget_sa(mblk_t
*, keysock_in_t
*, sadbp_t
*, int *, queue_t
*,
752 int sadb_purge_sa(mblk_t
*, keysock_in_t
*, sadb_t
*, int *, queue_t
*);
753 int sadb_common_add(queue_t
*, mblk_t
*, sadb_msg_t
*,
754 keysock_in_t
*, isaf_t
*, isaf_t
*, ipsa_t
*, boolean_t
, boolean_t
, int *,
755 netstack_t
*, sadbp_t
*);
756 void sadb_set_usetime(ipsa_t
*);
757 boolean_t
sadb_age_bytes(queue_t
*, ipsa_t
*, uint64_t, boolean_t
);
758 int sadb_update_sa(mblk_t
*, keysock_in_t
*, mblk_t
**, sadbp_t
*,
759 int *, queue_t
*, int (*)(mblk_t
*, keysock_in_t
*, int *, netstack_t
*),
760 netstack_t
*, uint8_t);
761 void sadb_acquire(mblk_t
*, ip_xmit_attr_t
*, boolean_t
, boolean_t
);
762 void gcm_params_init(ipsa_t
*, uchar_t
*, uint_t
, uchar_t
*, ipsa_cm_mech_t
*,
764 void ccm_params_init(ipsa_t
*, uchar_t
*, uint_t
, uchar_t
*, ipsa_cm_mech_t
*,
766 void cbc_params_init(ipsa_t
*, uchar_t
*, uint_t
, uchar_t
*, ipsa_cm_mech_t
*,
769 void sadb_destroy_acquire(ipsacq_t
*, netstack_t
*);
771 mblk_t
*sadb_setup_acquire(ipsacq_t
*, uint8_t, struct ipsec_stack
*);
772 ipsa_t
*sadb_getspi(keysock_in_t
*, uint32_t, int *, netstack_t
*);
773 void sadb_in_acquire(sadb_msg_t
*, sadbp_t
*, queue_t
*, netstack_t
*);
774 boolean_t
sadb_replay_check(ipsa_t
*, uint32_t);
775 boolean_t
sadb_replay_peek(ipsa_t
*, uint32_t);
776 int sadb_dump(queue_t
*, mblk_t
*, keysock_in_t
*, sadb_t
*);
777 void sadb_replay_delete(ipsa_t
*);
778 void sadb_ager(sadb_t
*, queue_t
*, int, netstack_t
*);
780 timeout_id_t
sadb_retimeout(hrtime_t
, queue_t
*, void (*)(void *), void *,
781 uint_t
*, uint_t
, short);
782 void sadb_sa_refrele(void *target
);
783 mblk_t
*sadb_set_lpkt(ipsa_t
*, mblk_t
*, ip_recv_attr_t
*);
784 mblk_t
*sadb_clear_lpkt(ipsa_t
*);
785 void sadb_buf_pkt(ipsa_t
*, mblk_t
*, ip_recv_attr_t
*);
786 void sadb_clear_buf_pkt(void *ipkt
);
788 /* Note that buf_pkt is the product of ip_recv_attr_to_mblk() */
789 #define HANDLE_BUF_PKT(taskq, stack, dropper, buf_pkt) \
791 if (buf_pkt != NULL) { \
792 if (taskq_dispatch(taskq, sadb_clear_buf_pkt, \
793 (void *) buf_pkt, TQ_NOSLEEP) == 0) { \
794 /* Dispatch was unsuccessful drop the packets. */ \
796 while (buf_pkt != NULL) { \
797 tmp = buf_pkt->b_next; \
798 buf_pkt->b_next = NULL; \
799 buf_pkt = ip_recv_attr_free_mblk(buf_pkt); \
800 ip_drop_packet(buf_pkt, B_TRUE, NULL, \
802 ipds_sadb_inidle_timeout), \
811 * Two IPsec rate-limiting routines.
814 extern void ipsec_rl_strlog(netstack_t
*, short, short, char,
815 ushort_t
, char *, ...)
817 extern void ipsec_assocfailure(short, short, char, ushort_t
, char *, uint32_t,
818 void *, int, netstack_t
*);
824 #define IPSEC_NALGTYPES 2
826 typedef enum ipsec_algtype
{
833 * Definitions as per IPsec/ISAKMP DOI.
836 #define IPSEC_MAX_ALGS 256
837 #define PROTO_IPSEC_AH 2
838 #define PROTO_IPSEC_ESP 3
841 * Common algorithm info.
843 typedef struct ipsec_alginfo
847 uint16_t *alg_key_sizes
;
848 uint16_t *alg_block_sizes
;
849 uint16_t *alg_params
;
850 uint16_t alg_nkey_sizes
;
854 uint16_t alg_nblock_sizes
;
855 uint16_t alg_nparams
;
856 uint16_t alg_minbits
;
857 uint16_t alg_maxbits
;
858 uint16_t alg_datalen
;
860 * increment: number of bits from keysize to keysize
861 * default: # of increments from min to default key len
863 uint16_t alg_increment
;
864 uint16_t alg_default
;
865 uint16_t alg_default_bits
;
867 * Min, max, and default key sizes effectively supported
868 * by the encryption framework.
870 uint16_t alg_ef_minbits
;
871 uint16_t alg_ef_maxbits
;
872 uint16_t alg_ef_default
;
873 uint16_t alg_ef_default_bits
;
875 crypto_mech_type_t alg_mech_type
; /* KCF mechanism type */
876 crypto_mech_name_t alg_mech_name
; /* KCF mechanism name */
879 #define alg_datalen alg_block_sizes[0]
880 #define ALG_VALID(_alg) ((_alg)->alg_flags & ALG_FLAG_VALID)
883 * Software crypto execution mode.
886 IPSEC_ALGS_EXEC_SYNC
= 0,
887 IPSEC_ALGS_EXEC_ASYNC
= 1
888 } ipsec_algs_exec_mode_t
;
890 extern void ipsec_alg_reg(ipsec_algtype_t
, ipsec_alginfo_t
*, netstack_t
*);
891 extern void ipsec_alg_unreg(ipsec_algtype_t
, uint8_t, netstack_t
*);
892 extern void ipsec_alg_fix_min_max(ipsec_alginfo_t
*, ipsec_algtype_t
,
894 extern void alg_flag_check(ipsec_alginfo_t
*);
895 extern void ipsec_alg_free(ipsec_alginfo_t
*);
896 extern void ipsec_register_prov_update(void);
897 extern void sadb_alg_update(ipsec_algtype_t
, uint8_t, boolean_t
, netstack_t
*);
900 * Context templates management.
903 #define IPSEC_CTX_TMPL_ALLOC ((crypto_ctx_template_t)-1)
904 #define IPSEC_CTX_TMPL(_sa, _which, _type, _tmpl) { \
905 if ((_tmpl = (_sa)->_which) == IPSEC_CTX_TMPL_ALLOC) { \
906 mutex_enter(&assoc->ipsa_lock); \
907 if ((_sa)->_which == IPSEC_CTX_TMPL_ALLOC) { \
908 ipsec_stack_t *ipss; \
910 ipss = assoc->ipsa_netstack->netstack_ipsec; \
911 rw_enter(&ipss->ipsec_alg_lock, RW_READER); \
912 (void) ipsec_create_ctx_tmpl(_sa, _type); \
913 rw_exit(&ipss->ipsec_alg_lock); \
915 mutex_exit(&assoc->ipsa_lock); \
916 if ((_tmpl = (_sa)->_which) == IPSEC_CTX_TMPL_ALLOC) \
921 extern int ipsec_create_ctx_tmpl(ipsa_t
*, ipsec_algtype_t
);
922 extern void ipsec_destroy_ctx_tmpl(ipsa_t
*, ipsec_algtype_t
);
925 extern int ipsec_check_key(crypto_mech_type_t
, sadb_key_t
*, boolean_t
, int *);
927 typedef struct ipsec_kstats_s
{
928 kstat_named_t esp_stat_in_requests
;
929 kstat_named_t esp_stat_in_discards
;
930 kstat_named_t esp_stat_lookup_failure
;
931 kstat_named_t ah_stat_in_requests
;
932 kstat_named_t ah_stat_in_discards
;
933 kstat_named_t ah_stat_lookup_failure
;
934 kstat_named_t sadb_acquire_maxpackets
;
935 kstat_named_t sadb_acquire_qhiwater
;
939 * (ipss)->ipsec_kstats is equal to (ipss)->ipsec_ksp->ks_data if
940 * kstat_create_netstack for (ipss)->ipsec_ksp succeeds, but when it
941 * fails, it will be NULL. Note this is done for all stack instances,
942 * so it *could* fail. hence a non-NULL checking is done for
943 * IP_ESP_BUMP_STAT, IP_AH_BUMP_STAT and IP_ACQUIRE_STAT
945 #define IP_ESP_BUMP_STAT(ipss, x) \
947 if ((ipss)->ipsec_kstats != NULL) \
948 ((ipss)->ipsec_kstats->esp_stat_ ## x).value.ui64++; \
952 #define IP_AH_BUMP_STAT(ipss, x) \
954 if ((ipss)->ipsec_kstats != NULL) \
955 ((ipss)->ipsec_kstats->ah_stat_ ## x).value.ui64++; \
959 #define IP_ACQUIRE_STAT(ipss, val, new) \
961 if ((ipss)->ipsec_kstats != NULL && \
962 ((uint64_t)(new)) > \
963 ((ipss)->ipsec_kstats->sadb_acquire_ ## val).value.ui64) \
964 ((ipss)->ipsec_kstats->sadb_acquire_ ## val).value.ui64 = \
974 #endif /* _INET_SADB_H */