key.c revision 1.240 1 1.240 ozaki /* $NetBSD: key.c,v 1.240 2017/11/21 07:20:17 ozaki-r Exp $ */
2 1.12 jonathan /* $FreeBSD: src/sys/netipsec/key.c,v 1.3.2.3 2004/02/14 22:23:23 bms Exp $ */
3 1.1 jonathan /* $KAME: key.c,v 1.191 2001/06/27 10:46:49 sakane Exp $ */
4 1.79 gdt
5 1.1 jonathan /*
6 1.1 jonathan * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
7 1.1 jonathan * All rights reserved.
8 1.1 jonathan *
9 1.1 jonathan * Redistribution and use in source and binary forms, with or without
10 1.1 jonathan * modification, are permitted provided that the following conditions
11 1.1 jonathan * are met:
12 1.1 jonathan * 1. Redistributions of source code must retain the above copyright
13 1.1 jonathan * notice, this list of conditions and the following disclaimer.
14 1.1 jonathan * 2. Redistributions in binary form must reproduce the above copyright
15 1.1 jonathan * notice, this list of conditions and the following disclaimer in the
16 1.1 jonathan * documentation and/or other materials provided with the distribution.
17 1.1 jonathan * 3. Neither the name of the project nor the names of its contributors
18 1.1 jonathan * may be used to endorse or promote products derived from this software
19 1.1 jonathan * without specific prior written permission.
20 1.1 jonathan *
21 1.1 jonathan * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22 1.1 jonathan * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 1.1 jonathan * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 1.1 jonathan * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25 1.1 jonathan * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 1.1 jonathan * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 1.1 jonathan * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 1.1 jonathan * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 1.1 jonathan * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 1.1 jonathan * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 1.1 jonathan * SUCH DAMAGE.
32 1.1 jonathan */
33 1.1 jonathan
34 1.1 jonathan #include <sys/cdefs.h>
35 1.240 ozaki __KERNEL_RCSID(0, "$NetBSD: key.c,v 1.240 2017/11/21 07:20:17 ozaki-r Exp $");
36 1.1 jonathan
37 1.1 jonathan /*
38 1.231 ryoon * This code is referred to RFC 2367
39 1.1 jonathan */
40 1.1 jonathan
41 1.104 ozaki #if defined(_KERNEL_OPT)
42 1.1 jonathan #include "opt_inet.h"
43 1.1 jonathan #include "opt_ipsec.h"
44 1.6 scw #include "opt_gateway.h"
45 1.197 ozaki #include "opt_net_mpsafe.h"
46 1.6 scw #endif
47 1.1 jonathan
48 1.1 jonathan #include <sys/types.h>
49 1.1 jonathan #include <sys/param.h>
50 1.1 jonathan #include <sys/systm.h>
51 1.1 jonathan #include <sys/callout.h>
52 1.1 jonathan #include <sys/kernel.h>
53 1.1 jonathan #include <sys/mbuf.h>
54 1.1 jonathan #include <sys/domain.h>
55 1.1 jonathan #include <sys/socket.h>
56 1.1 jonathan #include <sys/socketvar.h>
57 1.1 jonathan #include <sys/sysctl.h>
58 1.1 jonathan #include <sys/errno.h>
59 1.1 jonathan #include <sys/proc.h>
60 1.1 jonathan #include <sys/queue.h>
61 1.1 jonathan #include <sys/syslog.h>
62 1.52 thorpej #include <sys/once.h>
63 1.75 drochner #include <sys/cprng.h>
64 1.105 ozaki #include <sys/psref.h>
65 1.105 ozaki #include <sys/lwp.h>
66 1.126 ozaki #include <sys/workqueue.h>
67 1.127 ozaki #include <sys/kmem.h>
68 1.127 ozaki #include <sys/cpu.h>
69 1.147 ozaki #include <sys/atomic.h>
70 1.194 ozaki #include <sys/pslist.h>
71 1.197 ozaki #include <sys/mutex.h>
72 1.197 ozaki #include <sys/condvar.h>
73 1.197 ozaki #include <sys/localcount.h>
74 1.197 ozaki #include <sys/pserialize.h>
75 1.1 jonathan
76 1.1 jonathan #include <net/if.h>
77 1.1 jonathan #include <net/route.h>
78 1.1 jonathan
79 1.1 jonathan #include <netinet/in.h>
80 1.1 jonathan #include <netinet/in_systm.h>
81 1.1 jonathan #include <netinet/ip.h>
82 1.1 jonathan #include <netinet/in_var.h>
83 1.6 scw #ifdef INET
84 1.6 scw #include <netinet/ip_var.h>
85 1.6 scw #endif
86 1.1 jonathan
87 1.1 jonathan #ifdef INET6
88 1.1 jonathan #include <netinet/ip6.h>
89 1.1 jonathan #include <netinet6/in6_var.h>
90 1.1 jonathan #include <netinet6/ip6_var.h>
91 1.1 jonathan #endif /* INET6 */
92 1.1 jonathan
93 1.1 jonathan #ifdef INET
94 1.1 jonathan #include <netinet/in_pcb.h>
95 1.1 jonathan #endif
96 1.1 jonathan #ifdef INET6
97 1.1 jonathan #include <netinet6/in6_pcb.h>
98 1.1 jonathan #endif /* INET6 */
99 1.1 jonathan
100 1.1 jonathan #include <net/pfkeyv2.h>
101 1.1 jonathan #include <netipsec/keydb.h>
102 1.1 jonathan #include <netipsec/key.h>
103 1.1 jonathan #include <netipsec/keysock.h>
104 1.1 jonathan #include <netipsec/key_debug.h>
105 1.1 jonathan
106 1.1 jonathan #include <netipsec/ipsec.h>
107 1.1 jonathan #ifdef INET6
108 1.1 jonathan #include <netipsec/ipsec6.h>
109 1.1 jonathan #endif
110 1.52 thorpej #include <netipsec/ipsec_private.h>
111 1.1 jonathan
112 1.1 jonathan #include <netipsec/xform.h>
113 1.33 degroote #include <netipsec/ipcomp.h>
114 1.33 degroote
115 1.1 jonathan
116 1.1 jonathan #include <net/net_osdep.h>
117 1.1 jonathan
118 1.1 jonathan #define FULLMASK 0xff
119 1.1 jonathan #define _BITS(bytes) ((bytes) << 3)
120 1.1 jonathan
121 1.96 christos #define PORT_NONE 0
122 1.96 christos #define PORT_LOOSE 1
123 1.96 christos #define PORT_STRICT 2
124 1.96 christos
125 1.52 thorpej percpu_t *pfkeystat_percpu;
126 1.52 thorpej
127 1.1 jonathan /*
128 1.1 jonathan * Note on SA reference counting:
129 1.1 jonathan * - SAs that are not in DEAD state will have (total external reference + 1)
130 1.1 jonathan * following value in reference count field. they cannot be freed and are
131 1.1 jonathan * referenced from SA header.
132 1.1 jonathan * - SAs that are in DEAD state will have (total external reference)
133 1.1 jonathan * in reference count field. they are ready to be freed. reference from
134 1.1 jonathan * SA header will be removed in key_delsav(), when the reference count
135 1.1 jonathan * field hits 0 (= no external reference other than from SA header.
136 1.1 jonathan */
137 1.1 jonathan
138 1.209 ozaki u_int32_t key_debug_level = 0;
139 1.209 ozaki static u_int key_spi_trycnt = 1000;
140 1.209 ozaki static u_int32_t key_spi_minval = 0x100;
141 1.209 ozaki static u_int32_t key_spi_maxval = 0x0fffffff; /* XXX */
142 1.209 ozaki static u_int32_t policy_id = 0;
143 1.209 ozaki static u_int key_int_random = 60; /*interval to initialize randseed,1(m)*/
144 1.209 ozaki static u_int key_larval_lifetime = 30; /* interval to expire acquiring, 30(s)*/
145 1.209 ozaki static int key_blockacq_count = 10; /* counter for blocking SADB_ACQUIRE.*/
146 1.209 ozaki static int key_blockacq_lifetime = 20; /* lifetime for blocking SADB_ACQUIRE.*/
147 1.209 ozaki static int key_prefered_oldsa = 0; /* prefered old sa rather than new sa.*/
148 1.209 ozaki
149 1.209 ozaki static u_int32_t acq_seq = 0;
150 1.209 ozaki
151 1.197 ozaki /*
152 1.210 ozaki * Locking order: there is no order for now; it means that any locks aren't
153 1.210 ozaki * overlapped.
154 1.210 ozaki */
155 1.210 ozaki /*
156 1.197 ozaki * Locking notes on SPD:
157 1.208 ozaki * - Modifications to the key_spd.splist must be done with holding key_spd.lock
158 1.197 ozaki * which is a adaptive mutex
159 1.214 ozaki * - Read accesses to the key_spd.splist must be in pserialize(9) read sections
160 1.197 ozaki * - SP's lifetime is managed by localcount(9)
161 1.210 ozaki * - An SP that has been inserted to the key_spd.splist is initially referenced
162 1.210 ozaki * by none, i.e., a reference from the key_spd.splist isn't counted
163 1.197 ozaki * - When an SP is being destroyed, we change its state as DEAD, wait for
164 1.197 ozaki * references to the SP to be released, and then deallocate the SP
165 1.197 ozaki * (see key_unlink_sp)
166 1.197 ozaki * - Getting an SP
167 1.210 ozaki * - Normally we get an SP from the key_spd.splist (see key_lookup_sp_byspidx)
168 1.210 ozaki * - Must iterate the list and increment the reference count of a found SP
169 1.214 ozaki * (by key_sp_ref) in a pserialize read section
170 1.197 ozaki * - We can gain another reference from a held SP only if we check its state
171 1.214 ozaki * and take its reference in a pserialize read section
172 1.197 ozaki * (see esp_output for example)
173 1.197 ozaki * - We may get an SP from an SP cache. See below
174 1.210 ozaki * - A gotten SP must be released after use by KEY_SP_UNREF (key_sp_unref)
175 1.197 ozaki * - Updating member variables of an SP
176 1.197 ozaki * - Most member variables of an SP are immutable
177 1.197 ozaki * - Only sp->state and sp->lastused can be changed
178 1.208 ozaki * - sp->state of an SP is updated only when destroying it under key_spd.lock
179 1.197 ozaki * - SP caches
180 1.197 ozaki * - SPs can be cached in PCBs
181 1.197 ozaki * - The lifetime of the caches is controlled by the global generation counter
182 1.197 ozaki * (ipsec_spdgen)
183 1.197 ozaki * - The global counter value is stored when an SP is cached
184 1.197 ozaki * - If the stored value is different from the global counter then the cache
185 1.197 ozaki * is considered invalidated
186 1.197 ozaki * - The counter is incremented when an SP is being destroyed
187 1.197 ozaki * - So checking the generation and taking a reference to an SP should be
188 1.214 ozaki * in a pserialize read section
189 1.197 ozaki * - Note that caching doesn't increment the reference counter of an SP
190 1.197 ozaki * - SPs in sockets
191 1.197 ozaki * - Userland programs can set a policy to a socket by
192 1.197 ozaki * setsockopt(IP_IPSEC_POLICY)
193 1.197 ozaki * - Such policies (SPs) are set to a socket (PCB) and also inserted to
194 1.208 ozaki * the key_spd.socksplist list (not the key_spd.splist)
195 1.197 ozaki * - Such a policy is destroyed when a corresponding socket is destroed,
196 1.197 ozaki * however, a socket can be destroyed in softint so we cannot destroy
197 1.197 ozaki * it directly instead we just mark it DEAD and delay the destruction
198 1.197 ozaki * until GC by the timer
199 1.197 ozaki */
200 1.210 ozaki /*
201 1.216 ozaki * Locking notes on SAD:
202 1.216 ozaki * - Data structures
203 1.216 ozaki * - SAs are managed by the list called key_sad.sahlist and sav lists of sah
204 1.216 ozaki * entries
205 1.223 ozaki * - An sav is supposed to be an SA from a viewpoint of users
206 1.216 ozaki * - A sah has sav lists for each SA state
207 1.216 ozaki * - Multiple sahs with the same saidx can exist
208 1.216 ozaki * - Only one entry has MATURE state and others should be DEAD
209 1.216 ozaki * - DEAD entries are just ignored from searching
210 1.223 ozaki * - Modifications to the key_sad.sahlist and sah.savlist must be done with
211 1.223 ozaki * holding key_sad.lock which is a adaptive mutex
212 1.223 ozaki * - Read accesses to the key_sad.sahlist and sah.savlist must be in
213 1.223 ozaki * pserialize(9) read sections
214 1.216 ozaki * - sah's lifetime is managed by localcount(9)
215 1.216 ozaki * - Getting an sah entry
216 1.219 ozaki * - We get an sah from the key_sad.sahlist
217 1.216 ozaki * - Must iterate the list and increment the reference count of a found sah
218 1.216 ozaki * (by key_sah_ref) in a pserialize read section
219 1.216 ozaki * - A gotten sah must be released after use by key_sah_unref
220 1.216 ozaki * - An sah is destroyed when its state become DEAD and no sav is
221 1.216 ozaki * listed to the sah
222 1.216 ozaki * - The destruction is done only in the timer (see key_timehandler_sad)
223 1.223 ozaki * - sav's lifetime is managed by localcount(9)
224 1.223 ozaki * - Getting an sav entry
225 1.223 ozaki * - First get an sah by saidx and get an sav from either of sah's savlists
226 1.223 ozaki * - Must iterate the list and increment the reference count of a found sav
227 1.223 ozaki * (by key_sa_ref) in a pserialize read section
228 1.223 ozaki * - We can gain another reference from a held SA only if we check its state
229 1.223 ozaki * and take its reference in a pserialize read section
230 1.223 ozaki * (see esp_output for example)
231 1.223 ozaki * - A gotten sav must be released after use by key_sa_unref
232 1.223 ozaki * - An sav is destroyed when its state become DEAD
233 1.216 ozaki */
234 1.216 ozaki /*
235 1.210 ozaki * Locking notes on misc data:
236 1.210 ozaki * - All lists of key_misc are protected by key_misc.lock
237 1.210 ozaki * - key_misc.lock must be held even for read accesses
238 1.210 ozaki */
239 1.197 ozaki
240 1.208 ozaki /* SPD */
241 1.208 ozaki static struct {
242 1.208 ozaki kmutex_t lock;
243 1.226 ozaki kcondvar_t cv_lc;
244 1.208 ozaki struct pslist_head splist[IPSEC_DIR_MAX];
245 1.208 ozaki /*
246 1.208 ozaki * The list has SPs that are set to a socket via
247 1.208 ozaki * setsockopt(IP_IPSEC_POLICY) from userland. See ipsec_set_policy.
248 1.208 ozaki */
249 1.208 ozaki struct pslist_head socksplist;
250 1.226 ozaki
251 1.226 ozaki pserialize_t psz;
252 1.226 ozaki kcondvar_t cv_psz;
253 1.226 ozaki bool psz_performing;
254 1.208 ozaki } key_spd __cacheline_aligned;
255 1.208 ozaki
256 1.208 ozaki /* SAD */
257 1.208 ozaki static struct {
258 1.208 ozaki kmutex_t lock;
259 1.226 ozaki kcondvar_t cv_lc;
260 1.208 ozaki struct pslist_head sahlist;
261 1.226 ozaki
262 1.226 ozaki pserialize_t psz;
263 1.226 ozaki kcondvar_t cv_psz;
264 1.226 ozaki bool psz_performing;
265 1.208 ozaki } key_sad __cacheline_aligned;
266 1.208 ozaki
267 1.208 ozaki /* Misc data */
268 1.208 ozaki static struct {
269 1.208 ozaki kmutex_t lock;
270 1.208 ozaki /* registed list */
271 1.208 ozaki LIST_HEAD(_reglist, secreg) reglist[SADB_SATYPE_MAX + 1];
272 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
273 1.208 ozaki /* acquiring list */
274 1.208 ozaki LIST_HEAD(_acqlist, secacq) acqlist;
275 1.1 jonathan #endif
276 1.139 ozaki #ifdef notyet
277 1.208 ozaki /* SP acquiring list */
278 1.208 ozaki LIST_HEAD(_spacqlist, secspacq) spacqlist;
279 1.139 ozaki #endif
280 1.208 ozaki } key_misc __cacheline_aligned;
281 1.1 jonathan
282 1.208 ozaki /* Macros for key_spd.splist */
283 1.194 ozaki #define SPLIST_ENTRY_INIT(sp) \
284 1.194 ozaki PSLIST_ENTRY_INIT((sp), pslist_entry)
285 1.194 ozaki #define SPLIST_ENTRY_DESTROY(sp) \
286 1.194 ozaki PSLIST_ENTRY_DESTROY((sp), pslist_entry)
287 1.194 ozaki #define SPLIST_WRITER_REMOVE(sp) \
288 1.194 ozaki PSLIST_WRITER_REMOVE((sp), pslist_entry)
289 1.194 ozaki #define SPLIST_READER_EMPTY(dir) \
290 1.208 ozaki (PSLIST_READER_FIRST(&key_spd.splist[(dir)], struct secpolicy, \
291 1.194 ozaki pslist_entry) == NULL)
292 1.194 ozaki #define SPLIST_READER_FOREACH(sp, dir) \
293 1.208 ozaki PSLIST_READER_FOREACH((sp), &key_spd.splist[(dir)], \
294 1.208 ozaki struct secpolicy, pslist_entry)
295 1.194 ozaki #define SPLIST_WRITER_FOREACH(sp, dir) \
296 1.208 ozaki PSLIST_WRITER_FOREACH((sp), &key_spd.splist[(dir)], \
297 1.208 ozaki struct secpolicy, pslist_entry)
298 1.194 ozaki #define SPLIST_WRITER_INSERT_AFTER(sp, new) \
299 1.194 ozaki PSLIST_WRITER_INSERT_AFTER((sp), (new), pslist_entry)
300 1.194 ozaki #define SPLIST_WRITER_EMPTY(dir) \
301 1.208 ozaki (PSLIST_WRITER_FIRST(&key_spd.splist[(dir)], struct secpolicy, \
302 1.194 ozaki pslist_entry) == NULL)
303 1.194 ozaki #define SPLIST_WRITER_INSERT_HEAD(dir, sp) \
304 1.208 ozaki PSLIST_WRITER_INSERT_HEAD(&key_spd.splist[(dir)], (sp), \
305 1.208 ozaki pslist_entry)
306 1.194 ozaki #define SPLIST_WRITER_NEXT(sp) \
307 1.194 ozaki PSLIST_WRITER_NEXT((sp), struct secpolicy, pslist_entry)
308 1.194 ozaki #define SPLIST_WRITER_INSERT_TAIL(dir, new) \
309 1.194 ozaki do { \
310 1.194 ozaki if (SPLIST_WRITER_EMPTY((dir))) { \
311 1.194 ozaki SPLIST_WRITER_INSERT_HEAD((dir), (new)); \
312 1.194 ozaki } else { \
313 1.194 ozaki struct secpolicy *__sp; \
314 1.194 ozaki SPLIST_WRITER_FOREACH(__sp, (dir)) { \
315 1.194 ozaki if (SPLIST_WRITER_NEXT(__sp) == NULL) { \
316 1.194 ozaki SPLIST_WRITER_INSERT_AFTER(__sp,\
317 1.194 ozaki (new)); \
318 1.194 ozaki break; \
319 1.194 ozaki } \
320 1.194 ozaki } \
321 1.194 ozaki } \
322 1.194 ozaki } while (0)
323 1.194 ozaki
324 1.208 ozaki /* Macros for key_spd.socksplist */
325 1.208 ozaki #define SOCKSPLIST_WRITER_FOREACH(sp) \
326 1.208 ozaki PSLIST_WRITER_FOREACH((sp), &key_spd.socksplist, \
327 1.208 ozaki struct secpolicy, pslist_entry)
328 1.208 ozaki #define SOCKSPLIST_READER_EMPTY() \
329 1.208 ozaki (PSLIST_READER_FIRST(&key_spd.socksplist, struct secpolicy, \
330 1.208 ozaki pslist_entry) == NULL)
331 1.208 ozaki
332 1.208 ozaki /* Macros for key_sad.sahlist */
333 1.202 ozaki #define SAHLIST_ENTRY_INIT(sah) \
334 1.202 ozaki PSLIST_ENTRY_INIT((sah), pslist_entry)
335 1.202 ozaki #define SAHLIST_ENTRY_DESTROY(sah) \
336 1.202 ozaki PSLIST_ENTRY_DESTROY((sah), pslist_entry)
337 1.202 ozaki #define SAHLIST_WRITER_REMOVE(sah) \
338 1.202 ozaki PSLIST_WRITER_REMOVE((sah), pslist_entry)
339 1.202 ozaki #define SAHLIST_READER_FOREACH(sah) \
340 1.208 ozaki PSLIST_READER_FOREACH((sah), &key_sad.sahlist, struct secashead,\
341 1.202 ozaki pslist_entry)
342 1.202 ozaki #define SAHLIST_WRITER_FOREACH(sah) \
343 1.208 ozaki PSLIST_WRITER_FOREACH((sah), &key_sad.sahlist, struct secashead,\
344 1.202 ozaki pslist_entry)
345 1.202 ozaki #define SAHLIST_WRITER_INSERT_HEAD(sah) \
346 1.208 ozaki PSLIST_WRITER_INSERT_HEAD(&key_sad.sahlist, (sah), pslist_entry)
347 1.202 ozaki
348 1.208 ozaki /* Macros for key_sad.sahlist#savlist */
349 1.203 ozaki #define SAVLIST_ENTRY_INIT(sav) \
350 1.203 ozaki PSLIST_ENTRY_INIT((sav), pslist_entry)
351 1.203 ozaki #define SAVLIST_ENTRY_DESTROY(sav) \
352 1.203 ozaki PSLIST_ENTRY_DESTROY((sav), pslist_entry)
353 1.203 ozaki #define SAVLIST_READER_FIRST(sah, state) \
354 1.208 ozaki PSLIST_READER_FIRST(&(sah)->savlist[(state)], struct secasvar, \
355 1.203 ozaki pslist_entry)
356 1.203 ozaki #define SAVLIST_WRITER_REMOVE(sav) \
357 1.203 ozaki PSLIST_WRITER_REMOVE((sav), pslist_entry)
358 1.203 ozaki #define SAVLIST_READER_FOREACH(sav, sah, state) \
359 1.208 ozaki PSLIST_READER_FOREACH((sav), &(sah)->savlist[(state)], \
360 1.203 ozaki struct secasvar, pslist_entry)
361 1.203 ozaki #define SAVLIST_WRITER_FOREACH(sav, sah, state) \
362 1.208 ozaki PSLIST_WRITER_FOREACH((sav), &(sah)->savlist[(state)], \
363 1.203 ozaki struct secasvar, pslist_entry)
364 1.203 ozaki #define SAVLIST_WRITER_INSERT_BEFORE(sav, new) \
365 1.203 ozaki PSLIST_WRITER_INSERT_BEFORE((sav), (new), pslist_entry)
366 1.203 ozaki #define SAVLIST_WRITER_INSERT_AFTER(sav, new) \
367 1.203 ozaki PSLIST_WRITER_INSERT_AFTER((sav), (new), pslist_entry)
368 1.203 ozaki #define SAVLIST_WRITER_EMPTY(sah, state) \
369 1.208 ozaki (PSLIST_WRITER_FIRST(&(sah)->savlist[(state)], struct secasvar, \
370 1.203 ozaki pslist_entry) == NULL)
371 1.203 ozaki #define SAVLIST_WRITER_INSERT_HEAD(sah, state, sav) \
372 1.208 ozaki PSLIST_WRITER_INSERT_HEAD(&(sah)->savlist[(state)], (sav), \
373 1.203 ozaki pslist_entry)
374 1.203 ozaki #define SAVLIST_WRITER_NEXT(sav) \
375 1.203 ozaki PSLIST_WRITER_NEXT((sav), struct secasvar, pslist_entry)
376 1.203 ozaki #define SAVLIST_WRITER_INSERT_TAIL(sah, state, new) \
377 1.203 ozaki do { \
378 1.203 ozaki if (SAVLIST_WRITER_EMPTY((sah), (state))) { \
379 1.203 ozaki SAVLIST_WRITER_INSERT_HEAD((sah), (state), (new));\
380 1.203 ozaki } else { \
381 1.203 ozaki struct secasvar *__sav; \
382 1.203 ozaki SAVLIST_WRITER_FOREACH(__sav, (sah), (state)) { \
383 1.203 ozaki if (SAVLIST_WRITER_NEXT(__sav) == NULL) {\
384 1.203 ozaki SAVLIST_WRITER_INSERT_AFTER(__sav,\
385 1.203 ozaki (new)); \
386 1.203 ozaki break; \
387 1.203 ozaki } \
388 1.203 ozaki } \
389 1.203 ozaki } \
390 1.203 ozaki } while (0)
391 1.203 ozaki #define SAVLIST_READER_NEXT(sav) \
392 1.203 ozaki PSLIST_READER_NEXT((sav), struct secasvar, pslist_entry)
393 1.203 ozaki
394 1.141 ozaki
395 1.1 jonathan /* search order for SAs */
396 1.1 jonathan /*
397 1.1 jonathan * This order is important because we must select the oldest SA
398 1.1 jonathan * for outbound processing. For inbound, This is not important.
399 1.1 jonathan */
400 1.67 drochner static const u_int saorder_state_valid_prefer_old[] = {
401 1.67 drochner SADB_SASTATE_DYING, SADB_SASTATE_MATURE,
402 1.67 drochner };
403 1.67 drochner static const u_int saorder_state_valid_prefer_new[] = {
404 1.67 drochner SADB_SASTATE_MATURE, SADB_SASTATE_DYING,
405 1.1 jonathan };
406 1.67 drochner
407 1.66 drochner static const u_int saorder_state_alive[] = {
408 1.1 jonathan /* except DEAD */
409 1.1 jonathan SADB_SASTATE_MATURE, SADB_SASTATE_DYING, SADB_SASTATE_LARVAL
410 1.1 jonathan };
411 1.66 drochner static const u_int saorder_state_any[] = {
412 1.1 jonathan SADB_SASTATE_MATURE, SADB_SASTATE_DYING,
413 1.1 jonathan SADB_SASTATE_LARVAL, SADB_SASTATE_DEAD
414 1.1 jonathan };
415 1.1 jonathan
416 1.120 ozaki #define SASTATE_ALIVE_FOREACH(s) \
417 1.120 ozaki for (int _i = 0; \
418 1.120 ozaki _i < __arraycount(saorder_state_alive) ? \
419 1.120 ozaki (s) = saorder_state_alive[_i], true : false; \
420 1.120 ozaki _i++)
421 1.120 ozaki #define SASTATE_ANY_FOREACH(s) \
422 1.120 ozaki for (int _i = 0; \
423 1.120 ozaki _i < __arraycount(saorder_state_any) ? \
424 1.120 ozaki (s) = saorder_state_any[_i], true : false; \
425 1.120 ozaki _i++)
426 1.120 ozaki
427 1.1 jonathan static const int minsize[] = {
428 1.1 jonathan sizeof(struct sadb_msg), /* SADB_EXT_RESERVED */
429 1.1 jonathan sizeof(struct sadb_sa), /* SADB_EXT_SA */
430 1.1 jonathan sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_CURRENT */
431 1.1 jonathan sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_HARD */
432 1.1 jonathan sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_SOFT */
433 1.1 jonathan sizeof(struct sadb_address), /* SADB_EXT_ADDRESS_SRC */
434 1.1 jonathan sizeof(struct sadb_address), /* SADB_EXT_ADDRESS_DST */
435 1.1 jonathan sizeof(struct sadb_address), /* SADB_EXT_ADDRESS_PROXY */
436 1.1 jonathan sizeof(struct sadb_key), /* SADB_EXT_KEY_AUTH */
437 1.1 jonathan sizeof(struct sadb_key), /* SADB_EXT_KEY_ENCRYPT */
438 1.1 jonathan sizeof(struct sadb_ident), /* SADB_EXT_IDENTITY_SRC */
439 1.1 jonathan sizeof(struct sadb_ident), /* SADB_EXT_IDENTITY_DST */
440 1.1 jonathan sizeof(struct sadb_sens), /* SADB_EXT_SENSITIVITY */
441 1.1 jonathan sizeof(struct sadb_prop), /* SADB_EXT_PROPOSAL */
442 1.1 jonathan sizeof(struct sadb_supported), /* SADB_EXT_SUPPORTED_AUTH */
443 1.1 jonathan sizeof(struct sadb_supported), /* SADB_EXT_SUPPORTED_ENCRYPT */
444 1.1 jonathan sizeof(struct sadb_spirange), /* SADB_EXT_SPIRANGE */
445 1.1 jonathan 0, /* SADB_X_EXT_KMPRIVATE */
446 1.1 jonathan sizeof(struct sadb_x_policy), /* SADB_X_EXT_POLICY */
447 1.1 jonathan sizeof(struct sadb_x_sa2), /* SADB_X_SA2 */
448 1.21 manu sizeof(struct sadb_x_nat_t_type), /* SADB_X_EXT_NAT_T_TYPE */
449 1.21 manu sizeof(struct sadb_x_nat_t_port), /* SADB_X_EXT_NAT_T_SPORT */
450 1.21 manu sizeof(struct sadb_x_nat_t_port), /* SADB_X_EXT_NAT_T_DPORT */
451 1.64 spz sizeof(struct sadb_address), /* SADB_X_EXT_NAT_T_OAI */
452 1.64 spz sizeof(struct sadb_address), /* SADB_X_EXT_NAT_T_OAR */
453 1.21 manu sizeof(struct sadb_x_nat_t_frag), /* SADB_X_EXT_NAT_T_FRAG */
454 1.1 jonathan };
455 1.1 jonathan static const int maxsize[] = {
456 1.1 jonathan sizeof(struct sadb_msg), /* SADB_EXT_RESERVED */
457 1.1 jonathan sizeof(struct sadb_sa), /* SADB_EXT_SA */
458 1.1 jonathan sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_CURRENT */
459 1.1 jonathan sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_HARD */
460 1.1 jonathan sizeof(struct sadb_lifetime), /* SADB_EXT_LIFETIME_SOFT */
461 1.1 jonathan 0, /* SADB_EXT_ADDRESS_SRC */
462 1.1 jonathan 0, /* SADB_EXT_ADDRESS_DST */
463 1.1 jonathan 0, /* SADB_EXT_ADDRESS_PROXY */
464 1.1 jonathan 0, /* SADB_EXT_KEY_AUTH */
465 1.1 jonathan 0, /* SADB_EXT_KEY_ENCRYPT */
466 1.1 jonathan 0, /* SADB_EXT_IDENTITY_SRC */
467 1.1 jonathan 0, /* SADB_EXT_IDENTITY_DST */
468 1.1 jonathan 0, /* SADB_EXT_SENSITIVITY */
469 1.1 jonathan 0, /* SADB_EXT_PROPOSAL */
470 1.1 jonathan 0, /* SADB_EXT_SUPPORTED_AUTH */
471 1.1 jonathan 0, /* SADB_EXT_SUPPORTED_ENCRYPT */
472 1.1 jonathan sizeof(struct sadb_spirange), /* SADB_EXT_SPIRANGE */
473 1.1 jonathan 0, /* SADB_X_EXT_KMPRIVATE */
474 1.1 jonathan 0, /* SADB_X_EXT_POLICY */
475 1.1 jonathan sizeof(struct sadb_x_sa2), /* SADB_X_SA2 */
476 1.21 manu sizeof(struct sadb_x_nat_t_type), /* SADB_X_EXT_NAT_T_TYPE */
477 1.21 manu sizeof(struct sadb_x_nat_t_port), /* SADB_X_EXT_NAT_T_SPORT */
478 1.21 manu sizeof(struct sadb_x_nat_t_port), /* SADB_X_EXT_NAT_T_DPORT */
479 1.64 spz 0, /* SADB_X_EXT_NAT_T_OAI */
480 1.64 spz 0, /* SADB_X_EXT_NAT_T_OAR */
481 1.21 manu sizeof(struct sadb_x_nat_t_frag), /* SADB_X_EXT_NAT_T_FRAG */
482 1.1 jonathan };
483 1.1 jonathan
484 1.1 jonathan static int ipsec_esp_keymin = 256;
485 1.1 jonathan static int ipsec_esp_auth = 0;
486 1.1 jonathan static int ipsec_ah_keymin = 128;
487 1.1 jonathan
488 1.1 jonathan #ifdef SYSCTL_DECL
489 1.1 jonathan SYSCTL_DECL(_net_key);
490 1.1 jonathan #endif
491 1.1 jonathan
492 1.1 jonathan #ifdef SYSCTL_INT
493 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_DEBUG_LEVEL, debug, CTLFLAG_RW, \
494 1.1 jonathan &key_debug_level, 0, "");
495 1.1 jonathan
496 1.1 jonathan /* max count of trial for the decision of spi value */
497 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_SPI_TRY, spi_trycnt, CTLFLAG_RW, \
498 1.1 jonathan &key_spi_trycnt, 0, "");
499 1.1 jonathan
500 1.1 jonathan /* minimum spi value to allocate automatically. */
501 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_SPI_MIN_VALUE, spi_minval, CTLFLAG_RW, \
502 1.1 jonathan &key_spi_minval, 0, "");
503 1.1 jonathan
504 1.1 jonathan /* maximun spi value to allocate automatically. */
505 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_SPI_MAX_VALUE, spi_maxval, CTLFLAG_RW, \
506 1.1 jonathan &key_spi_maxval, 0, "");
507 1.1 jonathan
508 1.1 jonathan /* interval to initialize randseed */
509 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_RANDOM_INT, int_random, CTLFLAG_RW, \
510 1.1 jonathan &key_int_random, 0, "");
511 1.1 jonathan
512 1.1 jonathan /* lifetime for larval SA */
513 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_LARVAL_LIFETIME, larval_lifetime, CTLFLAG_RW, \
514 1.1 jonathan &key_larval_lifetime, 0, "");
515 1.1 jonathan
516 1.1 jonathan /* counter for blocking to send SADB_ACQUIRE to IKEd */
517 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_BLOCKACQ_COUNT, blockacq_count, CTLFLAG_RW, \
518 1.1 jonathan &key_blockacq_count, 0, "");
519 1.1 jonathan
520 1.1 jonathan /* lifetime for blocking to send SADB_ACQUIRE to IKEd */
521 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_BLOCKACQ_LIFETIME, blockacq_lifetime, CTLFLAG_RW, \
522 1.1 jonathan &key_blockacq_lifetime, 0, "");
523 1.1 jonathan
524 1.1 jonathan /* ESP auth */
525 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_ESP_AUTH, esp_auth, CTLFLAG_RW, \
526 1.1 jonathan &ipsec_esp_auth, 0, "");
527 1.1 jonathan
528 1.1 jonathan /* minimum ESP key length */
529 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_ESP_KEYMIN, esp_keymin, CTLFLAG_RW, \
530 1.1 jonathan &ipsec_esp_keymin, 0, "");
531 1.1 jonathan
532 1.1 jonathan /* minimum AH key length */
533 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_AH_KEYMIN, ah_keymin, CTLFLAG_RW, \
534 1.1 jonathan &ipsec_ah_keymin, 0, "");
535 1.1 jonathan
536 1.1 jonathan /* perfered old SA rather than new SA */
537 1.1 jonathan SYSCTL_INT(_net_key, KEYCTL_PREFERED_OLDSA, prefered_oldsa, CTLFLAG_RW,\
538 1.1 jonathan &key_prefered_oldsa, 0, "");
539 1.3 tls #endif /* SYSCTL_INT */
540 1.1 jonathan
541 1.1 jonathan #define __LIST_CHAINED(elm) \
542 1.1 jonathan (!((elm)->chain.le_next == NULL && (elm)->chain.le_prev == NULL))
543 1.1 jonathan #define LIST_INSERT_TAIL(head, elm, type, field) \
544 1.1 jonathan do {\
545 1.1 jonathan struct type *curelm = LIST_FIRST(head); \
546 1.1 jonathan if (curelm == NULL) {\
547 1.1 jonathan LIST_INSERT_HEAD(head, elm, field); \
548 1.1 jonathan } else { \
549 1.1 jonathan while (LIST_NEXT(curelm, field)) \
550 1.1 jonathan curelm = LIST_NEXT(curelm, field);\
551 1.1 jonathan LIST_INSERT_AFTER(curelm, elm, field);\
552 1.1 jonathan }\
553 1.1 jonathan } while (0)
554 1.1 jonathan
555 1.134 ozaki #define KEY_CHKSASTATE(head, sav) \
556 1.57 dsl /* do */ { \
557 1.1 jonathan if ((head) != (sav)) { \
558 1.134 ozaki IPSECLOG(LOG_DEBUG, \
559 1.134 ozaki "state mismatched (TREE=%d SA=%d)\n", \
560 1.134 ozaki (head), (sav)); \
561 1.1 jonathan continue; \
562 1.1 jonathan } \
563 1.57 dsl } /* while (0) */
564 1.1 jonathan
565 1.134 ozaki #define KEY_CHKSPDIR(head, sp) \
566 1.1 jonathan do { \
567 1.1 jonathan if ((head) != (sp)) { \
568 1.134 ozaki IPSECLOG(LOG_DEBUG, \
569 1.134 ozaki "direction mismatched (TREE=%d SP=%d), anyway continue.\n",\
570 1.134 ozaki (head), (sp)); \
571 1.1 jonathan } \
572 1.1 jonathan } while (0)
573 1.1 jonathan
574 1.1 jonathan /*
575 1.1 jonathan * set parameters into secasindex buffer.
576 1.1 jonathan * Must allocate secasindex buffer before calling this function.
577 1.1 jonathan */
578 1.79 gdt static int
579 1.151 ozaki key_setsecasidx(int, int, int, const struct sockaddr *,
580 1.151 ozaki const struct sockaddr *, struct secasindex *);
581 1.79 gdt
582 1.1 jonathan /* key statistics */
583 1.1 jonathan struct _keystat {
584 1.1 jonathan u_long getspi_count; /* the avarage of count to try to get new SPI */
585 1.1 jonathan } keystat;
586 1.1 jonathan
587 1.1 jonathan struct sadb_msghdr {
588 1.1 jonathan struct sadb_msg *msg;
589 1.230 christos void *ext[SADB_EXT_MAX + 1];
590 1.1 jonathan int extoff[SADB_EXT_MAX + 1];
591 1.1 jonathan int extlen[SADB_EXT_MAX + 1];
592 1.1 jonathan };
593 1.1 jonathan
594 1.151 ozaki static void
595 1.151 ozaki key_init_spidx_bymsghdr(struct secpolicyindex *, const struct sadb_msghdr *);
596 1.151 ozaki
597 1.151 ozaki static const struct sockaddr *
598 1.151 ozaki key_msghdr_get_sockaddr(const struct sadb_msghdr *mhp, int idx)
599 1.151 ozaki {
600 1.151 ozaki
601 1.230 christos return PFKEY_ADDR_SADDR(mhp->ext[idx]);
602 1.151 ozaki }
603 1.151 ozaki
604 1.158 ozaki static struct mbuf *
605 1.158 ozaki key_fill_replymsg(struct mbuf *m, int seq)
606 1.158 ozaki {
607 1.158 ozaki struct sadb_msg *msg;
608 1.158 ozaki
609 1.158 ozaki if (m->m_len < sizeof(*msg)) {
610 1.158 ozaki m = m_pullup(m, sizeof(*msg));
611 1.158 ozaki if (m == NULL)
612 1.158 ozaki return NULL;
613 1.158 ozaki }
614 1.158 ozaki msg = mtod(m, struct sadb_msg *);
615 1.158 ozaki msg->sadb_msg_errno = 0;
616 1.158 ozaki msg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
617 1.158 ozaki if (seq != 0)
618 1.158 ozaki msg->sadb_msg_seq = seq;
619 1.158 ozaki
620 1.158 ozaki return m;
621 1.158 ozaki }
622 1.158 ozaki
623 1.143 ozaki #if 0
624 1.143 ozaki static void key_freeso(struct socket *);
625 1.143 ozaki static void key_freesp_so(struct secpolicy **);
626 1.143 ozaki #endif
627 1.66 drochner static struct secpolicy *key_getsp (const struct secpolicyindex *);
628 1.49 degroote static struct secpolicy *key_getspbyid (u_int32_t);
629 1.197 ozaki static struct secpolicy *key_lookup_and_remove_sp(const struct secpolicyindex *);
630 1.197 ozaki static struct secpolicy *key_lookupbyid_and_remove_sp(u_int32_t);
631 1.197 ozaki static void key_destroy_sp(struct secpolicy *);
632 1.49 degroote static u_int16_t key_newreqid (void);
633 1.49 degroote static struct mbuf *key_gather_mbuf (struct mbuf *,
634 1.49 degroote const struct sadb_msghdr *, int, int, ...);
635 1.162 ozaki static int key_api_spdadd(struct socket *, struct mbuf *,
636 1.49 degroote const struct sadb_msghdr *);
637 1.49 degroote static u_int32_t key_getnewspid (void);
638 1.162 ozaki static int key_api_spddelete(struct socket *, struct mbuf *,
639 1.49 degroote const struct sadb_msghdr *);
640 1.162 ozaki static int key_api_spddelete2(struct socket *, struct mbuf *,
641 1.49 degroote const struct sadb_msghdr *);
642 1.162 ozaki static int key_api_spdget(struct socket *, struct mbuf *,
643 1.49 degroote const struct sadb_msghdr *);
644 1.162 ozaki static int key_api_spdflush(struct socket *, struct mbuf *,
645 1.49 degroote const struct sadb_msghdr *);
646 1.162 ozaki static int key_api_spddump(struct socket *, struct mbuf *,
647 1.49 degroote const struct sadb_msghdr *);
648 1.49 degroote static struct mbuf * key_setspddump (int *errorp, pid_t);
649 1.49 degroote static struct mbuf * key_setspddump_chain (int *errorp, int *lenp, pid_t pid);
650 1.162 ozaki static int key_api_nat_map(struct socket *, struct mbuf *,
651 1.49 degroote const struct sadb_msghdr *);
652 1.49 degroote static struct mbuf *key_setdumpsp (struct secpolicy *,
653 1.49 degroote u_int8_t, u_int32_t, pid_t);
654 1.66 drochner static u_int key_getspreqmsglen (const struct secpolicy *);
655 1.49 degroote static int key_spdexpire (struct secpolicy *);
656 1.66 drochner static struct secashead *key_newsah (const struct secasindex *);
657 1.216 ozaki static void key_unlink_sah(struct secashead *);
658 1.216 ozaki static void key_destroy_sah(struct secashead *);
659 1.216 ozaki static bool key_sah_has_sav(struct secashead *);
660 1.216 ozaki static void key_sah_ref(struct secashead *);
661 1.216 ozaki static void key_sah_unref(struct secashead *);
662 1.223 ozaki static void key_init_sav(struct secasvar *);
663 1.223 ozaki static void key_destroy_sav(struct secasvar *);
664 1.223 ozaki static void key_destroy_sav_with_ref(struct secasvar *);
665 1.171 ozaki static struct secasvar *key_newsav(struct mbuf *,
666 1.171 ozaki const struct sadb_msghdr *, int *, const char*, int);
667 1.171 ozaki #define KEY_NEWSAV(m, sadb, e) \
668 1.171 ozaki key_newsav(m, sadb, e, __func__, __LINE__)
669 1.49 degroote static void key_delsav (struct secasvar *);
670 1.155 ozaki static struct secashead *key_getsah(const struct secasindex *, int);
671 1.216 ozaki static struct secashead *key_getsah_ref(const struct secasindex *, int);
672 1.174 ozaki static bool key_checkspidup(const struct secasindex *, u_int32_t);
673 1.49 degroote static struct secasvar *key_getsavbyspi (struct secashead *, u_int32_t);
674 1.49 degroote static int key_setsaval (struct secasvar *, struct mbuf *,
675 1.49 degroote const struct sadb_msghdr *);
676 1.131 ozaki static void key_freesaval(struct secasvar *);
677 1.171 ozaki static int key_init_xform(struct secasvar *);
678 1.169 ozaki static void key_clear_xform(struct secasvar *);
679 1.49 degroote static struct mbuf *key_setdumpsa (struct secasvar *, u_int8_t,
680 1.49 degroote u_int8_t, u_int32_t, u_int32_t);
681 1.49 degroote static struct mbuf *key_setsadbxport (u_int16_t, u_int16_t);
682 1.49 degroote static struct mbuf *key_setsadbxtype (u_int16_t);
683 1.76 drochner static struct mbuf *key_setsadbxfrag (u_int16_t);
684 1.49 degroote static void key_porttosaddr (union sockaddr_union *, u_int16_t);
685 1.49 degroote static int key_checksalen (const union sockaddr_union *);
686 1.49 degroote static struct mbuf *key_setsadbmsg (u_int8_t, u_int16_t, u_int8_t,
687 1.239 ozaki u_int32_t, pid_t, u_int16_t, int);
688 1.49 degroote static struct mbuf *key_setsadbsa (struct secasvar *);
689 1.239 ozaki static struct mbuf *key_setsadbaddr(u_int16_t,
690 1.239 ozaki const struct sockaddr *, u_int8_t, u_int16_t, int);
691 1.1 jonathan #if 0
692 1.49 degroote static struct mbuf *key_setsadbident (u_int16_t, u_int16_t, void *,
693 1.49 degroote int, u_int64_t);
694 1.1 jonathan #endif
695 1.49 degroote static struct mbuf *key_setsadbxsa2 (u_int8_t, u_int32_t, u_int16_t);
696 1.49 degroote static struct mbuf *key_setsadbxpolicy (u_int16_t, u_int8_t,
697 1.239 ozaki u_int32_t, int);
698 1.49 degroote static void *key_newbuf (const void *, u_int);
699 1.1 jonathan #ifdef INET6
700 1.66 drochner static int key_ismyaddr6 (const struct sockaddr_in6 *);
701 1.1 jonathan #endif
702 1.1 jonathan
703 1.104 ozaki static void sysctl_net_keyv2_setup(struct sysctllog **);
704 1.104 ozaki static void sysctl_net_key_compat_setup(struct sysctllog **);
705 1.104 ozaki
706 1.145 ozaki /* flags for key_saidx_match() */
707 1.1 jonathan #define CMP_HEAD 1 /* protocol, addresses. */
708 1.1 jonathan #define CMP_MODE_REQID 2 /* additionally HEAD, reqid, mode. */
709 1.1 jonathan #define CMP_REQID 3 /* additionally HEAD, reaid. */
710 1.1 jonathan #define CMP_EXACTLY 4 /* all elements. */
711 1.145 ozaki static int key_saidx_match(const struct secasindex *,
712 1.145 ozaki const struct secasindex *, int);
713 1.1 jonathan
714 1.145 ozaki static int key_sockaddr_match(const struct sockaddr *,
715 1.145 ozaki const struct sockaddr *, int);
716 1.145 ozaki static int key_bb_match_withmask(const void *, const void *, u_int);
717 1.49 degroote static u_int16_t key_satype2proto (u_int8_t);
718 1.49 degroote static u_int8_t key_proto2satype (u_int16_t);
719 1.49 degroote
720 1.145 ozaki static int key_spidx_match_exactly(const struct secpolicyindex *,
721 1.144 ozaki const struct secpolicyindex *);
722 1.145 ozaki static int key_spidx_match_withmask(const struct secpolicyindex *,
723 1.144 ozaki const struct secpolicyindex *);
724 1.144 ozaki
725 1.162 ozaki static int key_api_getspi(struct socket *, struct mbuf *,
726 1.49 degroote const struct sadb_msghdr *);
727 1.66 drochner static u_int32_t key_do_getnewspi (const struct sadb_spirange *,
728 1.66 drochner const struct secasindex *);
729 1.79 gdt static int key_handle_natt_info (struct secasvar *,
730 1.49 degroote const struct sadb_msghdr *);
731 1.64 spz static int key_set_natt_ports (union sockaddr_union *,
732 1.64 spz union sockaddr_union *,
733 1.64 spz const struct sadb_msghdr *);
734 1.162 ozaki static int key_api_update(struct socket *, struct mbuf *,
735 1.49 degroote const struct sadb_msghdr *);
736 1.1 jonathan #ifdef IPSEC_DOSEQCHECK
737 1.49 degroote static struct secasvar *key_getsavbyseq (struct secashead *, u_int32_t);
738 1.1 jonathan #endif
739 1.162 ozaki static int key_api_add(struct socket *, struct mbuf *,
740 1.49 degroote const struct sadb_msghdr *);
741 1.49 degroote static int key_setident (struct secashead *, struct mbuf *,
742 1.49 degroote const struct sadb_msghdr *);
743 1.49 degroote static struct mbuf *key_getmsgbuf_x1 (struct mbuf *,
744 1.49 degroote const struct sadb_msghdr *);
745 1.162 ozaki static int key_api_delete(struct socket *, struct mbuf *,
746 1.49 degroote const struct sadb_msghdr *);
747 1.162 ozaki static int key_api_get(struct socket *, struct mbuf *,
748 1.49 degroote const struct sadb_msghdr *);
749 1.49 degroote
750 1.49 degroote static void key_getcomb_setlifetime (struct sadb_comb *);
751 1.239 ozaki static struct mbuf *key_getcomb_esp(int);
752 1.239 ozaki static struct mbuf *key_getcomb_ah(int);
753 1.239 ozaki static struct mbuf *key_getcomb_ipcomp(int);
754 1.239 ozaki static struct mbuf *key_getprop(const struct secasindex *, int);
755 1.1 jonathan
756 1.239 ozaki static int key_acquire(const struct secasindex *, const struct secpolicy *,
757 1.239 ozaki int);
758 1.222 ozaki static int key_acquire_sendup_mbuf_later(struct mbuf *);
759 1.220 ozaki static void key_acquire_sendup_pending_mbuf(void);
760 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
761 1.49 degroote static struct secacq *key_newacq (const struct secasindex *);
762 1.49 degroote static struct secacq *key_getacq (const struct secasindex *);
763 1.49 degroote static struct secacq *key_getacqbyseq (u_int32_t);
764 1.49 degroote #endif
765 1.139 ozaki #ifdef notyet
766 1.66 drochner static struct secspacq *key_newspacq (const struct secpolicyindex *);
767 1.66 drochner static struct secspacq *key_getspacq (const struct secpolicyindex *);
768 1.139 ozaki #endif
769 1.162 ozaki static int key_api_acquire(struct socket *, struct mbuf *,
770 1.49 degroote const struct sadb_msghdr *);
771 1.162 ozaki static int key_api_register(struct socket *, struct mbuf *,
772 1.49 degroote const struct sadb_msghdr *);
773 1.49 degroote static int key_expire (struct secasvar *);
774 1.162 ozaki static int key_api_flush(struct socket *, struct mbuf *,
775 1.49 degroote const struct sadb_msghdr *);
776 1.49 degroote static struct mbuf *key_setdump_chain (u_int8_t req_satype, int *errorp,
777 1.49 degroote int *lenp, pid_t pid);
778 1.162 ozaki static int key_api_dump(struct socket *, struct mbuf *,
779 1.49 degroote const struct sadb_msghdr *);
780 1.162 ozaki static int key_api_promisc(struct socket *, struct mbuf *,
781 1.49 degroote const struct sadb_msghdr *);
782 1.49 degroote static int key_senderror (struct socket *, struct mbuf *, int);
783 1.49 degroote static int key_validate_ext (const struct sadb_ext *, int);
784 1.49 degroote static int key_align (struct mbuf *, struct sadb_msghdr *);
785 1.1 jonathan #if 0
786 1.49 degroote static const char *key_getfqdn (void);
787 1.49 degroote static const char *key_getuserfqdn (void);
788 1.1 jonathan #endif
789 1.49 degroote static void key_sa_chgstate (struct secasvar *, u_int8_t);
790 1.18 jonathan
791 1.239 ozaki static struct mbuf *key_alloc_mbuf(int, int);
792 1.236 ozaki static struct mbuf *key_alloc_mbuf_simple(int, int);
793 1.126 ozaki
794 1.126 ozaki static void key_timehandler(void *);
795 1.126 ozaki static void key_timehandler_work(struct work *, void *);
796 1.126 ozaki static struct callout key_timehandler_ch;
797 1.126 ozaki static struct workqueue *key_timehandler_wq;
798 1.126 ozaki static struct work key_timehandler_wk;
799 1.1 jonathan
800 1.193 ozaki u_int
801 1.193 ozaki key_sp_refcnt(const struct secpolicy *sp)
802 1.193 ozaki {
803 1.193 ozaki
804 1.197 ozaki /* FIXME */
805 1.197 ozaki return 0;
806 1.193 ozaki }
807 1.18 jonathan
808 1.227 ozaki #ifdef NET_MPSAFE
809 1.226 ozaki static void
810 1.226 ozaki key_spd_pserialize_perform(void)
811 1.226 ozaki {
812 1.226 ozaki
813 1.226 ozaki KASSERT(mutex_owned(&key_spd.lock));
814 1.226 ozaki
815 1.226 ozaki while (key_spd.psz_performing)
816 1.226 ozaki cv_wait(&key_spd.cv_psz, &key_spd.lock);
817 1.226 ozaki key_spd.psz_performing = true;
818 1.226 ozaki mutex_exit(&key_spd.lock);
819 1.226 ozaki
820 1.226 ozaki pserialize_perform(key_spd.psz);
821 1.226 ozaki
822 1.226 ozaki mutex_enter(&key_spd.lock);
823 1.226 ozaki key_spd.psz_performing = false;
824 1.226 ozaki cv_broadcast(&key_spd.cv_psz);
825 1.226 ozaki }
826 1.227 ozaki #endif
827 1.226 ozaki
828 1.197 ozaki /*
829 1.208 ozaki * Remove the sp from the key_spd.splist and wait for references to the sp
830 1.208 ozaki * to be released. key_spd.lock must be held.
831 1.197 ozaki */
832 1.197 ozaki static void
833 1.197 ozaki key_unlink_sp(struct secpolicy *sp)
834 1.18 jonathan {
835 1.18 jonathan
836 1.208 ozaki KASSERT(mutex_owned(&key_spd.lock));
837 1.197 ozaki
838 1.18 jonathan sp->state = IPSEC_SPSTATE_DEAD;
839 1.197 ozaki SPLIST_WRITER_REMOVE(sp);
840 1.197 ozaki
841 1.197 ozaki /* Invalidate all cached SPD pointers in the PCBs. */
842 1.197 ozaki ipsec_invalpcbcacheall();
843 1.18 jonathan
844 1.197 ozaki #ifdef NET_MPSAFE
845 1.197 ozaki KASSERT(mutex_ownable(softnet_lock));
846 1.226 ozaki key_spd_pserialize_perform();
847 1.197 ozaki #endif
848 1.18 jonathan
849 1.226 ozaki localcount_drain(&sp->localcount, &key_spd.cv_lc, &key_spd.lock);
850 1.18 jonathan }
851 1.18 jonathan
852 1.1 jonathan /*
853 1.1 jonathan * Return 0 when there are known to be no SP's for the specified
854 1.1 jonathan * direction. Otherwise return 1. This is used by IPsec code
855 1.1 jonathan * to optimize performance.
856 1.1 jonathan */
857 1.1 jonathan int
858 1.1 jonathan key_havesp(u_int dir)
859 1.1 jonathan {
860 1.1 jonathan return (dir == IPSEC_DIR_INBOUND || dir == IPSEC_DIR_OUTBOUND ?
861 1.194 ozaki !SPLIST_READER_EMPTY(dir) : 1);
862 1.1 jonathan }
863 1.1 jonathan
864 1.1 jonathan /* %%% IPsec policy management */
865 1.1 jonathan /*
866 1.1 jonathan * allocating a SP for OUTBOUND or INBOUND packet.
867 1.1 jonathan * Must call key_freesp() later.
868 1.1 jonathan * OUT: NULL: not found
869 1.1 jonathan * others: found and return the pointer.
870 1.1 jonathan */
871 1.1 jonathan struct secpolicy *
872 1.168 ozaki key_lookup_sp_byspidx(const struct secpolicyindex *spidx,
873 1.168 ozaki u_int dir, const char* where, int tag)
874 1.1 jonathan {
875 1.1 jonathan struct secpolicy *sp;
876 1.1 jonathan int s;
877 1.1 jonathan
878 1.108 ozaki KASSERT(spidx != NULL);
879 1.116 ozaki KASSERTMSG(IPSEC_DIR_IS_INOROUT(dir), "invalid direction %u", dir);
880 1.1 jonathan
881 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP, "DP from %s:%u\n", where, tag);
882 1.1 jonathan
883 1.1 jonathan /* get a SP entry */
884 1.111 ozaki if (KEYDEBUG_ON(KEYDEBUG_IPSEC_DATA)) {
885 1.228 christos kdebug_secpolicyindex("objects", spidx);
886 1.111 ozaki }
887 1.1 jonathan
888 1.197 ozaki s = pserialize_read_enter();
889 1.194 ozaki SPLIST_READER_FOREACH(sp, dir) {
890 1.111 ozaki if (KEYDEBUG_ON(KEYDEBUG_IPSEC_DATA)) {
891 1.228 christos kdebug_secpolicyindex("in SPD", &sp->spidx);
892 1.111 ozaki }
893 1.1 jonathan
894 1.1 jonathan if (sp->state == IPSEC_SPSTATE_DEAD)
895 1.1 jonathan continue;
896 1.145 ozaki if (key_spidx_match_withmask(&sp->spidx, spidx))
897 1.1 jonathan goto found;
898 1.1 jonathan }
899 1.1 jonathan sp = NULL;
900 1.1 jonathan found:
901 1.1 jonathan if (sp) {
902 1.1 jonathan /* sanity check */
903 1.134 ozaki KEY_CHKSPDIR(sp->spidx.dir, dir);
904 1.1 jonathan
905 1.1 jonathan /* found a SPD entry */
906 1.69 drochner sp->lastused = time_uptime;
907 1.197 ozaki key_sp_ref(sp, where, tag);
908 1.1 jonathan }
909 1.197 ozaki pserialize_read_exit(s);
910 1.1 jonathan
911 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
912 1.111 ozaki "DP return SP:%p (ID=%u) refcnt %u\n",
913 1.193 ozaki sp, sp ? sp->id : 0, key_sp_refcnt(sp));
914 1.1 jonathan return sp;
915 1.1 jonathan }
916 1.1 jonathan
917 1.1 jonathan /*
918 1.1 jonathan * return a policy that matches this particular inbound packet.
919 1.1 jonathan * XXX slow
920 1.1 jonathan */
921 1.1 jonathan struct secpolicy *
922 1.1 jonathan key_gettunnel(const struct sockaddr *osrc,
923 1.1 jonathan const struct sockaddr *odst,
924 1.1 jonathan const struct sockaddr *isrc,
925 1.1 jonathan const struct sockaddr *idst,
926 1.1 jonathan const char* where, int tag)
927 1.1 jonathan {
928 1.1 jonathan struct secpolicy *sp;
929 1.1 jonathan const int dir = IPSEC_DIR_INBOUND;
930 1.1 jonathan int s;
931 1.1 jonathan struct ipsecrequest *r1, *r2, *p;
932 1.1 jonathan struct secpolicyindex spidx;
933 1.1 jonathan
934 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP, "DP from %s:%u\n", where, tag);
935 1.1 jonathan
936 1.1 jonathan if (isrc->sa_family != idst->sa_family) {
937 1.134 ozaki IPSECLOG(LOG_ERR, "protocol family mismatched %d != %d\n.",
938 1.134 ozaki isrc->sa_family, idst->sa_family);
939 1.1 jonathan sp = NULL;
940 1.1 jonathan goto done;
941 1.1 jonathan }
942 1.1 jonathan
943 1.197 ozaki s = pserialize_read_enter();
944 1.194 ozaki SPLIST_READER_FOREACH(sp, dir) {
945 1.1 jonathan if (sp->state == IPSEC_SPSTATE_DEAD)
946 1.1 jonathan continue;
947 1.1 jonathan
948 1.1 jonathan r1 = r2 = NULL;
949 1.1 jonathan for (p = sp->req; p; p = p->next) {
950 1.1 jonathan if (p->saidx.mode != IPSEC_MODE_TUNNEL)
951 1.1 jonathan continue;
952 1.1 jonathan
953 1.1 jonathan r1 = r2;
954 1.1 jonathan r2 = p;
955 1.1 jonathan
956 1.1 jonathan if (!r1) {
957 1.1 jonathan /* here we look at address matches only */
958 1.1 jonathan spidx = sp->spidx;
959 1.1 jonathan if (isrc->sa_len > sizeof(spidx.src) ||
960 1.1 jonathan idst->sa_len > sizeof(spidx.dst))
961 1.1 jonathan continue;
962 1.49 degroote memcpy(&spidx.src, isrc, isrc->sa_len);
963 1.49 degroote memcpy(&spidx.dst, idst, idst->sa_len);
964 1.145 ozaki if (!key_spidx_match_withmask(&sp->spidx, &spidx))
965 1.1 jonathan continue;
966 1.1 jonathan } else {
967 1.145 ozaki if (!key_sockaddr_match(&r1->saidx.src.sa, isrc, PORT_NONE) ||
968 1.145 ozaki !key_sockaddr_match(&r1->saidx.dst.sa, idst, PORT_NONE))
969 1.1 jonathan continue;
970 1.1 jonathan }
971 1.1 jonathan
972 1.145 ozaki if (!key_sockaddr_match(&r2->saidx.src.sa, osrc, PORT_NONE) ||
973 1.145 ozaki !key_sockaddr_match(&r2->saidx.dst.sa, odst, PORT_NONE))
974 1.1 jonathan continue;
975 1.1 jonathan
976 1.1 jonathan goto found;
977 1.1 jonathan }
978 1.1 jonathan }
979 1.1 jonathan sp = NULL;
980 1.1 jonathan found:
981 1.1 jonathan if (sp) {
982 1.69 drochner sp->lastused = time_uptime;
983 1.197 ozaki key_sp_ref(sp, where, tag);
984 1.1 jonathan }
985 1.197 ozaki pserialize_read_exit(s);
986 1.1 jonathan done:
987 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
988 1.111 ozaki "DP return SP:%p (ID=%u) refcnt %u\n",
989 1.193 ozaki sp, sp ? sp->id : 0, key_sp_refcnt(sp));
990 1.1 jonathan return sp;
991 1.1 jonathan }
992 1.1 jonathan
993 1.1 jonathan /*
994 1.1 jonathan * allocating an SA entry for an *OUTBOUND* packet.
995 1.1 jonathan * checking each request entries in SP, and acquire an SA if need.
996 1.1 jonathan * OUT: 0: there are valid requests.
997 1.1 jonathan * ENOENT: policy may be valid, but SA with REQUIRE is on acquiring.
998 1.1 jonathan */
999 1.1 jonathan int
1000 1.234 ozaki key_checkrequest(const struct ipsecrequest *isr, const struct secasindex *saidx,
1001 1.233 ozaki struct secasvar **ret)
1002 1.1 jonathan {
1003 1.1 jonathan u_int level;
1004 1.1 jonathan int error;
1005 1.190 ozaki struct secasvar *sav;
1006 1.1 jonathan
1007 1.108 ozaki KASSERT(isr != NULL);
1008 1.108 ozaki KASSERTMSG(saidx->mode == IPSEC_MODE_TRANSPORT ||
1009 1.108 ozaki saidx->mode == IPSEC_MODE_TUNNEL,
1010 1.108 ozaki "unexpected policy %u", saidx->mode);
1011 1.1 jonathan
1012 1.1 jonathan /* get current level */
1013 1.1 jonathan level = ipsec_get_reqlevel(isr);
1014 1.1 jonathan
1015 1.1 jonathan /*
1016 1.1 jonathan * XXX guard against protocol callbacks from the crypto
1017 1.1 jonathan * thread as they reference ipsecrequest.sav which we
1018 1.1 jonathan * temporarily null out below. Need to rethink how we
1019 1.1 jonathan * handle bundled SA's in the callback thread.
1020 1.1 jonathan */
1021 1.1 jonathan IPSEC_SPLASSERT_SOFTNET("key_checkrequest");
1022 1.1 jonathan
1023 1.190 ozaki sav = key_lookup_sa_bysaidx(saidx);
1024 1.190 ozaki if (sav != NULL) {
1025 1.190 ozaki *ret = sav;
1026 1.1 jonathan return 0;
1027 1.184 ozaki }
1028 1.1 jonathan
1029 1.1 jonathan /* there is no SA */
1030 1.239 ozaki error = key_acquire(saidx, isr->sp, M_NOWAIT);
1031 1.1 jonathan if (error != 0) {
1032 1.1 jonathan /* XXX What should I do ? */
1033 1.134 ozaki IPSECLOG(LOG_DEBUG, "error %d returned from key_acquire.\n",
1034 1.134 ozaki error);
1035 1.1 jonathan return error;
1036 1.1 jonathan }
1037 1.1 jonathan
1038 1.1 jonathan if (level != IPSEC_LEVEL_REQUIRE) {
1039 1.1 jonathan /* XXX sigh, the interface to this routine is botched */
1040 1.184 ozaki *ret = NULL;
1041 1.1 jonathan return 0;
1042 1.1 jonathan } else {
1043 1.1 jonathan return ENOENT;
1044 1.1 jonathan }
1045 1.1 jonathan }
1046 1.1 jonathan
1047 1.1 jonathan /*
1048 1.188 ozaki * looking up a SA for policy entry from SAD.
1049 1.1 jonathan * NOTE: searching SAD of aliving state.
1050 1.1 jonathan * OUT: NULL: not found.
1051 1.1 jonathan * others: found and return the pointer.
1052 1.1 jonathan */
1053 1.232 ozaki struct secasvar *
1054 1.188 ozaki key_lookup_sa_bysaidx(const struct secasindex *saidx)
1055 1.1 jonathan {
1056 1.1 jonathan struct secashead *sah;
1057 1.205 ozaki struct secasvar *sav = NULL;
1058 1.1 jonathan u_int stateidx, state;
1059 1.67 drochner const u_int *saorder_state_valid;
1060 1.67 drochner int arraysize;
1061 1.205 ozaki int s;
1062 1.1 jonathan
1063 1.205 ozaki s = pserialize_read_enter();
1064 1.155 ozaki sah = key_getsah(saidx, CMP_MODE_REQID);
1065 1.155 ozaki if (sah == NULL)
1066 1.205 ozaki goto out;
1067 1.1 jonathan
1068 1.67 drochner /*
1069 1.67 drochner * search a valid state list for outbound packet.
1070 1.67 drochner * This search order is important.
1071 1.67 drochner */
1072 1.67 drochner if (key_prefered_oldsa) {
1073 1.67 drochner saorder_state_valid = saorder_state_valid_prefer_old;
1074 1.67 drochner arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
1075 1.67 drochner } else {
1076 1.67 drochner saorder_state_valid = saorder_state_valid_prefer_new;
1077 1.67 drochner arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
1078 1.67 drochner }
1079 1.67 drochner
1080 1.1 jonathan /* search valid state */
1081 1.1 jonathan for (stateidx = 0;
1082 1.67 drochner stateidx < arraysize;
1083 1.1 jonathan stateidx++) {
1084 1.1 jonathan
1085 1.1 jonathan state = saorder_state_valid[stateidx];
1086 1.1 jonathan
1087 1.183 ozaki if (key_prefered_oldsa)
1088 1.203 ozaki sav = SAVLIST_READER_FIRST(sah, state);
1089 1.183 ozaki else {
1090 1.183 ozaki /* XXX need O(1) lookup */
1091 1.183 ozaki struct secasvar *last = NULL;
1092 1.183 ozaki
1093 1.203 ozaki SAVLIST_READER_FOREACH(sav, sah, state)
1094 1.183 ozaki last = sav;
1095 1.183 ozaki sav = last;
1096 1.183 ozaki }
1097 1.183 ozaki if (sav != NULL) {
1098 1.223 ozaki KEY_SA_REF(sav);
1099 1.183 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1100 1.183 ozaki "DP cause refcnt++:%d SA:%p\n",
1101 1.217 ozaki key_sa_refcnt(sav), sav);
1102 1.205 ozaki break;
1103 1.183 ozaki }
1104 1.1 jonathan }
1105 1.205 ozaki out:
1106 1.205 ozaki pserialize_read_exit(s);
1107 1.1 jonathan
1108 1.205 ozaki return sav;
1109 1.1 jonathan }
1110 1.1 jonathan
1111 1.183 ozaki #if 0
1112 1.176 ozaki static void
1113 1.176 ozaki key_sendup_message_delete(struct secasvar *sav)
1114 1.176 ozaki {
1115 1.176 ozaki struct mbuf *m, *result = 0;
1116 1.176 ozaki uint8_t satype;
1117 1.176 ozaki
1118 1.176 ozaki satype = key_proto2satype(sav->sah->saidx.proto);
1119 1.176 ozaki if (satype == 0)
1120 1.176 ozaki goto msgfail;
1121 1.176 ozaki
1122 1.217 ozaki m = key_setsadbmsg(SADB_DELETE, 0, satype, 0, 0, key_sa_refcnt(sav) - 1);
1123 1.176 ozaki if (m == NULL)
1124 1.176 ozaki goto msgfail;
1125 1.176 ozaki result = m;
1126 1.176 ozaki
1127 1.176 ozaki /* set sadb_address for saidx's. */
1128 1.176 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC, &sav->sah->saidx.src.sa,
1129 1.176 ozaki sav->sah->saidx.src.sa.sa_len << 3, IPSEC_ULPROTO_ANY);
1130 1.176 ozaki if (m == NULL)
1131 1.176 ozaki goto msgfail;
1132 1.176 ozaki m_cat(result, m);
1133 1.176 ozaki
1134 1.176 ozaki /* set sadb_address for saidx's. */
1135 1.176 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_DST, &sav->sah->saidx.src.sa,
1136 1.176 ozaki sav->sah->saidx.src.sa.sa_len << 3, IPSEC_ULPROTO_ANY);
1137 1.176 ozaki if (m == NULL)
1138 1.176 ozaki goto msgfail;
1139 1.176 ozaki m_cat(result, m);
1140 1.176 ozaki
1141 1.176 ozaki /* create SA extension */
1142 1.176 ozaki m = key_setsadbsa(sav);
1143 1.176 ozaki if (m == NULL)
1144 1.176 ozaki goto msgfail;
1145 1.176 ozaki m_cat(result, m);
1146 1.176 ozaki
1147 1.176 ozaki if (result->m_len < sizeof(struct sadb_msg)) {
1148 1.176 ozaki result = m_pullup(result, sizeof(struct sadb_msg));
1149 1.176 ozaki if (result == NULL)
1150 1.176 ozaki goto msgfail;
1151 1.176 ozaki }
1152 1.176 ozaki
1153 1.176 ozaki result->m_pkthdr.len = 0;
1154 1.176 ozaki for (m = result; m; m = m->m_next)
1155 1.176 ozaki result->m_pkthdr.len += m->m_len;
1156 1.176 ozaki mtod(result, struct sadb_msg *)->sadb_msg_len =
1157 1.176 ozaki PFKEY_UNIT64(result->m_pkthdr.len);
1158 1.176 ozaki
1159 1.176 ozaki key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
1160 1.176 ozaki result = NULL;
1161 1.176 ozaki msgfail:
1162 1.176 ozaki if (result)
1163 1.176 ozaki m_freem(result);
1164 1.176 ozaki }
1165 1.183 ozaki #endif
1166 1.1 jonathan
1167 1.1 jonathan /*
1168 1.1 jonathan * allocating a usable SA entry for a *INBOUND* packet.
1169 1.1 jonathan * Must call key_freesav() later.
1170 1.1 jonathan * OUT: positive: pointer to a usable sav (i.e. MATURE or DYING state).
1171 1.7 wiz * NULL: not found, or error occurred.
1172 1.1 jonathan *
1173 1.1 jonathan * In the comparison, no source address is used--for RFC2401 conformance.
1174 1.1 jonathan * To quote, from section 4.1:
1175 1.1 jonathan * A security association is uniquely identified by a triple consisting
1176 1.1 jonathan * of a Security Parameter Index (SPI), an IP Destination Address, and a
1177 1.1 jonathan * security protocol (AH or ESP) identifier.
1178 1.1 jonathan * Note that, however, we do need to keep source address in IPsec SA.
1179 1.1 jonathan * IKE specification and PF_KEY specification do assume that we
1180 1.1 jonathan * keep source address in IPsec SA. We see a tricky situation here.
1181 1.48 degroote *
1182 1.48 degroote * sport and dport are used for NAT-T. network order is always used.
1183 1.1 jonathan */
1184 1.1 jonathan struct secasvar *
1185 1.168 ozaki key_lookup_sa(
1186 1.37 degroote const union sockaddr_union *dst,
1187 1.1 jonathan u_int proto,
1188 1.1 jonathan u_int32_t spi,
1189 1.48 degroote u_int16_t sport,
1190 1.48 degroote u_int16_t dport,
1191 1.1 jonathan const char* where, int tag)
1192 1.1 jonathan {
1193 1.1 jonathan struct secashead *sah;
1194 1.1 jonathan struct secasvar *sav;
1195 1.1 jonathan u_int stateidx, state;
1196 1.67 drochner const u_int *saorder_state_valid;
1197 1.96 christos int arraysize, chkport;
1198 1.1 jonathan int s;
1199 1.1 jonathan
1200 1.33 degroote int must_check_spi = 1;
1201 1.33 degroote int must_check_alg = 0;
1202 1.33 degroote u_int16_t cpi = 0;
1203 1.33 degroote u_int8_t algo = 0;
1204 1.33 degroote
1205 1.48 degroote if ((sport != 0) && (dport != 0))
1206 1.96 christos chkport = PORT_STRICT;
1207 1.96 christos else
1208 1.96 christos chkport = PORT_NONE;
1209 1.48 degroote
1210 1.108 ozaki KASSERT(dst != NULL);
1211 1.1 jonathan
1212 1.1 jonathan /*
1213 1.79 gdt * XXX IPCOMP case
1214 1.33 degroote * We use cpi to define spi here. In the case where cpi <=
1215 1.33 degroote * IPCOMP_CPI_NEGOTIATE_MIN, cpi just define the algorithm used, not
1216 1.33 degroote * the real spi. In this case, don't check the spi but check the
1217 1.33 degroote * algorithm
1218 1.33 degroote */
1219 1.79 gdt
1220 1.33 degroote if (proto == IPPROTO_IPCOMP) {
1221 1.33 degroote u_int32_t tmp;
1222 1.33 degroote tmp = ntohl(spi);
1223 1.33 degroote cpi = (u_int16_t) tmp;
1224 1.33 degroote if (cpi < IPCOMP_CPI_NEGOTIATE_MIN) {
1225 1.33 degroote algo = (u_int8_t) cpi;
1226 1.33 degroote must_check_spi = 0;
1227 1.33 degroote must_check_alg = 1;
1228 1.33 degroote }
1229 1.33 degroote }
1230 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1231 1.111 ozaki "DP from %s:%u check_spi=%d, check_alg=%d\n",
1232 1.111 ozaki where, tag, must_check_spi, must_check_alg);
1233 1.92 christos
1234 1.33 degroote
1235 1.33 degroote /*
1236 1.1 jonathan * searching SAD.
1237 1.1 jonathan * XXX: to be checked internal IP header somewhere. Also when
1238 1.1 jonathan * IPsec tunnel packet is received. But ESP tunnel mode is
1239 1.1 jonathan * encrypted so we can't check internal IP header.
1240 1.1 jonathan */
1241 1.67 drochner if (key_prefered_oldsa) {
1242 1.67 drochner saorder_state_valid = saorder_state_valid_prefer_old;
1243 1.67 drochner arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
1244 1.67 drochner } else {
1245 1.67 drochner saorder_state_valid = saorder_state_valid_prefer_new;
1246 1.67 drochner arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
1247 1.67 drochner }
1248 1.205 ozaki s = pserialize_read_enter();
1249 1.202 ozaki SAHLIST_READER_FOREACH(sah) {
1250 1.1 jonathan /* search valid state */
1251 1.67 drochner for (stateidx = 0; stateidx < arraysize; stateidx++) {
1252 1.1 jonathan state = saorder_state_valid[stateidx];
1253 1.203 ozaki SAVLIST_READER_FOREACH(sav, sah, state) {
1254 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
1255 1.111 ozaki "try match spi %#x, %#x\n",
1256 1.111 ozaki ntohl(spi), ntohl(sav->spi));
1257 1.1 jonathan /* sanity check */
1258 1.134 ozaki KEY_CHKSASTATE(sav->state, state);
1259 1.1 jonathan /* do not return entries w/ unusable state */
1260 1.165 ozaki if (!SADB_SASTATE_USABLE_P(sav)) {
1261 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
1262 1.111 ozaki "bad state %d\n", sav->state);
1263 1.1 jonathan continue;
1264 1.92 christos }
1265 1.92 christos if (proto != sav->sah->saidx.proto) {
1266 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
1267 1.111 ozaki "proto fail %d != %d\n",
1268 1.111 ozaki proto, sav->sah->saidx.proto);
1269 1.1 jonathan continue;
1270 1.92 christos }
1271 1.92 christos if (must_check_spi && spi != sav->spi) {
1272 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
1273 1.111 ozaki "spi fail %#x != %#x\n",
1274 1.111 ozaki ntohl(spi), ntohl(sav->spi));
1275 1.33 degroote continue;
1276 1.92 christos }
1277 1.33 degroote /* XXX only on the ipcomp case */
1278 1.92 christos if (must_check_alg && algo != sav->alg_comp) {
1279 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
1280 1.111 ozaki "algo fail %d != %d\n",
1281 1.111 ozaki algo, sav->alg_comp);
1282 1.1 jonathan continue;
1283 1.92 christos }
1284 1.33 degroote
1285 1.1 jonathan #if 0 /* don't check src */
1286 1.48 degroote /* Fix port in src->sa */
1287 1.79 gdt
1288 1.1 jonathan /* check src address */
1289 1.145 ozaki if (!key_sockaddr_match(&src->sa, &sav->sah->saidx.src.sa, PORT_NONE))
1290 1.1 jonathan continue;
1291 1.1 jonathan #endif
1292 1.48 degroote /* fix port of dst address XXX*/
1293 1.48 degroote key_porttosaddr(__UNCONST(dst), dport);
1294 1.1 jonathan /* check dst address */
1295 1.145 ozaki if (!key_sockaddr_match(&dst->sa, &sav->sah->saidx.dst.sa, chkport))
1296 1.1 jonathan continue;
1297 1.223 ozaki key_sa_ref(sav, where, tag);
1298 1.1 jonathan goto done;
1299 1.1 jonathan }
1300 1.1 jonathan }
1301 1.1 jonathan }
1302 1.1 jonathan sav = NULL;
1303 1.1 jonathan done:
1304 1.205 ozaki pserialize_read_exit(s);
1305 1.1 jonathan
1306 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1307 1.217 ozaki "DP return SA:%p; refcnt %u\n", sav, key_sa_refcnt(sav));
1308 1.1 jonathan return sav;
1309 1.1 jonathan }
1310 1.1 jonathan
1311 1.183 ozaki static void
1312 1.183 ozaki key_validate_savlist(const struct secashead *sah, const u_int state)
1313 1.183 ozaki {
1314 1.183 ozaki #ifdef DEBUG
1315 1.183 ozaki struct secasvar *sav, *next;
1316 1.205 ozaki int s;
1317 1.183 ozaki
1318 1.183 ozaki /*
1319 1.183 ozaki * The list should be sorted by lft_c->sadb_lifetime_addtime
1320 1.183 ozaki * in ascending order.
1321 1.183 ozaki */
1322 1.205 ozaki s = pserialize_read_enter();
1323 1.203 ozaki SAVLIST_READER_FOREACH(sav, sah, state) {
1324 1.203 ozaki next = SAVLIST_READER_NEXT(sav);
1325 1.183 ozaki if (next != NULL &&
1326 1.183 ozaki sav->lft_c != NULL && next->lft_c != NULL) {
1327 1.183 ozaki KDASSERTMSG(sav->lft_c->sadb_lifetime_addtime <=
1328 1.183 ozaki next->lft_c->sadb_lifetime_addtime,
1329 1.183 ozaki "savlist is not sorted: sah=%p, state=%d, "
1330 1.185 christos "sav=%" PRIu64 ", next=%" PRIu64, sah, state,
1331 1.183 ozaki sav->lft_c->sadb_lifetime_addtime,
1332 1.183 ozaki next->lft_c->sadb_lifetime_addtime);
1333 1.183 ozaki }
1334 1.183 ozaki }
1335 1.205 ozaki pserialize_read_exit(s);
1336 1.183 ozaki #endif
1337 1.183 ozaki }
1338 1.183 ozaki
1339 1.148 ozaki void
1340 1.197 ozaki key_init_sp(struct secpolicy *sp)
1341 1.197 ozaki {
1342 1.197 ozaki
1343 1.197 ozaki ASSERT_SLEEPABLE();
1344 1.197 ozaki
1345 1.197 ozaki sp->state = IPSEC_SPSTATE_ALIVE;
1346 1.197 ozaki if (sp->policy == IPSEC_POLICY_IPSEC)
1347 1.197 ozaki KASSERT(sp->req != NULL);
1348 1.197 ozaki localcount_init(&sp->localcount);
1349 1.197 ozaki SPLIST_ENTRY_INIT(sp);
1350 1.197 ozaki }
1351 1.197 ozaki
1352 1.211 ozaki /*
1353 1.214 ozaki * Must be called in a pserialize read section. A held SP
1354 1.211 ozaki * must be released by key_sp_unref after use.
1355 1.211 ozaki */
1356 1.197 ozaki void
1357 1.148 ozaki key_sp_ref(struct secpolicy *sp, const char* where, int tag)
1358 1.148 ozaki {
1359 1.148 ozaki
1360 1.197 ozaki localcount_acquire(&sp->localcount);
1361 1.148 ozaki
1362 1.148 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1363 1.197 ozaki "DP SP:%p (ID=%u) from %s:%u; refcnt++ now %u\n",
1364 1.193 ozaki sp, sp->id, where, tag, key_sp_refcnt(sp));
1365 1.148 ozaki }
1366 1.148 ozaki
1367 1.211 ozaki /*
1368 1.211 ozaki * Must be called without holding key_spd.lock because the lock
1369 1.211 ozaki * would be held in localcount_release.
1370 1.211 ozaki */
1371 1.182 ozaki void
1372 1.197 ozaki key_sp_unref(struct secpolicy *sp, const char* where, int tag)
1373 1.182 ozaki {
1374 1.182 ozaki
1375 1.208 ozaki KDASSERT(mutex_ownable(&key_spd.lock));
1376 1.182 ozaki
1377 1.182 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1378 1.197 ozaki "DP SP:%p (ID=%u) from %s:%u; refcnt-- now %u\n",
1379 1.197 ozaki sp, sp->id, where, tag, key_sp_refcnt(sp));
1380 1.197 ozaki
1381 1.226 ozaki localcount_release(&sp->localcount, &key_spd.cv_lc, &key_spd.lock);
1382 1.182 ozaki }
1383 1.182 ozaki
1384 1.223 ozaki static void
1385 1.223 ozaki key_init_sav(struct secasvar *sav)
1386 1.223 ozaki {
1387 1.223 ozaki
1388 1.223 ozaki ASSERT_SLEEPABLE();
1389 1.223 ozaki
1390 1.223 ozaki localcount_init(&sav->localcount);
1391 1.223 ozaki SAVLIST_ENTRY_INIT(sav);
1392 1.223 ozaki }
1393 1.223 ozaki
1394 1.217 ozaki u_int
1395 1.217 ozaki key_sa_refcnt(const struct secasvar *sav)
1396 1.217 ozaki {
1397 1.217 ozaki
1398 1.223 ozaki /* FIXME */
1399 1.223 ozaki return 0;
1400 1.223 ozaki }
1401 1.223 ozaki
1402 1.223 ozaki void
1403 1.223 ozaki key_sa_ref(struct secasvar *sav, const char* where, int tag)
1404 1.223 ozaki {
1405 1.223 ozaki
1406 1.223 ozaki localcount_acquire(&sav->localcount);
1407 1.217 ozaki
1408 1.223 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1409 1.223 ozaki "DP cause refcnt++: SA:%p from %s:%u\n",
1410 1.223 ozaki sav, where, tag);
1411 1.217 ozaki }
1412 1.217 ozaki
1413 1.1 jonathan void
1414 1.223 ozaki key_sa_unref(struct secasvar *sav, const char* where, int tag)
1415 1.1 jonathan {
1416 1.1 jonathan
1417 1.223 ozaki KDASSERT(mutex_ownable(&key_sad.lock));
1418 1.1 jonathan
1419 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1420 1.223 ozaki "DP cause refcnt--: SA:%p from %s:%u\n",
1421 1.223 ozaki sav, where, tag);
1422 1.223 ozaki
1423 1.226 ozaki localcount_release(&sav->localcount, &key_sad.cv_lc, &key_sad.lock);
1424 1.1 jonathan }
1425 1.1 jonathan
1426 1.143 ozaki #if 0
1427 1.1 jonathan /*
1428 1.168 ozaki * Must be called after calling key_lookup_sp*().
1429 1.1 jonathan * For the packet with socket.
1430 1.1 jonathan */
1431 1.143 ozaki static void
1432 1.1 jonathan key_freeso(struct socket *so)
1433 1.1 jonathan {
1434 1.1 jonathan /* sanity check */
1435 1.108 ozaki KASSERT(so != NULL);
1436 1.1 jonathan
1437 1.1 jonathan switch (so->so_proto->pr_domain->dom_family) {
1438 1.1 jonathan #ifdef INET
1439 1.1 jonathan case PF_INET:
1440 1.1 jonathan {
1441 1.1 jonathan struct inpcb *pcb = sotoinpcb(so);
1442 1.1 jonathan
1443 1.1 jonathan /* Does it have a PCB ? */
1444 1.1 jonathan if (pcb == NULL)
1445 1.1 jonathan return;
1446 1.90 christos
1447 1.90 christos struct inpcbpolicy *sp = pcb->inp_sp;
1448 1.87 rmind key_freesp_so(&sp->sp_in);
1449 1.87 rmind key_freesp_so(&sp->sp_out);
1450 1.1 jonathan }
1451 1.1 jonathan break;
1452 1.1 jonathan #endif
1453 1.1 jonathan #ifdef INET6
1454 1.1 jonathan case PF_INET6:
1455 1.1 jonathan {
1456 1.1 jonathan #ifdef HAVE_NRL_INPCB
1457 1.1 jonathan struct inpcb *pcb = sotoinpcb(so);
1458 1.87 rmind struct inpcbpolicy *sp = pcb->inp_sp;
1459 1.1 jonathan
1460 1.1 jonathan /* Does it have a PCB ? */
1461 1.1 jonathan if (pcb == NULL)
1462 1.1 jonathan return;
1463 1.87 rmind key_freesp_so(&sp->sp_in);
1464 1.87 rmind key_freesp_so(&sp->sp_out);
1465 1.1 jonathan #else
1466 1.1 jonathan struct in6pcb *pcb = sotoin6pcb(so);
1467 1.1 jonathan
1468 1.1 jonathan /* Does it have a PCB ? */
1469 1.1 jonathan if (pcb == NULL)
1470 1.1 jonathan return;
1471 1.1 jonathan key_freesp_so(&pcb->in6p_sp->sp_in);
1472 1.1 jonathan key_freesp_so(&pcb->in6p_sp->sp_out);
1473 1.1 jonathan #endif
1474 1.1 jonathan }
1475 1.1 jonathan break;
1476 1.1 jonathan #endif /* INET6 */
1477 1.1 jonathan default:
1478 1.134 ozaki IPSECLOG(LOG_DEBUG, "unknown address family=%d.\n",
1479 1.134 ozaki so->so_proto->pr_domain->dom_family);
1480 1.1 jonathan return;
1481 1.1 jonathan }
1482 1.1 jonathan }
1483 1.1 jonathan
1484 1.1 jonathan static void
1485 1.1 jonathan key_freesp_so(struct secpolicy **sp)
1486 1.1 jonathan {
1487 1.108 ozaki
1488 1.108 ozaki KASSERT(sp != NULL);
1489 1.108 ozaki KASSERT(*sp != NULL);
1490 1.1 jonathan
1491 1.1 jonathan if ((*sp)->policy == IPSEC_POLICY_ENTRUST ||
1492 1.1 jonathan (*sp)->policy == IPSEC_POLICY_BYPASS)
1493 1.1 jonathan return;
1494 1.1 jonathan
1495 1.108 ozaki KASSERTMSG((*sp)->policy == IPSEC_POLICY_IPSEC,
1496 1.108 ozaki "invalid policy %u", (*sp)->policy);
1497 1.197 ozaki KEY_SP_UNREF(&sp);
1498 1.1 jonathan }
1499 1.143 ozaki #endif
1500 1.1 jonathan
1501 1.227 ozaki #ifdef NET_MPSAFE
1502 1.226 ozaki static void
1503 1.226 ozaki key_sad_pserialize_perform(void)
1504 1.226 ozaki {
1505 1.226 ozaki
1506 1.226 ozaki KASSERT(mutex_owned(&key_sad.lock));
1507 1.226 ozaki
1508 1.226 ozaki while (key_sad.psz_performing)
1509 1.226 ozaki cv_wait(&key_sad.cv_psz, &key_sad.lock);
1510 1.226 ozaki key_sad.psz_performing = true;
1511 1.226 ozaki mutex_exit(&key_sad.lock);
1512 1.226 ozaki
1513 1.226 ozaki pserialize_perform(key_sad.psz);
1514 1.226 ozaki
1515 1.226 ozaki mutex_enter(&key_sad.lock);
1516 1.226 ozaki key_sad.psz_performing = false;
1517 1.226 ozaki cv_broadcast(&key_sad.cv_psz);
1518 1.226 ozaki }
1519 1.227 ozaki #endif
1520 1.226 ozaki
1521 1.1 jonathan /*
1522 1.223 ozaki * Remove the sav from the savlist of its sah and wait for references to the sav
1523 1.223 ozaki * to be released. key_sad.lock must be held.
1524 1.223 ozaki */
1525 1.223 ozaki static void
1526 1.223 ozaki key_unlink_sav(struct secasvar *sav)
1527 1.223 ozaki {
1528 1.223 ozaki
1529 1.223 ozaki KASSERT(mutex_owned(&key_sad.lock));
1530 1.223 ozaki
1531 1.223 ozaki SAVLIST_WRITER_REMOVE(sav);
1532 1.223 ozaki
1533 1.223 ozaki #ifdef NET_MPSAFE
1534 1.223 ozaki KASSERT(mutex_ownable(softnet_lock));
1535 1.226 ozaki key_sad_pserialize_perform();
1536 1.223 ozaki #endif
1537 1.223 ozaki
1538 1.226 ozaki localcount_drain(&sav->localcount, &key_sad.cv_lc, &key_sad.lock);
1539 1.223 ozaki }
1540 1.223 ozaki
1541 1.223 ozaki /*
1542 1.223 ozaki * Destroy an sav where the sav must be unlinked from an sah
1543 1.223 ozaki * by say key_unlink_sav.
1544 1.1 jonathan */
1545 1.223 ozaki static void
1546 1.223 ozaki key_destroy_sav(struct secasvar *sav)
1547 1.1 jonathan {
1548 1.1 jonathan
1549 1.223 ozaki ASSERT_SLEEPABLE();
1550 1.223 ozaki
1551 1.223 ozaki localcount_fini(&sav->localcount);
1552 1.223 ozaki SAVLIST_ENTRY_DESTROY(sav);
1553 1.223 ozaki
1554 1.223 ozaki key_delsav(sav);
1555 1.223 ozaki }
1556 1.1 jonathan
1557 1.223 ozaki /*
1558 1.223 ozaki * Destroy sav with holding its reference.
1559 1.223 ozaki */
1560 1.223 ozaki static void
1561 1.223 ozaki key_destroy_sav_with_ref(struct secasvar *sav)
1562 1.223 ozaki {
1563 1.1 jonathan
1564 1.223 ozaki ASSERT_SLEEPABLE();
1565 1.223 ozaki
1566 1.223 ozaki mutex_enter(&key_sad.lock);
1567 1.223 ozaki sav->state = SADB_SASTATE_DEAD;
1568 1.223 ozaki SAVLIST_WRITER_REMOVE(sav);
1569 1.223 ozaki mutex_exit(&key_sad.lock);
1570 1.1 jonathan
1571 1.223 ozaki /* We cannot unref with holding key_sad.lock */
1572 1.223 ozaki KEY_SA_UNREF(&sav);
1573 1.171 ozaki
1574 1.223 ozaki mutex_enter(&key_sad.lock);
1575 1.223 ozaki #ifdef NET_MPSAFE
1576 1.223 ozaki KASSERT(mutex_ownable(softnet_lock));
1577 1.226 ozaki key_sad_pserialize_perform();
1578 1.223 ozaki #endif
1579 1.226 ozaki localcount_drain(&sav->localcount, &key_sad.cv_lc, &key_sad.lock);
1580 1.223 ozaki mutex_exit(&key_sad.lock);
1581 1.171 ozaki
1582 1.223 ozaki key_destroy_sav(sav);
1583 1.1 jonathan }
1584 1.1 jonathan
1585 1.1 jonathan /* %%% SPD management */
1586 1.1 jonathan /*
1587 1.1 jonathan * free security policy entry.
1588 1.1 jonathan */
1589 1.1 jonathan static void
1590 1.197 ozaki key_destroy_sp(struct secpolicy *sp)
1591 1.1 jonathan {
1592 1.1 jonathan
1593 1.197 ozaki SPLIST_ENTRY_DESTROY(sp);
1594 1.197 ozaki localcount_fini(&sp->localcount);
1595 1.1 jonathan
1596 1.197 ozaki key_free_sp(sp);
1597 1.198 ozaki
1598 1.198 ozaki key_update_used();
1599 1.197 ozaki }
1600 1.1 jonathan
1601 1.197 ozaki void
1602 1.197 ozaki key_free_sp(struct secpolicy *sp)
1603 1.197 ozaki {
1604 1.1 jonathan struct ipsecrequest *isr = sp->req, *nextisr;
1605 1.1 jonathan
1606 1.1 jonathan while (isr != NULL) {
1607 1.1 jonathan nextisr = isr->next;
1608 1.200 ozaki kmem_free(isr, sizeof(*isr));
1609 1.1 jonathan isr = nextisr;
1610 1.1 jonathan }
1611 1.1 jonathan
1612 1.200 ozaki kmem_free(sp, sizeof(*sp));
1613 1.197 ozaki }
1614 1.1 jonathan
1615 1.197 ozaki void
1616 1.197 ozaki key_socksplist_add(struct secpolicy *sp)
1617 1.197 ozaki {
1618 1.197 ozaki
1619 1.208 ozaki mutex_enter(&key_spd.lock);
1620 1.208 ozaki PSLIST_WRITER_INSERT_HEAD(&key_spd.socksplist, sp, pslist_entry);
1621 1.208 ozaki mutex_exit(&key_spd.lock);
1622 1.199 ozaki
1623 1.199 ozaki key_update_used();
1624 1.1 jonathan }
1625 1.1 jonathan
1626 1.1 jonathan /*
1627 1.1 jonathan * search SPD
1628 1.1 jonathan * OUT: NULL : not found
1629 1.1 jonathan * others : found, pointer to a SP.
1630 1.1 jonathan */
1631 1.1 jonathan static struct secpolicy *
1632 1.66 drochner key_getsp(const struct secpolicyindex *spidx)
1633 1.1 jonathan {
1634 1.1 jonathan struct secpolicy *sp;
1635 1.197 ozaki int s;
1636 1.1 jonathan
1637 1.108 ozaki KASSERT(spidx != NULL);
1638 1.1 jonathan
1639 1.197 ozaki s = pserialize_read_enter();
1640 1.194 ozaki SPLIST_READER_FOREACH(sp, spidx->dir) {
1641 1.1 jonathan if (sp->state == IPSEC_SPSTATE_DEAD)
1642 1.1 jonathan continue;
1643 1.145 ozaki if (key_spidx_match_exactly(spidx, &sp->spidx)) {
1644 1.197 ozaki KEY_SP_REF(sp);
1645 1.197 ozaki pserialize_read_exit(s);
1646 1.1 jonathan return sp;
1647 1.1 jonathan }
1648 1.1 jonathan }
1649 1.197 ozaki pserialize_read_exit(s);
1650 1.1 jonathan
1651 1.1 jonathan return NULL;
1652 1.1 jonathan }
1653 1.1 jonathan
1654 1.1 jonathan /*
1655 1.197 ozaki * search SPD and remove found SP
1656 1.197 ozaki * OUT: NULL : not found
1657 1.197 ozaki * others : found, pointer to a SP.
1658 1.197 ozaki */
1659 1.197 ozaki static struct secpolicy *
1660 1.197 ozaki key_lookup_and_remove_sp(const struct secpolicyindex *spidx)
1661 1.197 ozaki {
1662 1.197 ozaki struct secpolicy *sp = NULL;
1663 1.197 ozaki
1664 1.208 ozaki mutex_enter(&key_spd.lock);
1665 1.197 ozaki SPLIST_WRITER_FOREACH(sp, spidx->dir) {
1666 1.197 ozaki KASSERT(sp->state != IPSEC_SPSTATE_DEAD);
1667 1.197 ozaki
1668 1.197 ozaki if (key_spidx_match_exactly(spidx, &sp->spidx)) {
1669 1.197 ozaki key_unlink_sp(sp);
1670 1.197 ozaki goto out;
1671 1.197 ozaki }
1672 1.197 ozaki }
1673 1.197 ozaki sp = NULL;
1674 1.197 ozaki out:
1675 1.208 ozaki mutex_exit(&key_spd.lock);
1676 1.197 ozaki
1677 1.197 ozaki return sp;
1678 1.197 ozaki }
1679 1.197 ozaki
1680 1.197 ozaki /*
1681 1.1 jonathan * get SP by index.
1682 1.1 jonathan * OUT: NULL : not found
1683 1.1 jonathan * others : found, pointer to a SP.
1684 1.1 jonathan */
1685 1.1 jonathan static struct secpolicy *
1686 1.1 jonathan key_getspbyid(u_int32_t id)
1687 1.1 jonathan {
1688 1.1 jonathan struct secpolicy *sp;
1689 1.197 ozaki int s;
1690 1.1 jonathan
1691 1.197 ozaki s = pserialize_read_enter();
1692 1.194 ozaki SPLIST_READER_FOREACH(sp, IPSEC_DIR_INBOUND) {
1693 1.1 jonathan if (sp->state == IPSEC_SPSTATE_DEAD)
1694 1.1 jonathan continue;
1695 1.1 jonathan if (sp->id == id) {
1696 1.197 ozaki KEY_SP_REF(sp);
1697 1.197 ozaki goto out;
1698 1.1 jonathan }
1699 1.1 jonathan }
1700 1.1 jonathan
1701 1.194 ozaki SPLIST_READER_FOREACH(sp, IPSEC_DIR_OUTBOUND) {
1702 1.1 jonathan if (sp->state == IPSEC_SPSTATE_DEAD)
1703 1.1 jonathan continue;
1704 1.1 jonathan if (sp->id == id) {
1705 1.197 ozaki KEY_SP_REF(sp);
1706 1.197 ozaki goto out;
1707 1.1 jonathan }
1708 1.1 jonathan }
1709 1.197 ozaki out:
1710 1.197 ozaki pserialize_read_exit(s);
1711 1.197 ozaki return sp;
1712 1.197 ozaki }
1713 1.197 ozaki
1714 1.197 ozaki /*
1715 1.197 ozaki * get SP by index, remove and return it.
1716 1.197 ozaki * OUT: NULL : not found
1717 1.197 ozaki * others : found, pointer to a SP.
1718 1.197 ozaki */
1719 1.197 ozaki static struct secpolicy *
1720 1.197 ozaki key_lookupbyid_and_remove_sp(u_int32_t id)
1721 1.197 ozaki {
1722 1.197 ozaki struct secpolicy *sp;
1723 1.1 jonathan
1724 1.208 ozaki mutex_enter(&key_spd.lock);
1725 1.197 ozaki SPLIST_READER_FOREACH(sp, IPSEC_DIR_INBOUND) {
1726 1.197 ozaki KASSERT(sp->state != IPSEC_SPSTATE_DEAD);
1727 1.197 ozaki if (sp->id == id)
1728 1.197 ozaki goto out;
1729 1.197 ozaki }
1730 1.197 ozaki
1731 1.197 ozaki SPLIST_READER_FOREACH(sp, IPSEC_DIR_OUTBOUND) {
1732 1.197 ozaki KASSERT(sp->state != IPSEC_SPSTATE_DEAD);
1733 1.197 ozaki if (sp->id == id)
1734 1.197 ozaki goto out;
1735 1.197 ozaki }
1736 1.197 ozaki out:
1737 1.197 ozaki if (sp != NULL)
1738 1.197 ozaki key_unlink_sp(sp);
1739 1.208 ozaki mutex_exit(&key_spd.lock);
1740 1.197 ozaki return sp;
1741 1.1 jonathan }
1742 1.1 jonathan
1743 1.1 jonathan struct secpolicy *
1744 1.1 jonathan key_newsp(const char* where, int tag)
1745 1.1 jonathan {
1746 1.1 jonathan struct secpolicy *newsp = NULL;
1747 1.1 jonathan
1748 1.200 ozaki newsp = kmem_zalloc(sizeof(struct secpolicy), KM_SLEEP);
1749 1.1 jonathan
1750 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
1751 1.111 ozaki "DP from %s:%u return SP:%p\n", where, tag, newsp);
1752 1.1 jonathan return newsp;
1753 1.1 jonathan }
1754 1.1 jonathan
1755 1.1 jonathan /*
1756 1.1 jonathan * create secpolicy structure from sadb_x_policy structure.
1757 1.1 jonathan * NOTE: `state', `secpolicyindex' in secpolicy structure are not set,
1758 1.1 jonathan * so must be set properly later.
1759 1.1 jonathan */
1760 1.1 jonathan struct secpolicy *
1761 1.73 drochner key_msg2sp(const struct sadb_x_policy *xpl0, size_t len, int *error)
1762 1.1 jonathan {
1763 1.1 jonathan struct secpolicy *newsp;
1764 1.1 jonathan
1765 1.127 ozaki KASSERT(!cpu_softintr_p());
1766 1.112 ozaki KASSERT(xpl0 != NULL);
1767 1.112 ozaki KASSERT(len >= sizeof(*xpl0));
1768 1.112 ozaki
1769 1.1 jonathan if (len != PFKEY_EXTLEN(xpl0)) {
1770 1.134 ozaki IPSECLOG(LOG_DEBUG, "Invalid msg length.\n");
1771 1.1 jonathan *error = EINVAL;
1772 1.1 jonathan return NULL;
1773 1.1 jonathan }
1774 1.1 jonathan
1775 1.137 ozaki newsp = KEY_NEWSP();
1776 1.137 ozaki if (newsp == NULL) {
1777 1.1 jonathan *error = ENOBUFS;
1778 1.1 jonathan return NULL;
1779 1.1 jonathan }
1780 1.1 jonathan
1781 1.1 jonathan newsp->spidx.dir = xpl0->sadb_x_policy_dir;
1782 1.1 jonathan newsp->policy = xpl0->sadb_x_policy_type;
1783 1.1 jonathan
1784 1.1 jonathan /* check policy */
1785 1.1 jonathan switch (xpl0->sadb_x_policy_type) {
1786 1.1 jonathan case IPSEC_POLICY_DISCARD:
1787 1.1 jonathan case IPSEC_POLICY_NONE:
1788 1.1 jonathan case IPSEC_POLICY_ENTRUST:
1789 1.1 jonathan case IPSEC_POLICY_BYPASS:
1790 1.1 jonathan newsp->req = NULL;
1791 1.113 ozaki *error = 0;
1792 1.113 ozaki return newsp;
1793 1.113 ozaki
1794 1.113 ozaki case IPSEC_POLICY_IPSEC:
1795 1.113 ozaki /* Continued */
1796 1.1 jonathan break;
1797 1.113 ozaki default:
1798 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid policy type.\n");
1799 1.197 ozaki key_free_sp(newsp);
1800 1.113 ozaki *error = EINVAL;
1801 1.113 ozaki return NULL;
1802 1.113 ozaki }
1803 1.113 ozaki
1804 1.113 ozaki /* IPSEC_POLICY_IPSEC */
1805 1.113 ozaki {
1806 1.113 ozaki int tlen;
1807 1.113 ozaki const struct sadb_x_ipsecrequest *xisr;
1808 1.113 ozaki uint16_t xisr_reqid;
1809 1.113 ozaki struct ipsecrequest **p_isr = &newsp->req;
1810 1.1 jonathan
1811 1.113 ozaki /* validity check */
1812 1.113 ozaki if (PFKEY_EXTLEN(xpl0) < sizeof(*xpl0)) {
1813 1.134 ozaki IPSECLOG(LOG_DEBUG, "Invalid msg length.\n");
1814 1.113 ozaki *error = EINVAL;
1815 1.114 ozaki goto free_exit;
1816 1.113 ozaki }
1817 1.113 ozaki
1818 1.113 ozaki tlen = PFKEY_EXTLEN(xpl0) - sizeof(*xpl0);
1819 1.113 ozaki xisr = (const struct sadb_x_ipsecrequest *)(xpl0 + 1);
1820 1.1 jonathan
1821 1.113 ozaki while (tlen > 0) {
1822 1.113 ozaki /* length check */
1823 1.113 ozaki if (xisr->sadb_x_ipsecrequest_len < sizeof(*xisr)) {
1824 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid ipsecrequest length.\n");
1825 1.1 jonathan *error = EINVAL;
1826 1.114 ozaki goto free_exit;
1827 1.1 jonathan }
1828 1.1 jonathan
1829 1.113 ozaki /* allocate request buffer */
1830 1.130 ozaki *p_isr = kmem_zalloc(sizeof(**p_isr), KM_SLEEP);
1831 1.1 jonathan
1832 1.113 ozaki /* set values */
1833 1.113 ozaki (*p_isr)->next = NULL;
1834 1.1 jonathan
1835 1.113 ozaki switch (xisr->sadb_x_ipsecrequest_proto) {
1836 1.113 ozaki case IPPROTO_ESP:
1837 1.113 ozaki case IPPROTO_AH:
1838 1.113 ozaki case IPPROTO_IPCOMP:
1839 1.113 ozaki break;
1840 1.113 ozaki default:
1841 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid proto type=%u\n",
1842 1.134 ozaki xisr->sadb_x_ipsecrequest_proto);
1843 1.113 ozaki *error = EPROTONOSUPPORT;
1844 1.114 ozaki goto free_exit;
1845 1.113 ozaki }
1846 1.113 ozaki (*p_isr)->saidx.proto = xisr->sadb_x_ipsecrequest_proto;
1847 1.1 jonathan
1848 1.113 ozaki switch (xisr->sadb_x_ipsecrequest_mode) {
1849 1.113 ozaki case IPSEC_MODE_TRANSPORT:
1850 1.113 ozaki case IPSEC_MODE_TUNNEL:
1851 1.113 ozaki break;
1852 1.113 ozaki case IPSEC_MODE_ANY:
1853 1.113 ozaki default:
1854 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid mode=%u\n",
1855 1.134 ozaki xisr->sadb_x_ipsecrequest_mode);
1856 1.113 ozaki *error = EINVAL;
1857 1.114 ozaki goto free_exit;
1858 1.113 ozaki }
1859 1.113 ozaki (*p_isr)->saidx.mode = xisr->sadb_x_ipsecrequest_mode;
1860 1.1 jonathan
1861 1.113 ozaki switch (xisr->sadb_x_ipsecrequest_level) {
1862 1.113 ozaki case IPSEC_LEVEL_DEFAULT:
1863 1.113 ozaki case IPSEC_LEVEL_USE:
1864 1.113 ozaki case IPSEC_LEVEL_REQUIRE:
1865 1.113 ozaki break;
1866 1.113 ozaki case IPSEC_LEVEL_UNIQUE:
1867 1.113 ozaki xisr_reqid = xisr->sadb_x_ipsecrequest_reqid;
1868 1.113 ozaki /* validity check */
1869 1.113 ozaki /*
1870 1.113 ozaki * If range violation of reqid, kernel will
1871 1.113 ozaki * update it, don't refuse it.
1872 1.113 ozaki */
1873 1.113 ozaki if (xisr_reqid > IPSEC_MANUAL_REQID_MAX) {
1874 1.134 ozaki IPSECLOG(LOG_DEBUG,
1875 1.134 ozaki "reqid=%d range "
1876 1.113 ozaki "violation, updated by kernel.\n",
1877 1.134 ozaki xisr_reqid);
1878 1.113 ozaki xisr_reqid = 0;
1879 1.1 jonathan }
1880 1.1 jonathan
1881 1.113 ozaki /* allocate new reqid id if reqid is zero. */
1882 1.113 ozaki if (xisr_reqid == 0) {
1883 1.137 ozaki u_int16_t reqid = key_newreqid();
1884 1.137 ozaki if (reqid == 0) {
1885 1.113 ozaki *error = ENOBUFS;
1886 1.114 ozaki goto free_exit;
1887 1.113 ozaki }
1888 1.113 ozaki (*p_isr)->saidx.reqid = reqid;
1889 1.113 ozaki } else {
1890 1.113 ozaki /* set it for manual keying. */
1891 1.113 ozaki (*p_isr)->saidx.reqid = xisr_reqid;
1892 1.1 jonathan }
1893 1.113 ozaki break;
1894 1.113 ozaki
1895 1.113 ozaki default:
1896 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid level=%u\n",
1897 1.134 ozaki xisr->sadb_x_ipsecrequest_level);
1898 1.113 ozaki *error = EINVAL;
1899 1.114 ozaki goto free_exit;
1900 1.113 ozaki }
1901 1.113 ozaki (*p_isr)->level = xisr->sadb_x_ipsecrequest_level;
1902 1.1 jonathan
1903 1.113 ozaki /* set IP addresses if there */
1904 1.113 ozaki if (xisr->sadb_x_ipsecrequest_len > sizeof(*xisr)) {
1905 1.113 ozaki const struct sockaddr *paddr;
1906 1.1 jonathan
1907 1.113 ozaki paddr = (const struct sockaddr *)(xisr + 1);
1908 1.1 jonathan
1909 1.113 ozaki /* validity check */
1910 1.137 ozaki if (paddr->sa_len > sizeof((*p_isr)->saidx.src)) {
1911 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid request "
1912 1.134 ozaki "address length.\n");
1913 1.1 jonathan *error = EINVAL;
1914 1.114 ozaki goto free_exit;
1915 1.1 jonathan }
1916 1.113 ozaki memcpy(&(*p_isr)->saidx.src, paddr, paddr->sa_len);
1917 1.1 jonathan
1918 1.113 ozaki paddr = (const struct sockaddr *)((const char *)paddr
1919 1.137 ozaki + paddr->sa_len);
1920 1.1 jonathan
1921 1.1 jonathan /* validity check */
1922 1.137 ozaki if (paddr->sa_len > sizeof((*p_isr)->saidx.dst)) {
1923 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid request "
1924 1.134 ozaki "address length.\n");
1925 1.1 jonathan *error = EINVAL;
1926 1.114 ozaki goto free_exit;
1927 1.1 jonathan }
1928 1.113 ozaki memcpy(&(*p_isr)->saidx.dst, paddr, paddr->sa_len);
1929 1.113 ozaki }
1930 1.113 ozaki
1931 1.113 ozaki (*p_isr)->sp = newsp;
1932 1.113 ozaki
1933 1.113 ozaki /* initialization for the next. */
1934 1.113 ozaki p_isr = &(*p_isr)->next;
1935 1.113 ozaki tlen -= xisr->sadb_x_ipsecrequest_len;
1936 1.1 jonathan
1937 1.113 ozaki /* validity check */
1938 1.113 ozaki if (tlen < 0) {
1939 1.134 ozaki IPSECLOG(LOG_DEBUG, "becoming tlen < 0.\n");
1940 1.113 ozaki *error = EINVAL;
1941 1.114 ozaki goto free_exit;
1942 1.1 jonathan }
1943 1.113 ozaki
1944 1.137 ozaki xisr = (const struct sadb_x_ipsecrequest *)((const char *)xisr +
1945 1.137 ozaki xisr->sadb_x_ipsecrequest_len);
1946 1.1 jonathan }
1947 1.113 ozaki }
1948 1.1 jonathan
1949 1.1 jonathan *error = 0;
1950 1.1 jonathan return newsp;
1951 1.114 ozaki
1952 1.114 ozaki free_exit:
1953 1.197 ozaki key_free_sp(newsp);
1954 1.114 ozaki return NULL;
1955 1.1 jonathan }
1956 1.1 jonathan
1957 1.34 degroote static u_int16_t
1958 1.61 cegger key_newreqid(void)
1959 1.1 jonathan {
1960 1.34 degroote static u_int16_t auto_reqid = IPSEC_MANUAL_REQID_MAX + 1;
1961 1.1 jonathan
1962 1.137 ozaki auto_reqid = (auto_reqid == 0xffff ?
1963 1.137 ozaki IPSEC_MANUAL_REQID_MAX + 1 : auto_reqid + 1);
1964 1.1 jonathan
1965 1.1 jonathan /* XXX should be unique check */
1966 1.1 jonathan
1967 1.1 jonathan return auto_reqid;
1968 1.1 jonathan }
1969 1.1 jonathan
1970 1.1 jonathan /*
1971 1.1 jonathan * copy secpolicy struct to sadb_x_policy structure indicated.
1972 1.1 jonathan */
1973 1.1 jonathan struct mbuf *
1974 1.239 ozaki key_sp2msg(const struct secpolicy *sp, int mflag)
1975 1.1 jonathan {
1976 1.1 jonathan struct sadb_x_policy *xpl;
1977 1.1 jonathan int tlen;
1978 1.39 degroote char *p;
1979 1.1 jonathan struct mbuf *m;
1980 1.1 jonathan
1981 1.112 ozaki KASSERT(sp != NULL);
1982 1.1 jonathan
1983 1.1 jonathan tlen = key_getspreqmsglen(sp);
1984 1.1 jonathan
1985 1.239 ozaki m = key_alloc_mbuf(tlen, mflag);
1986 1.1 jonathan if (!m || m->m_next) { /*XXX*/
1987 1.1 jonathan if (m)
1988 1.1 jonathan m_freem(m);
1989 1.1 jonathan return NULL;
1990 1.1 jonathan }
1991 1.1 jonathan
1992 1.1 jonathan m->m_len = tlen;
1993 1.1 jonathan m->m_next = NULL;
1994 1.1 jonathan xpl = mtod(m, struct sadb_x_policy *);
1995 1.49 degroote memset(xpl, 0, tlen);
1996 1.1 jonathan
1997 1.1 jonathan xpl->sadb_x_policy_len = PFKEY_UNIT64(tlen);
1998 1.1 jonathan xpl->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
1999 1.1 jonathan xpl->sadb_x_policy_type = sp->policy;
2000 1.1 jonathan xpl->sadb_x_policy_dir = sp->spidx.dir;
2001 1.1 jonathan xpl->sadb_x_policy_id = sp->id;
2002 1.39 degroote p = (char *)xpl + sizeof(*xpl);
2003 1.1 jonathan
2004 1.1 jonathan /* if is the policy for ipsec ? */
2005 1.1 jonathan if (sp->policy == IPSEC_POLICY_IPSEC) {
2006 1.1 jonathan struct sadb_x_ipsecrequest *xisr;
2007 1.1 jonathan struct ipsecrequest *isr;
2008 1.1 jonathan
2009 1.1 jonathan for (isr = sp->req; isr != NULL; isr = isr->next) {
2010 1.1 jonathan
2011 1.1 jonathan xisr = (struct sadb_x_ipsecrequest *)p;
2012 1.1 jonathan
2013 1.1 jonathan xisr->sadb_x_ipsecrequest_proto = isr->saidx.proto;
2014 1.1 jonathan xisr->sadb_x_ipsecrequest_mode = isr->saidx.mode;
2015 1.1 jonathan xisr->sadb_x_ipsecrequest_level = isr->level;
2016 1.1 jonathan xisr->sadb_x_ipsecrequest_reqid = isr->saidx.reqid;
2017 1.1 jonathan
2018 1.1 jonathan p += sizeof(*xisr);
2019 1.49 degroote memcpy(p, &isr->saidx.src, isr->saidx.src.sa.sa_len);
2020 1.1 jonathan p += isr->saidx.src.sa.sa_len;
2021 1.49 degroote memcpy(p, &isr->saidx.dst, isr->saidx.dst.sa.sa_len);
2022 1.1 jonathan p += isr->saidx.src.sa.sa_len;
2023 1.1 jonathan
2024 1.1 jonathan xisr->sadb_x_ipsecrequest_len =
2025 1.137 ozaki PFKEY_ALIGN8(sizeof(*xisr)
2026 1.137 ozaki + isr->saidx.src.sa.sa_len
2027 1.137 ozaki + isr->saidx.dst.sa.sa_len);
2028 1.1 jonathan }
2029 1.1 jonathan }
2030 1.1 jonathan
2031 1.1 jonathan return m;
2032 1.1 jonathan }
2033 1.1 jonathan
2034 1.240 ozaki /*
2035 1.240 ozaki * m will not be freed nor modified. It may return NULL.
2036 1.240 ozaki */
2037 1.1 jonathan static struct mbuf *
2038 1.1 jonathan key_gather_mbuf(struct mbuf *m, const struct sadb_msghdr *mhp,
2039 1.49 degroote int ndeep, int nitem, ...)
2040 1.1 jonathan {
2041 1.1 jonathan va_list ap;
2042 1.1 jonathan int idx;
2043 1.1 jonathan int i;
2044 1.1 jonathan struct mbuf *result = NULL, *n;
2045 1.1 jonathan int len;
2046 1.1 jonathan
2047 1.112 ozaki KASSERT(m != NULL);
2048 1.112 ozaki KASSERT(mhp != NULL);
2049 1.239 ozaki KASSERT(!cpu_softintr_p());
2050 1.1 jonathan
2051 1.1 jonathan va_start(ap, nitem);
2052 1.1 jonathan for (i = 0; i < nitem; i++) {
2053 1.1 jonathan idx = va_arg(ap, int);
2054 1.1 jonathan if (idx < 0 || idx > SADB_EXT_MAX)
2055 1.1 jonathan goto fail;
2056 1.1 jonathan /* don't attempt to pull empty extension */
2057 1.1 jonathan if (idx == SADB_EXT_RESERVED && mhp->msg == NULL)
2058 1.1 jonathan continue;
2059 1.137 ozaki if (idx != SADB_EXT_RESERVED &&
2060 1.1 jonathan (mhp->ext[idx] == NULL || mhp->extlen[idx] == 0))
2061 1.1 jonathan continue;
2062 1.1 jonathan
2063 1.1 jonathan if (idx == SADB_EXT_RESERVED) {
2064 1.110 ozaki CTASSERT(PFKEY_ALIGN8(sizeof(struct sadb_msg)) <= MHLEN);
2065 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
2066 1.239 ozaki MGETHDR(n, M_WAITOK, MT_DATA);
2067 1.1 jonathan n->m_len = len;
2068 1.1 jonathan n->m_next = NULL;
2069 1.1 jonathan m_copydata(m, 0, sizeof(struct sadb_msg),
2070 1.38 christos mtod(n, void *));
2071 1.1 jonathan } else if (i < ndeep) {
2072 1.1 jonathan len = mhp->extlen[idx];
2073 1.239 ozaki n = key_alloc_mbuf(len, M_WAITOK);
2074 1.240 ozaki KASSERT(n->m_next == NULL);
2075 1.1 jonathan m_copydata(m, mhp->extoff[idx], mhp->extlen[idx],
2076 1.38 christos mtod(n, void *));
2077 1.1 jonathan } else {
2078 1.1 jonathan n = m_copym(m, mhp->extoff[idx], mhp->extlen[idx],
2079 1.239 ozaki M_WAITOK);
2080 1.1 jonathan }
2081 1.240 ozaki KASSERT(n != NULL);
2082 1.1 jonathan
2083 1.1 jonathan if (result)
2084 1.1 jonathan m_cat(result, n);
2085 1.1 jonathan else
2086 1.1 jonathan result = n;
2087 1.1 jonathan }
2088 1.1 jonathan va_end(ap);
2089 1.1 jonathan
2090 1.89 christos if (result && (result->m_flags & M_PKTHDR) != 0) {
2091 1.1 jonathan result->m_pkthdr.len = 0;
2092 1.1 jonathan for (n = result; n; n = n->m_next)
2093 1.1 jonathan result->m_pkthdr.len += n->m_len;
2094 1.1 jonathan }
2095 1.1 jonathan
2096 1.1 jonathan return result;
2097 1.1 jonathan
2098 1.1 jonathan fail:
2099 1.8 thorpej va_end(ap);
2100 1.1 jonathan m_freem(result);
2101 1.1 jonathan return NULL;
2102 1.1 jonathan }
2103 1.1 jonathan
2104 1.1 jonathan /*
2105 1.1 jonathan * SADB_X_SPDADD, SADB_X_SPDSETIDX or SADB_X_SPDUPDATE processing
2106 1.1 jonathan * add an entry to SP database, when received
2107 1.1 jonathan * <base, address(SD), (lifetime(H),) policy>
2108 1.1 jonathan * from the user(?).
2109 1.1 jonathan * Adding to SP database,
2110 1.1 jonathan * and send
2111 1.1 jonathan * <base, address(SD), (lifetime(H),) policy>
2112 1.1 jonathan * to the socket which was send.
2113 1.1 jonathan *
2114 1.1 jonathan * SPDADD set a unique policy entry.
2115 1.1 jonathan * SPDSETIDX like SPDADD without a part of policy requests.
2116 1.1 jonathan * SPDUPDATE replace a unique policy entry.
2117 1.1 jonathan *
2118 1.1 jonathan * m will always be freed.
2119 1.1 jonathan */
2120 1.1 jonathan static int
2121 1.162 ozaki key_api_spdadd(struct socket *so, struct mbuf *m,
2122 1.49 degroote const struct sadb_msghdr *mhp)
2123 1.1 jonathan {
2124 1.151 ozaki const struct sockaddr *src, *dst;
2125 1.73 drochner const struct sadb_x_policy *xpl0;
2126 1.73 drochner struct sadb_x_policy *xpl;
2127 1.73 drochner const struct sadb_lifetime *lft = NULL;
2128 1.1 jonathan struct secpolicyindex spidx;
2129 1.1 jonathan struct secpolicy *newsp;
2130 1.1 jonathan int error;
2131 1.1 jonathan
2132 1.1 jonathan if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
2133 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
2134 1.1 jonathan mhp->ext[SADB_X_EXT_POLICY] == NULL) {
2135 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2136 1.1 jonathan return key_senderror(so, m, EINVAL);
2137 1.1 jonathan }
2138 1.1 jonathan if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
2139 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
2140 1.1 jonathan mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2141 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2142 1.1 jonathan return key_senderror(so, m, EINVAL);
2143 1.1 jonathan }
2144 1.1 jonathan if (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL) {
2145 1.137 ozaki if (mhp->extlen[SADB_EXT_LIFETIME_HARD] <
2146 1.137 ozaki sizeof(struct sadb_lifetime)) {
2147 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2148 1.1 jonathan return key_senderror(so, m, EINVAL);
2149 1.1 jonathan }
2150 1.230 christos lft = mhp->ext[SADB_EXT_LIFETIME_HARD];
2151 1.1 jonathan }
2152 1.1 jonathan
2153 1.230 christos xpl0 = mhp->ext[SADB_X_EXT_POLICY];
2154 1.1 jonathan
2155 1.1 jonathan /* checking the direciton. */
2156 1.1 jonathan switch (xpl0->sadb_x_policy_dir) {
2157 1.1 jonathan case IPSEC_DIR_INBOUND:
2158 1.1 jonathan case IPSEC_DIR_OUTBOUND:
2159 1.1 jonathan break;
2160 1.1 jonathan default:
2161 1.134 ozaki IPSECLOG(LOG_DEBUG, "Invalid SP direction.\n");
2162 1.149 ozaki return key_senderror(so, m, EINVAL);
2163 1.1 jonathan }
2164 1.1 jonathan
2165 1.1 jonathan /* check policy */
2166 1.162 ozaki /* key_api_spdadd() accepts DISCARD, NONE and IPSEC. */
2167 1.137 ozaki if (xpl0->sadb_x_policy_type == IPSEC_POLICY_ENTRUST ||
2168 1.137 ozaki xpl0->sadb_x_policy_type == IPSEC_POLICY_BYPASS) {
2169 1.134 ozaki IPSECLOG(LOG_DEBUG, "Invalid policy type.\n");
2170 1.1 jonathan return key_senderror(so, m, EINVAL);
2171 1.1 jonathan }
2172 1.1 jonathan
2173 1.1 jonathan /* policy requests are mandatory when action is ipsec. */
2174 1.118 ozaki if (mhp->msg->sadb_msg_type != SADB_X_SPDSETIDX &&
2175 1.118 ozaki xpl0->sadb_x_policy_type == IPSEC_POLICY_IPSEC &&
2176 1.118 ozaki mhp->extlen[SADB_X_EXT_POLICY] <= sizeof(*xpl0)) {
2177 1.134 ozaki IPSECLOG(LOG_DEBUG, "some policy requests part required.\n");
2178 1.1 jonathan return key_senderror(so, m, EINVAL);
2179 1.1 jonathan }
2180 1.1 jonathan
2181 1.152 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
2182 1.152 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
2183 1.152 ozaki
2184 1.152 ozaki /* sanity check on addr pair */
2185 1.152 ozaki if (src->sa_family != dst->sa_family)
2186 1.152 ozaki return key_senderror(so, m, EINVAL);
2187 1.152 ozaki if (src->sa_len != dst->sa_len)
2188 1.152 ozaki return key_senderror(so, m, EINVAL);
2189 1.152 ozaki
2190 1.152 ozaki key_init_spidx_bymsghdr(&spidx, mhp);
2191 1.152 ozaki
2192 1.1 jonathan /*
2193 1.1 jonathan * checking there is SP already or not.
2194 1.1 jonathan * SPDUPDATE doesn't depend on whether there is a SP or not.
2195 1.1 jonathan * If the type is either SPDADD or SPDSETIDX AND a SP is found,
2196 1.1 jonathan * then error.
2197 1.1 jonathan */
2198 1.154 ozaki {
2199 1.154 ozaki struct secpolicy *sp;
2200 1.154 ozaki
2201 1.1 jonathan if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) {
2202 1.197 ozaki sp = key_lookup_and_remove_sp(&spidx);
2203 1.197 ozaki if (sp != NULL)
2204 1.197 ozaki key_destroy_sp(sp);
2205 1.1 jonathan } else {
2206 1.197 ozaki sp = key_getsp(&spidx);
2207 1.154 ozaki if (sp != NULL) {
2208 1.197 ozaki KEY_SP_UNREF(&sp);
2209 1.134 ozaki IPSECLOG(LOG_DEBUG, "a SP entry exists already.\n");
2210 1.1 jonathan return key_senderror(so, m, EEXIST);
2211 1.1 jonathan }
2212 1.1 jonathan }
2213 1.154 ozaki }
2214 1.6 scw
2215 1.1 jonathan /* allocation new SP entry */
2216 1.137 ozaki newsp = key_msg2sp(xpl0, PFKEY_EXTLEN(xpl0), &error);
2217 1.137 ozaki if (newsp == NULL) {
2218 1.1 jonathan return key_senderror(so, m, error);
2219 1.1 jonathan }
2220 1.1 jonathan
2221 1.137 ozaki newsp->id = key_getnewspid();
2222 1.137 ozaki if (newsp->id == 0) {
2223 1.127 ozaki kmem_free(newsp, sizeof(*newsp));
2224 1.1 jonathan return key_senderror(so, m, ENOBUFS);
2225 1.1 jonathan }
2226 1.1 jonathan
2227 1.153 ozaki newsp->spidx = spidx;
2228 1.69 drochner newsp->created = time_uptime;
2229 1.1 jonathan newsp->lastused = newsp->created;
2230 1.1 jonathan newsp->lifetime = lft ? lft->sadb_lifetime_addtime : 0;
2231 1.1 jonathan newsp->validtime = lft ? lft->sadb_lifetime_usetime : 0;
2232 1.1 jonathan
2233 1.197 ozaki key_init_sp(newsp);
2234 1.197 ozaki
2235 1.208 ozaki mutex_enter(&key_spd.lock);
2236 1.194 ozaki SPLIST_WRITER_INSERT_TAIL(newsp->spidx.dir, newsp);
2237 1.208 ozaki mutex_exit(&key_spd.lock);
2238 1.1 jonathan
2239 1.139 ozaki #ifdef notyet
2240 1.208 ozaki /* delete the entry in key_misc.spacqlist */
2241 1.1 jonathan if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) {
2242 1.137 ozaki struct secspacq *spacq = key_getspacq(&spidx);
2243 1.137 ozaki if (spacq != NULL) {
2244 1.1 jonathan /* reset counter in order to deletion by timehandler. */
2245 1.69 drochner spacq->created = time_uptime;
2246 1.1 jonathan spacq->count = 0;
2247 1.1 jonathan }
2248 1.1 jonathan }
2249 1.139 ozaki #endif
2250 1.1 jonathan
2251 1.9 thorpej /* Invalidate all cached SPD pointers in the PCBs. */
2252 1.9 thorpej ipsec_invalpcbcacheall();
2253 1.9 thorpej
2254 1.9 thorpej #if defined(GATEWAY)
2255 1.9 thorpej /* Invalidate the ipflow cache, as well. */
2256 1.51 elad ipflow_invalidate_all(0);
2257 1.42 liamjfoy #ifdef INET6
2258 1.104 ozaki if (in6_present)
2259 1.104 ozaki ip6flow_invalidate_all(0);
2260 1.42 liamjfoy #endif /* INET6 */
2261 1.42 liamjfoy #endif /* GATEWAY */
2262 1.9 thorpej
2263 1.198 ozaki key_update_used();
2264 1.198 ozaki
2265 1.1 jonathan {
2266 1.1 jonathan struct mbuf *n, *mpolicy;
2267 1.1 jonathan int off;
2268 1.1 jonathan
2269 1.1 jonathan /* create new sadb_msg to reply. */
2270 1.1 jonathan if (lft) {
2271 1.1 jonathan n = key_gather_mbuf(m, mhp, 2, 5, SADB_EXT_RESERVED,
2272 1.1 jonathan SADB_X_EXT_POLICY, SADB_EXT_LIFETIME_HARD,
2273 1.1 jonathan SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
2274 1.1 jonathan } else {
2275 1.1 jonathan n = key_gather_mbuf(m, mhp, 2, 4, SADB_EXT_RESERVED,
2276 1.1 jonathan SADB_X_EXT_POLICY,
2277 1.1 jonathan SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
2278 1.1 jonathan }
2279 1.1 jonathan if (!n)
2280 1.1 jonathan return key_senderror(so, m, ENOBUFS);
2281 1.1 jonathan
2282 1.158 ozaki n = key_fill_replymsg(n, 0);
2283 1.158 ozaki if (n == NULL)
2284 1.158 ozaki return key_senderror(so, m, ENOBUFS);
2285 1.1 jonathan
2286 1.1 jonathan off = 0;
2287 1.1 jonathan mpolicy = m_pulldown(n, PFKEY_ALIGN8(sizeof(struct sadb_msg)),
2288 1.1 jonathan sizeof(*xpl), &off);
2289 1.1 jonathan if (mpolicy == NULL) {
2290 1.1 jonathan /* n is already freed */
2291 1.1 jonathan return key_senderror(so, m, ENOBUFS);
2292 1.1 jonathan }
2293 1.39 degroote xpl = (struct sadb_x_policy *)(mtod(mpolicy, char *) + off);
2294 1.1 jonathan if (xpl->sadb_x_policy_exttype != SADB_X_EXT_POLICY) {
2295 1.1 jonathan m_freem(n);
2296 1.1 jonathan return key_senderror(so, m, EINVAL);
2297 1.1 jonathan }
2298 1.1 jonathan xpl->sadb_x_policy_id = newsp->id;
2299 1.1 jonathan
2300 1.1 jonathan m_freem(m);
2301 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2302 1.1 jonathan }
2303 1.1 jonathan }
2304 1.1 jonathan
2305 1.1 jonathan /*
2306 1.1 jonathan * get new policy id.
2307 1.1 jonathan * OUT:
2308 1.1 jonathan * 0: failure.
2309 1.1 jonathan * others: success.
2310 1.1 jonathan */
2311 1.1 jonathan static u_int32_t
2312 1.61 cegger key_getnewspid(void)
2313 1.1 jonathan {
2314 1.1 jonathan u_int32_t newid = 0;
2315 1.1 jonathan int count = key_spi_trycnt; /* XXX */
2316 1.1 jonathan struct secpolicy *sp;
2317 1.1 jonathan
2318 1.1 jonathan /* when requesting to allocate spi ranged */
2319 1.1 jonathan while (count--) {
2320 1.1 jonathan newid = (policy_id = (policy_id == ~0 ? 1 : policy_id + 1));
2321 1.1 jonathan
2322 1.137 ozaki sp = key_getspbyid(newid);
2323 1.137 ozaki if (sp == NULL)
2324 1.1 jonathan break;
2325 1.1 jonathan
2326 1.197 ozaki KEY_SP_UNREF(&sp);
2327 1.1 jonathan }
2328 1.1 jonathan
2329 1.1 jonathan if (count == 0 || newid == 0) {
2330 1.134 ozaki IPSECLOG(LOG_DEBUG, "to allocate policy id is failed.\n");
2331 1.1 jonathan return 0;
2332 1.1 jonathan }
2333 1.1 jonathan
2334 1.1 jonathan return newid;
2335 1.1 jonathan }
2336 1.1 jonathan
2337 1.1 jonathan /*
2338 1.1 jonathan * SADB_SPDDELETE processing
2339 1.1 jonathan * receive
2340 1.1 jonathan * <base, address(SD), policy(*)>
2341 1.1 jonathan * from the user(?), and set SADB_SASTATE_DEAD,
2342 1.1 jonathan * and send,
2343 1.1 jonathan * <base, address(SD), policy(*)>
2344 1.1 jonathan * to the ikmpd.
2345 1.1 jonathan * policy(*) including direction of policy.
2346 1.1 jonathan *
2347 1.1 jonathan * m will always be freed.
2348 1.1 jonathan */
2349 1.1 jonathan static int
2350 1.162 ozaki key_api_spddelete(struct socket *so, struct mbuf *m,
2351 1.49 degroote const struct sadb_msghdr *mhp)
2352 1.1 jonathan {
2353 1.1 jonathan struct sadb_x_policy *xpl0;
2354 1.1 jonathan struct secpolicyindex spidx;
2355 1.1 jonathan struct secpolicy *sp;
2356 1.1 jonathan
2357 1.1 jonathan if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
2358 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
2359 1.1 jonathan mhp->ext[SADB_X_EXT_POLICY] == NULL) {
2360 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2361 1.1 jonathan return key_senderror(so, m, EINVAL);
2362 1.1 jonathan }
2363 1.1 jonathan if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
2364 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
2365 1.1 jonathan mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2366 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2367 1.1 jonathan return key_senderror(so, m, EINVAL);
2368 1.1 jonathan }
2369 1.1 jonathan
2370 1.230 christos xpl0 = mhp->ext[SADB_X_EXT_POLICY];
2371 1.1 jonathan
2372 1.230 christos /* checking the directon. */
2373 1.1 jonathan switch (xpl0->sadb_x_policy_dir) {
2374 1.1 jonathan case IPSEC_DIR_INBOUND:
2375 1.1 jonathan case IPSEC_DIR_OUTBOUND:
2376 1.1 jonathan break;
2377 1.1 jonathan default:
2378 1.134 ozaki IPSECLOG(LOG_DEBUG, "Invalid SP direction.\n");
2379 1.1 jonathan return key_senderror(so, m, EINVAL);
2380 1.1 jonathan }
2381 1.1 jonathan
2382 1.156 ozaki /* make secindex */
2383 1.156 ozaki key_init_spidx_bymsghdr(&spidx, mhp);
2384 1.156 ozaki
2385 1.1 jonathan /* Is there SP in SPD ? */
2386 1.197 ozaki sp = key_lookup_and_remove_sp(&spidx);
2387 1.137 ozaki if (sp == NULL) {
2388 1.134 ozaki IPSECLOG(LOG_DEBUG, "no SP found.\n");
2389 1.1 jonathan return key_senderror(so, m, EINVAL);
2390 1.1 jonathan }
2391 1.1 jonathan
2392 1.1 jonathan /* save policy id to buffer to be returned. */
2393 1.1 jonathan xpl0->sadb_x_policy_id = sp->id;
2394 1.1 jonathan
2395 1.197 ozaki key_destroy_sp(sp);
2396 1.9 thorpej
2397 1.9 thorpej /* We're deleting policy; no need to invalidate the ipflow cache. */
2398 1.9 thorpej
2399 1.1 jonathan {
2400 1.1 jonathan struct mbuf *n;
2401 1.1 jonathan
2402 1.1 jonathan /* create new sadb_msg to reply. */
2403 1.1 jonathan n = key_gather_mbuf(m, mhp, 1, 4, SADB_EXT_RESERVED,
2404 1.1 jonathan SADB_X_EXT_POLICY, SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
2405 1.1 jonathan if (!n)
2406 1.1 jonathan return key_senderror(so, m, ENOBUFS);
2407 1.1 jonathan
2408 1.158 ozaki n = key_fill_replymsg(n, 0);
2409 1.158 ozaki if (n == NULL)
2410 1.158 ozaki return key_senderror(so, m, ENOBUFS);
2411 1.1 jonathan
2412 1.1 jonathan m_freem(m);
2413 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2414 1.1 jonathan }
2415 1.1 jonathan }
2416 1.1 jonathan
2417 1.236 ozaki static struct mbuf *
2418 1.236 ozaki key_alloc_mbuf_simple(int len, int mflag)
2419 1.236 ozaki {
2420 1.236 ozaki struct mbuf *n;
2421 1.236 ozaki
2422 1.239 ozaki KASSERT(mflag == M_NOWAIT || (mflag == M_WAITOK && !cpu_softintr_p()));
2423 1.239 ozaki
2424 1.236 ozaki MGETHDR(n, mflag, MT_DATA);
2425 1.236 ozaki if (n && len > MHLEN) {
2426 1.236 ozaki MCLGET(n, mflag);
2427 1.236 ozaki if ((n->m_flags & M_EXT) == 0) {
2428 1.236 ozaki m_freem(n);
2429 1.236 ozaki n = NULL;
2430 1.236 ozaki }
2431 1.236 ozaki }
2432 1.236 ozaki return n;
2433 1.236 ozaki }
2434 1.236 ozaki
2435 1.1 jonathan /*
2436 1.1 jonathan * SADB_SPDDELETE2 processing
2437 1.1 jonathan * receive
2438 1.1 jonathan * <base, policy(*)>
2439 1.1 jonathan * from the user(?), and set SADB_SASTATE_DEAD,
2440 1.1 jonathan * and send,
2441 1.1 jonathan * <base, policy(*)>
2442 1.1 jonathan * to the ikmpd.
2443 1.1 jonathan * policy(*) including direction of policy.
2444 1.1 jonathan *
2445 1.1 jonathan * m will always be freed.
2446 1.1 jonathan */
2447 1.1 jonathan static int
2448 1.162 ozaki key_api_spddelete2(struct socket *so, struct mbuf *m,
2449 1.49 degroote const struct sadb_msghdr *mhp)
2450 1.1 jonathan {
2451 1.1 jonathan u_int32_t id;
2452 1.1 jonathan struct secpolicy *sp;
2453 1.230 christos const struct sadb_x_policy *xpl;
2454 1.1 jonathan
2455 1.1 jonathan if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2456 1.1 jonathan mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2457 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2458 1.160 ozaki return key_senderror(so, m, EINVAL);
2459 1.1 jonathan }
2460 1.1 jonathan
2461 1.230 christos xpl = mhp->ext[SADB_X_EXT_POLICY];
2462 1.230 christos id = xpl->sadb_x_policy_id;
2463 1.1 jonathan
2464 1.1 jonathan /* Is there SP in SPD ? */
2465 1.197 ozaki sp = key_lookupbyid_and_remove_sp(id);
2466 1.137 ozaki if (sp == NULL) {
2467 1.134 ozaki IPSECLOG(LOG_DEBUG, "no SP found id:%u.\n", id);
2468 1.45 degroote return key_senderror(so, m, EINVAL);
2469 1.1 jonathan }
2470 1.1 jonathan
2471 1.197 ozaki key_destroy_sp(sp);
2472 1.9 thorpej
2473 1.9 thorpej /* We're deleting policy; no need to invalidate the ipflow cache. */
2474 1.9 thorpej
2475 1.1 jonathan {
2476 1.1 jonathan struct mbuf *n, *nn;
2477 1.1 jonathan int off, len;
2478 1.1 jonathan
2479 1.157 ozaki CTASSERT(PFKEY_ALIGN8(sizeof(struct sadb_msg)) <= MCLBYTES);
2480 1.157 ozaki
2481 1.1 jonathan /* create new sadb_msg to reply. */
2482 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
2483 1.1 jonathan
2484 1.239 ozaki n = key_alloc_mbuf_simple(len, M_WAITOK);
2485 1.1 jonathan n->m_len = len;
2486 1.1 jonathan n->m_next = NULL;
2487 1.1 jonathan off = 0;
2488 1.1 jonathan
2489 1.39 degroote m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, char *) + off);
2490 1.1 jonathan off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
2491 1.1 jonathan
2492 1.110 ozaki KASSERTMSG(off == len, "length inconsistency");
2493 1.1 jonathan
2494 1.1 jonathan n->m_next = m_copym(m, mhp->extoff[SADB_X_EXT_POLICY],
2495 1.239 ozaki mhp->extlen[SADB_X_EXT_POLICY], M_WAITOK);
2496 1.1 jonathan
2497 1.1 jonathan n->m_pkthdr.len = 0;
2498 1.1 jonathan for (nn = n; nn; nn = nn->m_next)
2499 1.1 jonathan n->m_pkthdr.len += nn->m_len;
2500 1.1 jonathan
2501 1.158 ozaki n = key_fill_replymsg(n, 0);
2502 1.158 ozaki if (n == NULL)
2503 1.158 ozaki return key_senderror(so, m, ENOBUFS);
2504 1.1 jonathan
2505 1.1 jonathan m_freem(m);
2506 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2507 1.1 jonathan }
2508 1.1 jonathan }
2509 1.1 jonathan
2510 1.1 jonathan /*
2511 1.1 jonathan * SADB_X_GET processing
2512 1.1 jonathan * receive
2513 1.1 jonathan * <base, policy(*)>
2514 1.1 jonathan * from the user(?),
2515 1.1 jonathan * and send,
2516 1.1 jonathan * <base, address(SD), policy>
2517 1.1 jonathan * to the ikmpd.
2518 1.1 jonathan * policy(*) including direction of policy.
2519 1.1 jonathan *
2520 1.1 jonathan * m will always be freed.
2521 1.1 jonathan */
2522 1.1 jonathan static int
2523 1.162 ozaki key_api_spdget(struct socket *so, struct mbuf *m,
2524 1.49 degroote const struct sadb_msghdr *mhp)
2525 1.1 jonathan {
2526 1.1 jonathan u_int32_t id;
2527 1.1 jonathan struct secpolicy *sp;
2528 1.1 jonathan struct mbuf *n;
2529 1.230 christos const struct sadb_x_policy *xpl;
2530 1.1 jonathan
2531 1.1 jonathan if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2532 1.1 jonathan mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2533 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
2534 1.1 jonathan return key_senderror(so, m, EINVAL);
2535 1.1 jonathan }
2536 1.1 jonathan
2537 1.230 christos xpl = mhp->ext[SADB_X_EXT_POLICY];
2538 1.230 christos id = xpl->sadb_x_policy_id;
2539 1.1 jonathan
2540 1.1 jonathan /* Is there SP in SPD ? */
2541 1.137 ozaki sp = key_getspbyid(id);
2542 1.137 ozaki if (sp == NULL) {
2543 1.134 ozaki IPSECLOG(LOG_DEBUG, "no SP found id:%u.\n", id);
2544 1.1 jonathan return key_senderror(so, m, ENOENT);
2545 1.1 jonathan }
2546 1.1 jonathan
2547 1.46 degroote n = key_setdumpsp(sp, SADB_X_SPDGET, mhp->msg->sadb_msg_seq,
2548 1.118 ozaki mhp->msg->sadb_msg_pid);
2549 1.197 ozaki KEY_SP_UNREF(&sp); /* ref gained by key_getspbyid */
2550 1.1 jonathan if (n != NULL) {
2551 1.1 jonathan m_freem(m);
2552 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
2553 1.1 jonathan } else
2554 1.1 jonathan return key_senderror(so, m, ENOBUFS);
2555 1.1 jonathan }
2556 1.1 jonathan
2557 1.139 ozaki #ifdef notyet
2558 1.1 jonathan /*
2559 1.1 jonathan * SADB_X_SPDACQUIRE processing.
2560 1.1 jonathan * Acquire policy and SA(s) for a *OUTBOUND* packet.
2561 1.1 jonathan * send
2562 1.1 jonathan * <base, policy(*)>
2563 1.1 jonathan * to KMD, and expect to receive
2564 1.7 wiz * <base> with SADB_X_SPDACQUIRE if error occurred,
2565 1.1 jonathan * or
2566 1.1 jonathan * <base, policy>
2567 1.1 jonathan * with SADB_X_SPDUPDATE from KMD by PF_KEY.
2568 1.1 jonathan * policy(*) is without policy requests.
2569 1.1 jonathan *
2570 1.1 jonathan * 0 : succeed
2571 1.1 jonathan * others: error number
2572 1.1 jonathan */
2573 1.1 jonathan int
2574 1.66 drochner key_spdacquire(const struct secpolicy *sp)
2575 1.1 jonathan {
2576 1.1 jonathan struct mbuf *result = NULL, *m;
2577 1.1 jonathan struct secspacq *newspacq;
2578 1.1 jonathan int error;
2579 1.1 jonathan
2580 1.112 ozaki KASSERT(sp != NULL);
2581 1.112 ozaki KASSERTMSG(sp->req == NULL, "called but there is request");
2582 1.112 ozaki KASSERTMSG(sp->policy == IPSEC_POLICY_IPSEC,
2583 1.112 ozaki "policy mismathed. IPsec is expected");
2584 1.1 jonathan
2585 1.1 jonathan /* Get an entry to check whether sent message or not. */
2586 1.137 ozaki newspacq = key_getspacq(&sp->spidx);
2587 1.137 ozaki if (newspacq != NULL) {
2588 1.1 jonathan if (key_blockacq_count < newspacq->count) {
2589 1.1 jonathan /* reset counter and do send message. */
2590 1.1 jonathan newspacq->count = 0;
2591 1.1 jonathan } else {
2592 1.1 jonathan /* increment counter and do nothing. */
2593 1.1 jonathan newspacq->count++;
2594 1.1 jonathan return 0;
2595 1.1 jonathan }
2596 1.1 jonathan } else {
2597 1.1 jonathan /* make new entry for blocking to send SADB_ACQUIRE. */
2598 1.137 ozaki newspacq = key_newspacq(&sp->spidx);
2599 1.137 ozaki if (newspacq == NULL)
2600 1.1 jonathan return ENOBUFS;
2601 1.1 jonathan
2602 1.208 ozaki /* add to key_misc.acqlist */
2603 1.208 ozaki LIST_INSERT_HEAD(&key_misc.spacqlist, newspacq, chain);
2604 1.1 jonathan }
2605 1.1 jonathan
2606 1.1 jonathan /* create new sadb_msg to reply. */
2607 1.1 jonathan m = key_setsadbmsg(SADB_X_SPDACQUIRE, 0, 0, 0, 0, 0);
2608 1.1 jonathan if (!m) {
2609 1.1 jonathan error = ENOBUFS;
2610 1.1 jonathan goto fail;
2611 1.1 jonathan }
2612 1.1 jonathan result = m;
2613 1.1 jonathan
2614 1.1 jonathan result->m_pkthdr.len = 0;
2615 1.1 jonathan for (m = result; m; m = m->m_next)
2616 1.1 jonathan result->m_pkthdr.len += m->m_len;
2617 1.1 jonathan
2618 1.1 jonathan mtod(result, struct sadb_msg *)->sadb_msg_len =
2619 1.1 jonathan PFKEY_UNIT64(result->m_pkthdr.len);
2620 1.1 jonathan
2621 1.1 jonathan return key_sendup_mbuf(NULL, m, KEY_SENDUP_REGISTERED);
2622 1.1 jonathan
2623 1.1 jonathan fail:
2624 1.1 jonathan if (result)
2625 1.1 jonathan m_freem(result);
2626 1.1 jonathan return error;
2627 1.1 jonathan }
2628 1.139 ozaki #endif /* notyet */
2629 1.1 jonathan
2630 1.1 jonathan /*
2631 1.1 jonathan * SADB_SPDFLUSH processing
2632 1.1 jonathan * receive
2633 1.1 jonathan * <base>
2634 1.1 jonathan * from the user, and free all entries in secpctree.
2635 1.1 jonathan * and send,
2636 1.1 jonathan * <base>
2637 1.1 jonathan * to the user.
2638 1.1 jonathan * NOTE: what to do is only marking SADB_SASTATE_DEAD.
2639 1.1 jonathan *
2640 1.1 jonathan * m will always be freed.
2641 1.1 jonathan */
2642 1.1 jonathan static int
2643 1.162 ozaki key_api_spdflush(struct socket *so, struct mbuf *m,
2644 1.49 degroote const struct sadb_msghdr *mhp)
2645 1.1 jonathan {
2646 1.1 jonathan struct sadb_msg *newmsg;
2647 1.1 jonathan struct secpolicy *sp;
2648 1.1 jonathan u_int dir;
2649 1.1 jonathan
2650 1.1 jonathan if (m->m_len != PFKEY_ALIGN8(sizeof(struct sadb_msg)))
2651 1.1 jonathan return key_senderror(so, m, EINVAL);
2652 1.1 jonathan
2653 1.1 jonathan for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
2654 1.194 ozaki retry:
2655 1.208 ozaki mutex_enter(&key_spd.lock);
2656 1.194 ozaki SPLIST_WRITER_FOREACH(sp, dir) {
2657 1.197 ozaki KASSERT(sp->state != IPSEC_SPSTATE_DEAD);
2658 1.197 ozaki key_unlink_sp(sp);
2659 1.208 ozaki mutex_exit(&key_spd.lock);
2660 1.197 ozaki key_destroy_sp(sp);
2661 1.194 ozaki goto retry;
2662 1.1 jonathan }
2663 1.208 ozaki mutex_exit(&key_spd.lock);
2664 1.1 jonathan }
2665 1.1 jonathan
2666 1.9 thorpej /* We're deleting policy; no need to invalidate the ipflow cache. */
2667 1.9 thorpej
2668 1.1 jonathan if (sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
2669 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
2670 1.1 jonathan return key_senderror(so, m, ENOBUFS);
2671 1.1 jonathan }
2672 1.1 jonathan
2673 1.1 jonathan if (m->m_next)
2674 1.1 jonathan m_freem(m->m_next);
2675 1.1 jonathan m->m_next = NULL;
2676 1.1 jonathan m->m_pkthdr.len = m->m_len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
2677 1.1 jonathan newmsg = mtod(m, struct sadb_msg *);
2678 1.1 jonathan newmsg->sadb_msg_errno = 0;
2679 1.1 jonathan newmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
2680 1.1 jonathan
2681 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
2682 1.1 jonathan }
2683 1.1 jonathan
2684 1.79 gdt static struct sockaddr key_src = {
2685 1.79 gdt .sa_len = 2,
2686 1.29 christos .sa_family = PF_KEY,
2687 1.29 christos };
2688 1.19 jonathan
2689 1.19 jonathan static struct mbuf *
2690 1.20 jonathan key_setspddump_chain(int *errorp, int *lenp, pid_t pid)
2691 1.19 jonathan {
2692 1.19 jonathan struct secpolicy *sp;
2693 1.19 jonathan int cnt;
2694 1.19 jonathan u_int dir;
2695 1.19 jonathan struct mbuf *m, *n, *prev;
2696 1.19 jonathan int totlen;
2697 1.19 jonathan
2698 1.208 ozaki KASSERT(mutex_owned(&key_spd.lock));
2699 1.197 ozaki
2700 1.19 jonathan *lenp = 0;
2701 1.19 jonathan
2702 1.19 jonathan /* search SPD entry and get buffer size. */
2703 1.19 jonathan cnt = 0;
2704 1.19 jonathan for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
2705 1.197 ozaki SPLIST_WRITER_FOREACH(sp, dir) {
2706 1.19 jonathan cnt++;
2707 1.19 jonathan }
2708 1.19 jonathan }
2709 1.19 jonathan
2710 1.19 jonathan if (cnt == 0) {
2711 1.19 jonathan *errorp = ENOENT;
2712 1.19 jonathan return (NULL);
2713 1.19 jonathan }
2714 1.19 jonathan
2715 1.19 jonathan m = NULL;
2716 1.19 jonathan prev = m;
2717 1.19 jonathan totlen = 0;
2718 1.19 jonathan for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
2719 1.197 ozaki SPLIST_WRITER_FOREACH(sp, dir) {
2720 1.19 jonathan --cnt;
2721 1.20 jonathan n = key_setdumpsp(sp, SADB_X_SPDDUMP, cnt, pid);
2722 1.19 jonathan
2723 1.19 jonathan if (!n) {
2724 1.19 jonathan *errorp = ENOBUFS;
2725 1.137 ozaki if (m)
2726 1.137 ozaki m_freem(m);
2727 1.19 jonathan return (NULL);
2728 1.19 jonathan }
2729 1.19 jonathan
2730 1.19 jonathan totlen += n->m_pkthdr.len;
2731 1.19 jonathan if (!m) {
2732 1.19 jonathan m = n;
2733 1.19 jonathan } else {
2734 1.19 jonathan prev->m_nextpkt = n;
2735 1.19 jonathan }
2736 1.19 jonathan prev = n;
2737 1.19 jonathan }
2738 1.19 jonathan }
2739 1.19 jonathan
2740 1.19 jonathan *lenp = totlen;
2741 1.19 jonathan *errorp = 0;
2742 1.19 jonathan return (m);
2743 1.19 jonathan }
2744 1.19 jonathan
2745 1.1 jonathan /*
2746 1.1 jonathan * SADB_SPDDUMP processing
2747 1.1 jonathan * receive
2748 1.1 jonathan * <base>
2749 1.1 jonathan * from the user, and dump all SP leaves
2750 1.1 jonathan * and send,
2751 1.1 jonathan * <base> .....
2752 1.1 jonathan * to the ikmpd.
2753 1.1 jonathan *
2754 1.1 jonathan * m will always be freed.
2755 1.1 jonathan */
2756 1.1 jonathan static int
2757 1.162 ozaki key_api_spddump(struct socket *so, struct mbuf *m0,
2758 1.49 degroote const struct sadb_msghdr *mhp)
2759 1.1 jonathan {
2760 1.1 jonathan struct mbuf *n;
2761 1.19 jonathan int error, len;
2762 1.197 ozaki int ok;
2763 1.20 jonathan pid_t pid;
2764 1.1 jonathan
2765 1.20 jonathan pid = mhp->msg->sadb_msg_pid;
2766 1.19 jonathan /*
2767 1.19 jonathan * If the requestor has insufficient socket-buffer space
2768 1.19 jonathan * for the entire chain, nobody gets any response to the DUMP.
2769 1.19 jonathan * XXX For now, only the requestor ever gets anything.
2770 1.19 jonathan * Moreover, if the requestor has any space at all, they receive
2771 1.19 jonathan * the entire chain, otherwise the request is refused with ENOBUFS.
2772 1.19 jonathan */
2773 1.19 jonathan if (sbspace(&so->so_rcv) <= 0) {
2774 1.19 jonathan return key_senderror(so, m0, ENOBUFS);
2775 1.19 jonathan }
2776 1.19 jonathan
2777 1.208 ozaki mutex_enter(&key_spd.lock);
2778 1.20 jonathan n = key_setspddump_chain(&error, &len, pid);
2779 1.208 ozaki mutex_exit(&key_spd.lock);
2780 1.19 jonathan
2781 1.19 jonathan if (n == NULL) {
2782 1.19 jonathan return key_senderror(so, m0, ENOENT);
2783 1.1 jonathan }
2784 1.52 thorpej {
2785 1.52 thorpej uint64_t *ps = PFKEY_STAT_GETREF();
2786 1.52 thorpej ps[PFKEY_STAT_IN_TOTAL]++;
2787 1.52 thorpej ps[PFKEY_STAT_IN_BYTES] += len;
2788 1.52 thorpej PFKEY_STAT_PUTREF();
2789 1.52 thorpej }
2790 1.1 jonathan
2791 1.19 jonathan /*
2792 1.19 jonathan * PF_KEY DUMP responses are no longer broadcast to all PF_KEY sockets.
2793 1.19 jonathan * The requestor receives either the entire chain, or an
2794 1.19 jonathan * error message with ENOBUFS.
2795 1.19 jonathan */
2796 1.1 jonathan
2797 1.19 jonathan /*
2798 1.19 jonathan * sbappendchainwith record takes the chain of entries, one
2799 1.19 jonathan * packet-record per SPD entry, prepends the key_src sockaddr
2800 1.19 jonathan * to each packet-record, links the sockaddr mbufs into a new
2801 1.19 jonathan * list of records, then appends the entire resulting
2802 1.19 jonathan * list to the requesting socket.
2803 1.19 jonathan */
2804 1.137 ozaki ok = sbappendaddrchain(&so->so_rcv, (struct sockaddr *)&key_src, n,
2805 1.137 ozaki SB_PRIO_ONESHOT_OVERFLOW);
2806 1.1 jonathan
2807 1.19 jonathan if (!ok) {
2808 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
2809 1.19 jonathan m_freem(n);
2810 1.19 jonathan return key_senderror(so, m0, ENOBUFS);
2811 1.1 jonathan }
2812 1.1 jonathan
2813 1.19 jonathan m_freem(m0);
2814 1.19 jonathan return error;
2815 1.1 jonathan }
2816 1.1 jonathan
2817 1.48 degroote /*
2818 1.48 degroote * SADB_X_NAT_T_NEW_MAPPING. Unused by racoon as of 2005/04/23
2819 1.48 degroote */
2820 1.48 degroote static int
2821 1.162 ozaki key_api_nat_map(struct socket *so, struct mbuf *m,
2822 1.49 degroote const struct sadb_msghdr *mhp)
2823 1.48 degroote {
2824 1.48 degroote struct sadb_x_nat_t_type *type;
2825 1.48 degroote struct sadb_x_nat_t_port *sport;
2826 1.48 degroote struct sadb_x_nat_t_port *dport;
2827 1.64 spz struct sadb_address *iaddr, *raddr;
2828 1.48 degroote struct sadb_x_nat_t_frag *frag;
2829 1.48 degroote
2830 1.48 degroote if (mhp->ext[SADB_X_EXT_NAT_T_TYPE] == NULL ||
2831 1.137 ozaki mhp->ext[SADB_X_EXT_NAT_T_SPORT] == NULL ||
2832 1.137 ozaki mhp->ext[SADB_X_EXT_NAT_T_DPORT] == NULL) {
2833 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message.\n");
2834 1.48 degroote return key_senderror(so, m, EINVAL);
2835 1.48 degroote }
2836 1.48 degroote if ((mhp->extlen[SADB_X_EXT_NAT_T_TYPE] < sizeof(*type)) ||
2837 1.137 ozaki (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport)) ||
2838 1.137 ozaki (mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport))) {
2839 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message.\n");
2840 1.48 degroote return key_senderror(so, m, EINVAL);
2841 1.48 degroote }
2842 1.48 degroote
2843 1.64 spz if ((mhp->ext[SADB_X_EXT_NAT_T_OAI] != NULL) &&
2844 1.137 ozaki (mhp->extlen[SADB_X_EXT_NAT_T_OAI] < sizeof(*iaddr))) {
2845 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message\n");
2846 1.64 spz return key_senderror(so, m, EINVAL);
2847 1.64 spz }
2848 1.64 spz
2849 1.64 spz if ((mhp->ext[SADB_X_EXT_NAT_T_OAR] != NULL) &&
2850 1.137 ozaki (mhp->extlen[SADB_X_EXT_NAT_T_OAR] < sizeof(*raddr))) {
2851 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message\n");
2852 1.48 degroote return key_senderror(so, m, EINVAL);
2853 1.48 degroote }
2854 1.48 degroote
2855 1.48 degroote if ((mhp->ext[SADB_X_EXT_NAT_T_FRAG] != NULL) &&
2856 1.137 ozaki (mhp->extlen[SADB_X_EXT_NAT_T_FRAG] < sizeof(*frag))) {
2857 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message\n");
2858 1.48 degroote return key_senderror(so, m, EINVAL);
2859 1.48 degroote }
2860 1.48 degroote
2861 1.230 christos type = mhp->ext[SADB_X_EXT_NAT_T_TYPE];
2862 1.230 christos sport = mhp->ext[SADB_X_EXT_NAT_T_SPORT];
2863 1.230 christos dport = mhp->ext[SADB_X_EXT_NAT_T_DPORT];
2864 1.230 christos iaddr = mhp->ext[SADB_X_EXT_NAT_T_OAI];
2865 1.230 christos raddr = mhp->ext[SADB_X_EXT_NAT_T_OAR];
2866 1.230 christos frag = mhp->ext[SADB_X_EXT_NAT_T_FRAG];
2867 1.48 degroote
2868 1.48 degroote /*
2869 1.48 degroote * XXX handle that, it should also contain a SA, or anything
2870 1.48 degroote * that enable to update the SA information.
2871 1.48 degroote */
2872 1.48 degroote
2873 1.48 degroote return 0;
2874 1.48 degroote }
2875 1.48 degroote
2876 1.240 ozaki /*
2877 1.240 ozaki * It may return NULL.
2878 1.240 ozaki */
2879 1.1 jonathan static struct mbuf *
2880 1.49 degroote key_setdumpsp(struct secpolicy *sp, u_int8_t type, u_int32_t seq, pid_t pid)
2881 1.1 jonathan {
2882 1.1 jonathan struct mbuf *result = NULL, *m;
2883 1.1 jonathan
2884 1.239 ozaki KASSERT(!cpu_softintr_p());
2885 1.239 ozaki
2886 1.193 ozaki m = key_setsadbmsg(type, 0, SADB_SATYPE_UNSPEC, seq, pid,
2887 1.239 ozaki key_sp_refcnt(sp), M_WAITOK);
2888 1.1 jonathan result = m;
2889 1.1 jonathan
2890 1.1 jonathan m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
2891 1.239 ozaki &sp->spidx.src.sa, sp->spidx.prefs, sp->spidx.ul_proto, M_WAITOK);
2892 1.1 jonathan m_cat(result, m);
2893 1.1 jonathan
2894 1.1 jonathan m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
2895 1.239 ozaki &sp->spidx.dst.sa, sp->spidx.prefd, sp->spidx.ul_proto, M_WAITOK);
2896 1.1 jonathan m_cat(result, m);
2897 1.1 jonathan
2898 1.239 ozaki m = key_sp2msg(sp, M_WAITOK);
2899 1.1 jonathan m_cat(result, m);
2900 1.1 jonathan
2901 1.1 jonathan if ((result->m_flags & M_PKTHDR) == 0)
2902 1.1 jonathan goto fail;
2903 1.1 jonathan
2904 1.1 jonathan if (result->m_len < sizeof(struct sadb_msg)) {
2905 1.1 jonathan result = m_pullup(result, sizeof(struct sadb_msg));
2906 1.1 jonathan if (result == NULL)
2907 1.1 jonathan goto fail;
2908 1.1 jonathan }
2909 1.1 jonathan
2910 1.1 jonathan result->m_pkthdr.len = 0;
2911 1.1 jonathan for (m = result; m; m = m->m_next)
2912 1.1 jonathan result->m_pkthdr.len += m->m_len;
2913 1.1 jonathan
2914 1.1 jonathan mtod(result, struct sadb_msg *)->sadb_msg_len =
2915 1.1 jonathan PFKEY_UNIT64(result->m_pkthdr.len);
2916 1.1 jonathan
2917 1.1 jonathan return result;
2918 1.1 jonathan
2919 1.1 jonathan fail:
2920 1.1 jonathan m_freem(result);
2921 1.1 jonathan return NULL;
2922 1.1 jonathan }
2923 1.1 jonathan
2924 1.1 jonathan /*
2925 1.1 jonathan * get PFKEY message length for security policy and request.
2926 1.1 jonathan */
2927 1.1 jonathan static u_int
2928 1.66 drochner key_getspreqmsglen(const struct secpolicy *sp)
2929 1.1 jonathan {
2930 1.1 jonathan u_int tlen;
2931 1.1 jonathan
2932 1.1 jonathan tlen = sizeof(struct sadb_x_policy);
2933 1.1 jonathan
2934 1.1 jonathan /* if is the policy for ipsec ? */
2935 1.1 jonathan if (sp->policy != IPSEC_POLICY_IPSEC)
2936 1.1 jonathan return tlen;
2937 1.1 jonathan
2938 1.1 jonathan /* get length of ipsec requests */
2939 1.1 jonathan {
2940 1.66 drochner const struct ipsecrequest *isr;
2941 1.1 jonathan int len;
2942 1.1 jonathan
2943 1.1 jonathan for (isr = sp->req; isr != NULL; isr = isr->next) {
2944 1.1 jonathan len = sizeof(struct sadb_x_ipsecrequest)
2945 1.137 ozaki + isr->saidx.src.sa.sa_len + isr->saidx.dst.sa.sa_len;
2946 1.1 jonathan
2947 1.1 jonathan tlen += PFKEY_ALIGN8(len);
2948 1.1 jonathan }
2949 1.1 jonathan }
2950 1.1 jonathan
2951 1.1 jonathan return tlen;
2952 1.1 jonathan }
2953 1.1 jonathan
2954 1.1 jonathan /*
2955 1.1 jonathan * SADB_SPDEXPIRE processing
2956 1.1 jonathan * send
2957 1.1 jonathan * <base, address(SD), lifetime(CH), policy>
2958 1.1 jonathan * to KMD by PF_KEY.
2959 1.1 jonathan *
2960 1.1 jonathan * OUT: 0 : succeed
2961 1.1 jonathan * others : error number
2962 1.1 jonathan */
2963 1.1 jonathan static int
2964 1.49 degroote key_spdexpire(struct secpolicy *sp)
2965 1.1 jonathan {
2966 1.1 jonathan int s;
2967 1.1 jonathan struct mbuf *result = NULL, *m;
2968 1.1 jonathan int len;
2969 1.1 jonathan int error = -1;
2970 1.1 jonathan struct sadb_lifetime *lt;
2971 1.1 jonathan
2972 1.1 jonathan /* XXX: Why do we lock ? */
2973 1.1 jonathan s = splsoftnet(); /*called from softclock()*/
2974 1.1 jonathan
2975 1.112 ozaki KASSERT(sp != NULL);
2976 1.1 jonathan
2977 1.1 jonathan /* set msg header */
2978 1.239 ozaki m = key_setsadbmsg(SADB_X_SPDEXPIRE, 0, 0, 0, 0, 0, M_WAITOK);
2979 1.1 jonathan result = m;
2980 1.1 jonathan
2981 1.1 jonathan /* create lifetime extension (current and hard) */
2982 1.1 jonathan len = PFKEY_ALIGN8(sizeof(*lt)) * 2;
2983 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
2984 1.240 ozaki KASSERT(m->m_next == NULL);
2985 1.240 ozaki
2986 1.49 degroote memset(mtod(m, void *), 0, len);
2987 1.1 jonathan lt = mtod(m, struct sadb_lifetime *);
2988 1.1 jonathan lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
2989 1.1 jonathan lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
2990 1.1 jonathan lt->sadb_lifetime_allocations = 0;
2991 1.1 jonathan lt->sadb_lifetime_bytes = 0;
2992 1.175 ozaki lt->sadb_lifetime_addtime = time_mono_to_wall(sp->created);
2993 1.175 ozaki lt->sadb_lifetime_usetime = time_mono_to_wall(sp->lastused);
2994 1.39 degroote lt = (struct sadb_lifetime *)(mtod(m, char *) + len / 2);
2995 1.1 jonathan lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
2996 1.1 jonathan lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
2997 1.1 jonathan lt->sadb_lifetime_allocations = 0;
2998 1.1 jonathan lt->sadb_lifetime_bytes = 0;
2999 1.1 jonathan lt->sadb_lifetime_addtime = sp->lifetime;
3000 1.1 jonathan lt->sadb_lifetime_usetime = sp->validtime;
3001 1.1 jonathan m_cat(result, m);
3002 1.1 jonathan
3003 1.1 jonathan /* set sadb_address for source */
3004 1.137 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC, &sp->spidx.src.sa,
3005 1.239 ozaki sp->spidx.prefs, sp->spidx.ul_proto, M_WAITOK);
3006 1.1 jonathan m_cat(result, m);
3007 1.1 jonathan
3008 1.1 jonathan /* set sadb_address for destination */
3009 1.137 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_DST, &sp->spidx.dst.sa,
3010 1.239 ozaki sp->spidx.prefd, sp->spidx.ul_proto, M_WAITOK);
3011 1.1 jonathan m_cat(result, m);
3012 1.1 jonathan
3013 1.1 jonathan /* set secpolicy */
3014 1.239 ozaki m = key_sp2msg(sp, M_WAITOK);
3015 1.1 jonathan m_cat(result, m);
3016 1.1 jonathan
3017 1.1 jonathan if ((result->m_flags & M_PKTHDR) == 0) {
3018 1.1 jonathan error = EINVAL;
3019 1.1 jonathan goto fail;
3020 1.1 jonathan }
3021 1.1 jonathan
3022 1.1 jonathan if (result->m_len < sizeof(struct sadb_msg)) {
3023 1.1 jonathan result = m_pullup(result, sizeof(struct sadb_msg));
3024 1.1 jonathan if (result == NULL) {
3025 1.1 jonathan error = ENOBUFS;
3026 1.1 jonathan goto fail;
3027 1.1 jonathan }
3028 1.1 jonathan }
3029 1.1 jonathan
3030 1.1 jonathan result->m_pkthdr.len = 0;
3031 1.1 jonathan for (m = result; m; m = m->m_next)
3032 1.1 jonathan result->m_pkthdr.len += m->m_len;
3033 1.1 jonathan
3034 1.1 jonathan mtod(result, struct sadb_msg *)->sadb_msg_len =
3035 1.1 jonathan PFKEY_UNIT64(result->m_pkthdr.len);
3036 1.1 jonathan
3037 1.238 ozaki error = key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
3038 1.238 ozaki result = NULL;
3039 1.1 jonathan
3040 1.1 jonathan fail:
3041 1.1 jonathan if (result)
3042 1.1 jonathan m_freem(result);
3043 1.1 jonathan splx(s);
3044 1.1 jonathan return error;
3045 1.1 jonathan }
3046 1.1 jonathan
3047 1.1 jonathan /* %%% SAD management */
3048 1.1 jonathan /*
3049 1.1 jonathan * allocating a memory for new SA head, and copy from the values of mhp.
3050 1.1 jonathan * OUT: NULL : failure due to the lack of memory.
3051 1.1 jonathan * others : pointer to new SA head.
3052 1.1 jonathan */
3053 1.1 jonathan static struct secashead *
3054 1.66 drochner key_newsah(const struct secasindex *saidx)
3055 1.1 jonathan {
3056 1.1 jonathan struct secashead *newsah;
3057 1.127 ozaki int i;
3058 1.1 jonathan
3059 1.108 ozaki KASSERT(saidx != NULL);
3060 1.1 jonathan
3061 1.127 ozaki newsah = kmem_zalloc(sizeof(struct secashead), KM_SLEEP);
3062 1.208 ozaki for (i = 0; i < __arraycount(newsah->savlist); i++)
3063 1.208 ozaki PSLIST_INIT(&newsah->savlist[i]);
3064 1.127 ozaki newsah->saidx = *saidx;
3065 1.127 ozaki
3066 1.216 ozaki localcount_init(&newsah->localcount);
3067 1.216 ozaki /* Take a reference for the caller */
3068 1.216 ozaki localcount_acquire(&newsah->localcount);
3069 1.216 ozaki
3070 1.216 ozaki /* Add to the sah list */
3071 1.216 ozaki SAHLIST_ENTRY_INIT(newsah);
3072 1.127 ozaki newsah->state = SADB_SASTATE_MATURE;
3073 1.208 ozaki mutex_enter(&key_sad.lock);
3074 1.202 ozaki SAHLIST_WRITER_INSERT_HEAD(newsah);
3075 1.208 ozaki mutex_exit(&key_sad.lock);
3076 1.127 ozaki
3077 1.127 ozaki return newsah;
3078 1.1 jonathan }
3079 1.1 jonathan
3080 1.216 ozaki static bool
3081 1.216 ozaki key_sah_has_sav(struct secashead *sah)
3082 1.216 ozaki {
3083 1.216 ozaki u_int state;
3084 1.216 ozaki
3085 1.216 ozaki KASSERT(mutex_owned(&key_sad.lock));
3086 1.216 ozaki
3087 1.216 ozaki SASTATE_ANY_FOREACH(state) {
3088 1.216 ozaki if (!SAVLIST_WRITER_EMPTY(sah, state))
3089 1.216 ozaki return true;
3090 1.216 ozaki }
3091 1.216 ozaki
3092 1.216 ozaki return false;
3093 1.216 ozaki }
3094 1.216 ozaki
3095 1.1 jonathan static void
3096 1.216 ozaki key_unlink_sah(struct secashead *sah)
3097 1.1 jonathan {
3098 1.1 jonathan
3099 1.127 ozaki KASSERT(!cpu_softintr_p());
3100 1.216 ozaki KASSERT(mutex_owned(&key_sad.lock));
3101 1.216 ozaki KASSERT(sah->state == SADB_SASTATE_DEAD);
3102 1.1 jonathan
3103 1.216 ozaki /* Remove from the sah list */
3104 1.216 ozaki SAHLIST_WRITER_REMOVE(sah);
3105 1.1 jonathan
3106 1.216 ozaki #ifdef NET_MPSAFE
3107 1.216 ozaki KASSERT(mutex_ownable(softnet_lock));
3108 1.226 ozaki key_sad_pserialize_perform();
3109 1.216 ozaki #endif
3110 1.216 ozaki
3111 1.226 ozaki localcount_drain(&sah->localcount, &key_sad.cv_lc, &key_sad.lock);
3112 1.216 ozaki }
3113 1.1 jonathan
3114 1.216 ozaki static void
3115 1.216 ozaki key_destroy_sah(struct secashead *sah)
3116 1.216 ozaki {
3117 1.1 jonathan
3118 1.32 joerg rtcache_free(&sah->sa_route);
3119 1.1 jonathan
3120 1.216 ozaki SAHLIST_ENTRY_DESTROY(sah);
3121 1.216 ozaki localcount_fini(&sah->localcount);
3122 1.1 jonathan
3123 1.129 ozaki if (sah->idents != NULL)
3124 1.132 ozaki kmem_free(sah->idents, sah->idents_len);
3125 1.129 ozaki if (sah->identd != NULL)
3126 1.132 ozaki kmem_free(sah->identd, sah->identd_len);
3127 1.129 ozaki
3128 1.127 ozaki kmem_free(sah, sizeof(*sah));
3129 1.1 jonathan }
3130 1.1 jonathan
3131 1.1 jonathan /*
3132 1.162 ozaki * allocating a new SA with LARVAL state.
3133 1.162 ozaki * key_api_add() and key_api_getspi() call,
3134 1.1 jonathan * and copy the values of mhp into new buffer.
3135 1.1 jonathan * When SAD message type is GETSPI:
3136 1.1 jonathan * to set sequence number from acq_seq++,
3137 1.1 jonathan * to set zero to SPI.
3138 1.1 jonathan * not to call key_setsava().
3139 1.1 jonathan * OUT: NULL : fail
3140 1.1 jonathan * others : pointer to new secasvar.
3141 1.1 jonathan *
3142 1.1 jonathan * does not modify mbuf. does not free mbuf on error.
3143 1.1 jonathan */
3144 1.1 jonathan static struct secasvar *
3145 1.49 degroote key_newsav(struct mbuf *m, const struct sadb_msghdr *mhp,
3146 1.171 ozaki int *errp, const char* where, int tag)
3147 1.1 jonathan {
3148 1.1 jonathan struct secasvar *newsav;
3149 1.1 jonathan const struct sadb_sa *xsa;
3150 1.1 jonathan
3151 1.127 ozaki KASSERT(!cpu_softintr_p());
3152 1.112 ozaki KASSERT(m != NULL);
3153 1.112 ozaki KASSERT(mhp != NULL);
3154 1.112 ozaki KASSERT(mhp->msg != NULL);
3155 1.1 jonathan
3156 1.130 ozaki newsav = kmem_zalloc(sizeof(struct secasvar), KM_SLEEP);
3157 1.1 jonathan
3158 1.1 jonathan switch (mhp->msg->sadb_msg_type) {
3159 1.1 jonathan case SADB_GETSPI:
3160 1.1 jonathan newsav->spi = 0;
3161 1.1 jonathan
3162 1.1 jonathan #ifdef IPSEC_DOSEQCHECK
3163 1.1 jonathan /* sync sequence number */
3164 1.1 jonathan if (mhp->msg->sadb_msg_seq == 0)
3165 1.1 jonathan newsav->seq =
3166 1.137 ozaki (acq_seq = (acq_seq == ~0 ? 1 : ++acq_seq));
3167 1.1 jonathan else
3168 1.1 jonathan #endif
3169 1.1 jonathan newsav->seq = mhp->msg->sadb_msg_seq;
3170 1.1 jonathan break;
3171 1.1 jonathan
3172 1.1 jonathan case SADB_ADD:
3173 1.1 jonathan /* sanity check */
3174 1.1 jonathan if (mhp->ext[SADB_EXT_SA] == NULL) {
3175 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
3176 1.1 jonathan *errp = EINVAL;
3177 1.127 ozaki goto error;
3178 1.1 jonathan }
3179 1.230 christos xsa = mhp->ext[SADB_EXT_SA];
3180 1.1 jonathan newsav->spi = xsa->sadb_sa_spi;
3181 1.1 jonathan newsav->seq = mhp->msg->sadb_msg_seq;
3182 1.1 jonathan break;
3183 1.1 jonathan default:
3184 1.1 jonathan *errp = EINVAL;
3185 1.127 ozaki goto error;
3186 1.1 jonathan }
3187 1.1 jonathan
3188 1.1 jonathan /* copy sav values */
3189 1.1 jonathan if (mhp->msg->sadb_msg_type != SADB_GETSPI) {
3190 1.1 jonathan *errp = key_setsaval(newsav, m, mhp);
3191 1.127 ozaki if (*errp)
3192 1.127 ozaki goto error;
3193 1.201 ozaki } else {
3194 1.201 ozaki /* We don't allow lft_c to be NULL */
3195 1.201 ozaki newsav->lft_c = kmem_zalloc(sizeof(struct sadb_lifetime),
3196 1.201 ozaki KM_SLEEP);
3197 1.1 jonathan }
3198 1.1 jonathan
3199 1.1 jonathan /* reset created */
3200 1.69 drochner newsav->created = time_uptime;
3201 1.1 jonathan newsav->pid = mhp->msg->sadb_msg_pid;
3202 1.1 jonathan
3203 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
3204 1.124 ozaki "DP from %s:%u return SA:%p\n", where, tag, newsav);
3205 1.127 ozaki return newsav;
3206 1.1 jonathan
3207 1.127 ozaki error:
3208 1.127 ozaki KASSERT(*errp != 0);
3209 1.127 ozaki kmem_free(newsav, sizeof(*newsav));
3210 1.127 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
3211 1.127 ozaki "DP from %s:%u return SA:NULL\n", where, tag);
3212 1.127 ozaki return NULL;
3213 1.1 jonathan }
3214 1.1 jonathan
3215 1.169 ozaki
3216 1.1 jonathan static void
3217 1.169 ozaki key_clear_xform(struct secasvar *sav)
3218 1.1 jonathan {
3219 1.108 ozaki
3220 1.1 jonathan /*
3221 1.1 jonathan * Cleanup xform state. Note that zeroize'ing causes the
3222 1.1 jonathan * keys to be cleared; otherwise we must do it ourself.
3223 1.1 jonathan */
3224 1.1 jonathan if (sav->tdb_xform != NULL) {
3225 1.1 jonathan sav->tdb_xform->xf_zeroize(sav);
3226 1.1 jonathan sav->tdb_xform = NULL;
3227 1.1 jonathan } else {
3228 1.1 jonathan if (sav->key_auth != NULL)
3229 1.82 riastrad explicit_memset(_KEYBUF(sav->key_auth), 0,
3230 1.82 riastrad _KEYLEN(sav->key_auth));
3231 1.1 jonathan if (sav->key_enc != NULL)
3232 1.82 riastrad explicit_memset(_KEYBUF(sav->key_enc), 0,
3233 1.82 riastrad _KEYLEN(sav->key_enc));
3234 1.1 jonathan }
3235 1.169 ozaki }
3236 1.169 ozaki
3237 1.169 ozaki /*
3238 1.169 ozaki * free() SA variable entry.
3239 1.169 ozaki */
3240 1.169 ozaki static void
3241 1.169 ozaki key_delsav(struct secasvar *sav)
3242 1.169 ozaki {
3243 1.169 ozaki
3244 1.169 ozaki key_clear_xform(sav);
3245 1.131 ozaki key_freesaval(sav);
3246 1.223 ozaki kmem_free(sav, sizeof(*sav));
3247 1.1 jonathan }
3248 1.1 jonathan
3249 1.1 jonathan /*
3250 1.216 ozaki * Must be called in a pserialize read section. A held sah
3251 1.216 ozaki * must be released by key_sah_unref after use.
3252 1.216 ozaki */
3253 1.216 ozaki static void
3254 1.216 ozaki key_sah_ref(struct secashead *sah)
3255 1.216 ozaki {
3256 1.216 ozaki
3257 1.216 ozaki localcount_acquire(&sah->localcount);
3258 1.216 ozaki }
3259 1.216 ozaki
3260 1.216 ozaki /*
3261 1.216 ozaki * Must be called without holding key_sad.lock because the lock
3262 1.216 ozaki * would be held in localcount_release.
3263 1.216 ozaki */
3264 1.216 ozaki static void
3265 1.216 ozaki key_sah_unref(struct secashead *sah)
3266 1.216 ozaki {
3267 1.216 ozaki
3268 1.216 ozaki KDASSERT(mutex_ownable(&key_sad.lock));
3269 1.216 ozaki
3270 1.226 ozaki localcount_release(&sah->localcount, &key_sad.cv_lc, &key_sad.lock);
3271 1.216 ozaki }
3272 1.216 ozaki
3273 1.216 ozaki /*
3274 1.216 ozaki * Search SAD and return sah. Must be called in a pserialize
3275 1.216 ozaki * read section.
3276 1.1 jonathan * OUT:
3277 1.1 jonathan * NULL : not found
3278 1.1 jonathan * others : found, pointer to a SA.
3279 1.1 jonathan */
3280 1.1 jonathan static struct secashead *
3281 1.155 ozaki key_getsah(const struct secasindex *saidx, int flag)
3282 1.1 jonathan {
3283 1.1 jonathan struct secashead *sah;
3284 1.1 jonathan
3285 1.202 ozaki SAHLIST_READER_FOREACH(sah) {
3286 1.1 jonathan if (sah->state == SADB_SASTATE_DEAD)
3287 1.1 jonathan continue;
3288 1.155 ozaki if (key_saidx_match(&sah->saidx, saidx, flag))
3289 1.1 jonathan return sah;
3290 1.1 jonathan }
3291 1.1 jonathan
3292 1.1 jonathan return NULL;
3293 1.1 jonathan }
3294 1.1 jonathan
3295 1.1 jonathan /*
3296 1.216 ozaki * Search SAD and return sah. If sah is returned, the caller must call
3297 1.216 ozaki * key_sah_unref to releaset a reference.
3298 1.216 ozaki * OUT:
3299 1.216 ozaki * NULL : not found
3300 1.216 ozaki * others : found, pointer to a SA.
3301 1.216 ozaki */
3302 1.216 ozaki static struct secashead *
3303 1.216 ozaki key_getsah_ref(const struct secasindex *saidx, int flag)
3304 1.216 ozaki {
3305 1.216 ozaki struct secashead *sah;
3306 1.216 ozaki int s;
3307 1.216 ozaki
3308 1.216 ozaki s = pserialize_read_enter();
3309 1.216 ozaki sah = key_getsah(saidx, flag);
3310 1.216 ozaki if (sah != NULL)
3311 1.216 ozaki key_sah_ref(sah);
3312 1.216 ozaki pserialize_read_exit(s);
3313 1.216 ozaki
3314 1.216 ozaki return sah;
3315 1.216 ozaki }
3316 1.216 ozaki
3317 1.216 ozaki /*
3318 1.1 jonathan * check not to be duplicated SPI.
3319 1.1 jonathan * NOTE: this function is too slow due to searching all SAD.
3320 1.1 jonathan * OUT:
3321 1.1 jonathan * NULL : not found
3322 1.1 jonathan * others : found, pointer to a SA.
3323 1.1 jonathan */
3324 1.174 ozaki static bool
3325 1.66 drochner key_checkspidup(const struct secasindex *saidx, u_int32_t spi)
3326 1.1 jonathan {
3327 1.1 jonathan struct secashead *sah;
3328 1.1 jonathan struct secasvar *sav;
3329 1.216 ozaki int s;
3330 1.1 jonathan
3331 1.1 jonathan /* check address family */
3332 1.1 jonathan if (saidx->src.sa.sa_family != saidx->dst.sa.sa_family) {
3333 1.134 ozaki IPSECLOG(LOG_DEBUG, "address family mismatched.\n");
3334 1.174 ozaki return false;
3335 1.1 jonathan }
3336 1.1 jonathan
3337 1.1 jonathan /* check all SAD */
3338 1.216 ozaki s = pserialize_read_enter();
3339 1.202 ozaki SAHLIST_READER_FOREACH(sah) {
3340 1.1 jonathan if (!key_ismyaddr((struct sockaddr *)&sah->saidx.dst))
3341 1.1 jonathan continue;
3342 1.1 jonathan sav = key_getsavbyspi(sah, spi);
3343 1.174 ozaki if (sav != NULL) {
3344 1.216 ozaki pserialize_read_exit(s);
3345 1.206 ozaki KEY_SA_UNREF(&sav);
3346 1.174 ozaki return true;
3347 1.174 ozaki }
3348 1.1 jonathan }
3349 1.216 ozaki pserialize_read_exit(s);
3350 1.1 jonathan
3351 1.174 ozaki return false;
3352 1.1 jonathan }
3353 1.1 jonathan
3354 1.1 jonathan /*
3355 1.1 jonathan * search SAD litmited alive SA, protocol, SPI.
3356 1.1 jonathan * OUT:
3357 1.1 jonathan * NULL : not found
3358 1.1 jonathan * others : found, pointer to a SA.
3359 1.1 jonathan */
3360 1.1 jonathan static struct secasvar *
3361 1.49 degroote key_getsavbyspi(struct secashead *sah, u_int32_t spi)
3362 1.1 jonathan {
3363 1.205 ozaki struct secasvar *sav = NULL;
3364 1.120 ozaki u_int state;
3365 1.205 ozaki int s;
3366 1.1 jonathan
3367 1.1 jonathan /* search all status */
3368 1.205 ozaki s = pserialize_read_enter();
3369 1.120 ozaki SASTATE_ALIVE_FOREACH(state) {
3370 1.203 ozaki SAVLIST_READER_FOREACH(sav, sah, state) {
3371 1.1 jonathan /* sanity check */
3372 1.1 jonathan if (sav->state != state) {
3373 1.134 ozaki IPSECLOG(LOG_DEBUG,
3374 1.1 jonathan "invalid sav->state (queue: %d SA: %d)\n",
3375 1.134 ozaki state, sav->state);
3376 1.1 jonathan continue;
3377 1.1 jonathan }
3378 1.1 jonathan
3379 1.174 ozaki if (sav->spi == spi) {
3380 1.223 ozaki KEY_SA_REF(sav);
3381 1.205 ozaki goto out;
3382 1.174 ozaki }
3383 1.1 jonathan }
3384 1.1 jonathan }
3385 1.205 ozaki out:
3386 1.205 ozaki pserialize_read_exit(s);
3387 1.1 jonathan
3388 1.205 ozaki return sav;
3389 1.1 jonathan }
3390 1.1 jonathan
3391 1.1 jonathan /*
3392 1.131 ozaki * Free allocated data to member variables of sav:
3393 1.131 ozaki * sav->replay, sav->key_* and sav->lft_*.
3394 1.131 ozaki */
3395 1.131 ozaki static void
3396 1.131 ozaki key_freesaval(struct secasvar *sav)
3397 1.131 ozaki {
3398 1.131 ozaki
3399 1.217 ozaki KASSERT(key_sa_refcnt(sav) == 0);
3400 1.177 ozaki
3401 1.177 ozaki if (sav->replay != NULL)
3402 1.133 ozaki kmem_intr_free(sav->replay, sav->replay_len);
3403 1.177 ozaki if (sav->key_auth != NULL)
3404 1.133 ozaki kmem_intr_free(sav->key_auth, sav->key_auth_len);
3405 1.177 ozaki if (sav->key_enc != NULL)
3406 1.133 ozaki kmem_intr_free(sav->key_enc, sav->key_enc_len);
3407 1.177 ozaki if (sav->lft_c != NULL)
3408 1.133 ozaki kmem_intr_free(sav->lft_c, sizeof(*(sav->lft_c)));
3409 1.177 ozaki if (sav->lft_h != NULL)
3410 1.133 ozaki kmem_intr_free(sav->lft_h, sizeof(*(sav->lft_h)));
3411 1.177 ozaki if (sav->lft_s != NULL)
3412 1.133 ozaki kmem_intr_free(sav->lft_s, sizeof(*(sav->lft_s)));
3413 1.131 ozaki }
3414 1.131 ozaki
3415 1.131 ozaki /*
3416 1.1 jonathan * copy SA values from PF_KEY message except *SPI, SEQ, PID, STATE and TYPE*.
3417 1.1 jonathan * You must update these if need.
3418 1.1 jonathan * OUT: 0: success.
3419 1.1 jonathan * !0: failure.
3420 1.1 jonathan *
3421 1.1 jonathan * does not modify mbuf. does not free mbuf on error.
3422 1.1 jonathan */
3423 1.1 jonathan static int
3424 1.49 degroote key_setsaval(struct secasvar *sav, struct mbuf *m,
3425 1.49 degroote const struct sadb_msghdr *mhp)
3426 1.1 jonathan {
3427 1.1 jonathan int error = 0;
3428 1.1 jonathan
3429 1.127 ozaki KASSERT(!cpu_softintr_p());
3430 1.112 ozaki KASSERT(m != NULL);
3431 1.112 ozaki KASSERT(mhp != NULL);
3432 1.112 ozaki KASSERT(mhp->msg != NULL);
3433 1.1 jonathan
3434 1.167 ozaki /* We shouldn't initialize sav variables while someone uses it. */
3435 1.217 ozaki KASSERT(key_sa_refcnt(sav) == 0);
3436 1.167 ozaki
3437 1.1 jonathan /* SA */
3438 1.1 jonathan if (mhp->ext[SADB_EXT_SA] != NULL) {
3439 1.1 jonathan const struct sadb_sa *sa0;
3440 1.1 jonathan
3441 1.230 christos sa0 = mhp->ext[SADB_EXT_SA];
3442 1.1 jonathan if (mhp->extlen[SADB_EXT_SA] < sizeof(*sa0)) {
3443 1.1 jonathan error = EINVAL;
3444 1.1 jonathan goto fail;
3445 1.1 jonathan }
3446 1.1 jonathan
3447 1.1 jonathan sav->alg_auth = sa0->sadb_sa_auth;
3448 1.1 jonathan sav->alg_enc = sa0->sadb_sa_encrypt;
3449 1.1 jonathan sav->flags = sa0->sadb_sa_flags;
3450 1.1 jonathan
3451 1.1 jonathan /* replay window */
3452 1.1 jonathan if ((sa0->sadb_sa_flags & SADB_X_EXT_OLD) == 0) {
3453 1.132 ozaki size_t len = sizeof(struct secreplay) +
3454 1.132 ozaki sa0->sadb_sa_replay;
3455 1.132 ozaki sav->replay = kmem_zalloc(len, KM_SLEEP);
3456 1.132 ozaki sav->replay_len = len;
3457 1.1 jonathan if (sa0->sadb_sa_replay != 0)
3458 1.40 degroote sav->replay->bitmap = (char*)(sav->replay+1);
3459 1.1 jonathan sav->replay->wsize = sa0->sadb_sa_replay;
3460 1.1 jonathan }
3461 1.1 jonathan }
3462 1.1 jonathan
3463 1.1 jonathan /* Authentication keys */
3464 1.1 jonathan if (mhp->ext[SADB_EXT_KEY_AUTH] != NULL) {
3465 1.1 jonathan const struct sadb_key *key0;
3466 1.1 jonathan int len;
3467 1.1 jonathan
3468 1.230 christos key0 = mhp->ext[SADB_EXT_KEY_AUTH];
3469 1.1 jonathan len = mhp->extlen[SADB_EXT_KEY_AUTH];
3470 1.1 jonathan
3471 1.1 jonathan error = 0;
3472 1.1 jonathan if (len < sizeof(*key0)) {
3473 1.1 jonathan error = EINVAL;
3474 1.1 jonathan goto fail;
3475 1.1 jonathan }
3476 1.1 jonathan switch (mhp->msg->sadb_msg_satype) {
3477 1.1 jonathan case SADB_SATYPE_AH:
3478 1.1 jonathan case SADB_SATYPE_ESP:
3479 1.12 jonathan case SADB_X_SATYPE_TCPSIGNATURE:
3480 1.1 jonathan if (len == PFKEY_ALIGN8(sizeof(struct sadb_key)) &&
3481 1.1 jonathan sav->alg_auth != SADB_X_AALG_NULL)
3482 1.1 jonathan error = EINVAL;
3483 1.1 jonathan break;
3484 1.1 jonathan case SADB_X_SATYPE_IPCOMP:
3485 1.1 jonathan default:
3486 1.1 jonathan error = EINVAL;
3487 1.1 jonathan break;
3488 1.1 jonathan }
3489 1.1 jonathan if (error) {
3490 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid key_auth values.\n");
3491 1.1 jonathan goto fail;
3492 1.1 jonathan }
3493 1.1 jonathan
3494 1.132 ozaki sav->key_auth = key_newbuf(key0, len);
3495 1.132 ozaki sav->key_auth_len = len;
3496 1.1 jonathan }
3497 1.1 jonathan
3498 1.1 jonathan /* Encryption key */
3499 1.1 jonathan if (mhp->ext[SADB_EXT_KEY_ENCRYPT] != NULL) {
3500 1.1 jonathan const struct sadb_key *key0;
3501 1.1 jonathan int len;
3502 1.1 jonathan
3503 1.230 christos key0 = mhp->ext[SADB_EXT_KEY_ENCRYPT];
3504 1.1 jonathan len = mhp->extlen[SADB_EXT_KEY_ENCRYPT];
3505 1.1 jonathan
3506 1.1 jonathan error = 0;
3507 1.1 jonathan if (len < sizeof(*key0)) {
3508 1.1 jonathan error = EINVAL;
3509 1.1 jonathan goto fail;
3510 1.1 jonathan }
3511 1.1 jonathan switch (mhp->msg->sadb_msg_satype) {
3512 1.1 jonathan case SADB_SATYPE_ESP:
3513 1.1 jonathan if (len == PFKEY_ALIGN8(sizeof(struct sadb_key)) &&
3514 1.1 jonathan sav->alg_enc != SADB_EALG_NULL) {
3515 1.1 jonathan error = EINVAL;
3516 1.1 jonathan break;
3517 1.1 jonathan }
3518 1.132 ozaki sav->key_enc = key_newbuf(key0, len);
3519 1.132 ozaki sav->key_enc_len = len;
3520 1.1 jonathan break;
3521 1.1 jonathan case SADB_X_SATYPE_IPCOMP:
3522 1.1 jonathan if (len != PFKEY_ALIGN8(sizeof(struct sadb_key)))
3523 1.1 jonathan error = EINVAL;
3524 1.1 jonathan sav->key_enc = NULL; /*just in case*/
3525 1.1 jonathan break;
3526 1.1 jonathan case SADB_SATYPE_AH:
3527 1.12 jonathan case SADB_X_SATYPE_TCPSIGNATURE:
3528 1.1 jonathan default:
3529 1.1 jonathan error = EINVAL;
3530 1.1 jonathan break;
3531 1.1 jonathan }
3532 1.1 jonathan if (error) {
3533 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid key_enc value.\n");
3534 1.1 jonathan goto fail;
3535 1.1 jonathan }
3536 1.1 jonathan }
3537 1.1 jonathan
3538 1.1 jonathan /* set iv */
3539 1.1 jonathan sav->ivlen = 0;
3540 1.1 jonathan
3541 1.1 jonathan switch (mhp->msg->sadb_msg_satype) {
3542 1.1 jonathan case SADB_SATYPE_AH:
3543 1.1 jonathan error = xform_init(sav, XF_AH);
3544 1.1 jonathan break;
3545 1.1 jonathan case SADB_SATYPE_ESP:
3546 1.1 jonathan error = xform_init(sav, XF_ESP);
3547 1.1 jonathan break;
3548 1.1 jonathan case SADB_X_SATYPE_IPCOMP:
3549 1.1 jonathan error = xform_init(sav, XF_IPCOMP);
3550 1.1 jonathan break;
3551 1.12 jonathan case SADB_X_SATYPE_TCPSIGNATURE:
3552 1.12 jonathan error = xform_init(sav, XF_TCPSIGNATURE);
3553 1.12 jonathan break;
3554 1.1 jonathan }
3555 1.1 jonathan if (error) {
3556 1.134 ozaki IPSECLOG(LOG_DEBUG, "unable to initialize SA type %u.\n",
3557 1.134 ozaki mhp->msg->sadb_msg_satype);
3558 1.1 jonathan goto fail;
3559 1.1 jonathan }
3560 1.1 jonathan
3561 1.1 jonathan /* reset created */
3562 1.69 drochner sav->created = time_uptime;
3563 1.1 jonathan
3564 1.1 jonathan /* make lifetime for CURRENT */
3565 1.127 ozaki sav->lft_c = kmem_alloc(sizeof(struct sadb_lifetime), KM_SLEEP);
3566 1.1 jonathan
3567 1.1 jonathan sav->lft_c->sadb_lifetime_len =
3568 1.1 jonathan PFKEY_UNIT64(sizeof(struct sadb_lifetime));
3569 1.1 jonathan sav->lft_c->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
3570 1.1 jonathan sav->lft_c->sadb_lifetime_allocations = 0;
3571 1.1 jonathan sav->lft_c->sadb_lifetime_bytes = 0;
3572 1.69 drochner sav->lft_c->sadb_lifetime_addtime = time_uptime;
3573 1.1 jonathan sav->lft_c->sadb_lifetime_usetime = 0;
3574 1.1 jonathan
3575 1.1 jonathan /* lifetimes for HARD and SOFT */
3576 1.1 jonathan {
3577 1.1 jonathan const struct sadb_lifetime *lft0;
3578 1.1 jonathan
3579 1.230 christos lft0 = mhp->ext[SADB_EXT_LIFETIME_HARD];
3580 1.1 jonathan if (lft0 != NULL) {
3581 1.1 jonathan if (mhp->extlen[SADB_EXT_LIFETIME_HARD] < sizeof(*lft0)) {
3582 1.1 jonathan error = EINVAL;
3583 1.1 jonathan goto fail;
3584 1.1 jonathan }
3585 1.132 ozaki sav->lft_h = key_newbuf(lft0, sizeof(*lft0));
3586 1.1 jonathan }
3587 1.1 jonathan
3588 1.230 christos lft0 = mhp->ext[SADB_EXT_LIFETIME_SOFT];
3589 1.1 jonathan if (lft0 != NULL) {
3590 1.1 jonathan if (mhp->extlen[SADB_EXT_LIFETIME_SOFT] < sizeof(*lft0)) {
3591 1.1 jonathan error = EINVAL;
3592 1.1 jonathan goto fail;
3593 1.1 jonathan }
3594 1.132 ozaki sav->lft_s = key_newbuf(lft0, sizeof(*lft0));
3595 1.1 jonathan /* to be initialize ? */
3596 1.1 jonathan }
3597 1.1 jonathan }
3598 1.1 jonathan
3599 1.1 jonathan return 0;
3600 1.1 jonathan
3601 1.1 jonathan fail:
3602 1.169 ozaki key_clear_xform(sav);
3603 1.131 ozaki key_freesaval(sav);
3604 1.1 jonathan
3605 1.1 jonathan return error;
3606 1.1 jonathan }
3607 1.1 jonathan
3608 1.1 jonathan /*
3609 1.1 jonathan * validation with a secasvar entry, and set SADB_SATYPE_MATURE.
3610 1.1 jonathan * OUT: 0: valid
3611 1.1 jonathan * other: errno
3612 1.1 jonathan */
3613 1.1 jonathan static int
3614 1.171 ozaki key_init_xform(struct secasvar *sav)
3615 1.1 jonathan {
3616 1.1 jonathan int error;
3617 1.1 jonathan
3618 1.171 ozaki /* We shouldn't initialize sav variables while someone uses it. */
3619 1.217 ozaki KASSERT(key_sa_refcnt(sav) == 0);
3620 1.171 ozaki
3621 1.1 jonathan /* check SPI value */
3622 1.1 jonathan switch (sav->sah->saidx.proto) {
3623 1.1 jonathan case IPPROTO_ESP:
3624 1.1 jonathan case IPPROTO_AH:
3625 1.29 christos if (ntohl(sav->spi) <= 255) {
3626 1.134 ozaki IPSECLOG(LOG_DEBUG, "illegal range of SPI %u.\n",
3627 1.134 ozaki (u_int32_t)ntohl(sav->spi));
3628 1.1 jonathan return EINVAL;
3629 1.1 jonathan }
3630 1.1 jonathan break;
3631 1.1 jonathan }
3632 1.1 jonathan
3633 1.1 jonathan /* check satype */
3634 1.1 jonathan switch (sav->sah->saidx.proto) {
3635 1.1 jonathan case IPPROTO_ESP:
3636 1.1 jonathan /* check flags */
3637 1.1 jonathan if ((sav->flags & (SADB_X_EXT_OLD|SADB_X_EXT_DERIV)) ==
3638 1.1 jonathan (SADB_X_EXT_OLD|SADB_X_EXT_DERIV)) {
3639 1.134 ozaki IPSECLOG(LOG_DEBUG,
3640 1.134 ozaki "invalid flag (derived) given to old-esp.\n");
3641 1.1 jonathan return EINVAL;
3642 1.1 jonathan }
3643 1.1 jonathan error = xform_init(sav, XF_ESP);
3644 1.1 jonathan break;
3645 1.1 jonathan case IPPROTO_AH:
3646 1.1 jonathan /* check flags */
3647 1.1 jonathan if (sav->flags & SADB_X_EXT_DERIV) {
3648 1.134 ozaki IPSECLOG(LOG_DEBUG,
3649 1.134 ozaki "invalid flag (derived) given to AH SA.\n");
3650 1.1 jonathan return EINVAL;
3651 1.1 jonathan }
3652 1.1 jonathan if (sav->alg_enc != SADB_EALG_NONE) {
3653 1.134 ozaki IPSECLOG(LOG_DEBUG,
3654 1.134 ozaki "protocol and algorithm mismated.\n");
3655 1.1 jonathan return(EINVAL);
3656 1.1 jonathan }
3657 1.1 jonathan error = xform_init(sav, XF_AH);
3658 1.1 jonathan break;
3659 1.1 jonathan case IPPROTO_IPCOMP:
3660 1.1 jonathan if (sav->alg_auth != SADB_AALG_NONE) {
3661 1.134 ozaki IPSECLOG(LOG_DEBUG,
3662 1.134 ozaki "protocol and algorithm mismated.\n");
3663 1.1 jonathan return(EINVAL);
3664 1.1 jonathan }
3665 1.1 jonathan if ((sav->flags & SADB_X_EXT_RAWCPI) == 0
3666 1.1 jonathan && ntohl(sav->spi) >= 0x10000) {
3667 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid cpi for IPComp.\n");
3668 1.1 jonathan return(EINVAL);
3669 1.1 jonathan }
3670 1.1 jonathan error = xform_init(sav, XF_IPCOMP);
3671 1.1 jonathan break;
3672 1.12 jonathan case IPPROTO_TCP:
3673 1.12 jonathan if (sav->alg_enc != SADB_EALG_NONE) {
3674 1.134 ozaki IPSECLOG(LOG_DEBUG,
3675 1.134 ozaki "protocol and algorithm mismated.\n");
3676 1.12 jonathan return(EINVAL);
3677 1.12 jonathan }
3678 1.12 jonathan error = xform_init(sav, XF_TCPSIGNATURE);
3679 1.12 jonathan break;
3680 1.1 jonathan default:
3681 1.134 ozaki IPSECLOG(LOG_DEBUG, "Invalid satype.\n");
3682 1.1 jonathan error = EPROTONOSUPPORT;
3683 1.1 jonathan break;
3684 1.1 jonathan }
3685 1.171 ozaki
3686 1.171 ozaki return error;
3687 1.1 jonathan }
3688 1.1 jonathan
3689 1.1 jonathan /*
3690 1.1 jonathan * subroutine for SADB_GET and SADB_DUMP.
3691 1.1 jonathan */
3692 1.1 jonathan static struct mbuf *
3693 1.49 degroote key_setdumpsa(struct secasvar *sav, u_int8_t type, u_int8_t satype,
3694 1.49 degroote u_int32_t seq, u_int32_t pid)
3695 1.1 jonathan {
3696 1.1 jonathan struct mbuf *result = NULL, *tres = NULL, *m;
3697 1.1 jonathan int l = 0;
3698 1.1 jonathan int i;
3699 1.1 jonathan void *p;
3700 1.69 drochner struct sadb_lifetime lt;
3701 1.1 jonathan int dumporder[] = {
3702 1.1 jonathan SADB_EXT_SA, SADB_X_EXT_SA2,
3703 1.1 jonathan SADB_EXT_LIFETIME_HARD, SADB_EXT_LIFETIME_SOFT,
3704 1.1 jonathan SADB_EXT_LIFETIME_CURRENT, SADB_EXT_ADDRESS_SRC,
3705 1.1 jonathan SADB_EXT_ADDRESS_DST, SADB_EXT_ADDRESS_PROXY, SADB_EXT_KEY_AUTH,
3706 1.1 jonathan SADB_EXT_KEY_ENCRYPT, SADB_EXT_IDENTITY_SRC,
3707 1.1 jonathan SADB_EXT_IDENTITY_DST, SADB_EXT_SENSITIVITY,
3708 1.64 spz SADB_X_EXT_NAT_T_TYPE,
3709 1.64 spz SADB_X_EXT_NAT_T_SPORT, SADB_X_EXT_NAT_T_DPORT,
3710 1.64 spz SADB_X_EXT_NAT_T_OAI, SADB_X_EXT_NAT_T_OAR,
3711 1.48 degroote SADB_X_EXT_NAT_T_FRAG,
3712 1.48 degroote
3713 1.1 jonathan };
3714 1.1 jonathan
3715 1.239 ozaki m = key_setsadbmsg(type, 0, satype, seq, pid, key_sa_refcnt(sav), M_WAITOK);
3716 1.1 jonathan result = m;
3717 1.1 jonathan
3718 1.140 ozaki for (i = __arraycount(dumporder) - 1; i >= 0; i--) {
3719 1.1 jonathan m = NULL;
3720 1.1 jonathan p = NULL;
3721 1.1 jonathan switch (dumporder[i]) {
3722 1.1 jonathan case SADB_EXT_SA:
3723 1.1 jonathan m = key_setsadbsa(sav);
3724 1.1 jonathan break;
3725 1.1 jonathan
3726 1.1 jonathan case SADB_X_EXT_SA2:
3727 1.1 jonathan m = key_setsadbxsa2(sav->sah->saidx.mode,
3728 1.137 ozaki sav->replay ? sav->replay->count : 0,
3729 1.137 ozaki sav->sah->saidx.reqid);
3730 1.1 jonathan break;
3731 1.1 jonathan
3732 1.1 jonathan case SADB_EXT_ADDRESS_SRC:
3733 1.1 jonathan m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
3734 1.1 jonathan &sav->sah->saidx.src.sa,
3735 1.239 ozaki FULLMASK, IPSEC_ULPROTO_ANY, M_WAITOK);
3736 1.1 jonathan break;
3737 1.1 jonathan
3738 1.1 jonathan case SADB_EXT_ADDRESS_DST:
3739 1.1 jonathan m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
3740 1.1 jonathan &sav->sah->saidx.dst.sa,
3741 1.239 ozaki FULLMASK, IPSEC_ULPROTO_ANY, M_WAITOK);
3742 1.1 jonathan break;
3743 1.1 jonathan
3744 1.1 jonathan case SADB_EXT_KEY_AUTH:
3745 1.1 jonathan if (!sav->key_auth)
3746 1.1 jonathan continue;
3747 1.1 jonathan l = PFKEY_UNUNIT64(sav->key_auth->sadb_key_len);
3748 1.1 jonathan p = sav->key_auth;
3749 1.1 jonathan break;
3750 1.1 jonathan
3751 1.1 jonathan case SADB_EXT_KEY_ENCRYPT:
3752 1.1 jonathan if (!sav->key_enc)
3753 1.1 jonathan continue;
3754 1.1 jonathan l = PFKEY_UNUNIT64(sav->key_enc->sadb_key_len);
3755 1.1 jonathan p = sav->key_enc;
3756 1.1 jonathan break;
3757 1.1 jonathan
3758 1.1 jonathan case SADB_EXT_LIFETIME_CURRENT:
3759 1.178 ozaki KASSERT(sav->lft_c != NULL);
3760 1.1 jonathan l = PFKEY_UNUNIT64(((struct sadb_ext *)sav->lft_c)->sadb_ext_len);
3761 1.69 drochner memcpy(<, sav->lft_c, sizeof(struct sadb_lifetime));
3762 1.175 ozaki lt.sadb_lifetime_addtime =
3763 1.175 ozaki time_mono_to_wall(lt.sadb_lifetime_addtime);
3764 1.175 ozaki lt.sadb_lifetime_usetime =
3765 1.175 ozaki time_mono_to_wall(lt.sadb_lifetime_usetime);
3766 1.69 drochner p = <
3767 1.1 jonathan break;
3768 1.1 jonathan
3769 1.1 jonathan case SADB_EXT_LIFETIME_HARD:
3770 1.1 jonathan if (!sav->lft_h)
3771 1.1 jonathan continue;
3772 1.1 jonathan l = PFKEY_UNUNIT64(((struct sadb_ext *)sav->lft_h)->sadb_ext_len);
3773 1.1 jonathan p = sav->lft_h;
3774 1.1 jonathan break;
3775 1.1 jonathan
3776 1.1 jonathan case SADB_EXT_LIFETIME_SOFT:
3777 1.1 jonathan if (!sav->lft_s)
3778 1.1 jonathan continue;
3779 1.1 jonathan l = PFKEY_UNUNIT64(((struct sadb_ext *)sav->lft_s)->sadb_ext_len);
3780 1.1 jonathan p = sav->lft_s;
3781 1.1 jonathan break;
3782 1.1 jonathan
3783 1.48 degroote case SADB_X_EXT_NAT_T_TYPE:
3784 1.68 drochner m = key_setsadbxtype(sav->natt_type);
3785 1.48 degroote break;
3786 1.79 gdt
3787 1.48 degroote case SADB_X_EXT_NAT_T_DPORT:
3788 1.68 drochner if (sav->natt_type == 0)
3789 1.68 drochner continue;
3790 1.68 drochner m = key_setsadbxport(
3791 1.137 ozaki key_portfromsaddr(&sav->sah->saidx.dst),
3792 1.137 ozaki SADB_X_EXT_NAT_T_DPORT);
3793 1.48 degroote break;
3794 1.48 degroote
3795 1.48 degroote case SADB_X_EXT_NAT_T_SPORT:
3796 1.68 drochner if (sav->natt_type == 0)
3797 1.68 drochner continue;
3798 1.68 drochner m = key_setsadbxport(
3799 1.137 ozaki key_portfromsaddr(&sav->sah->saidx.src),
3800 1.137 ozaki SADB_X_EXT_NAT_T_SPORT);
3801 1.48 degroote break;
3802 1.48 degroote
3803 1.76 drochner case SADB_X_EXT_NAT_T_FRAG:
3804 1.76 drochner /* don't send frag info if not set */
3805 1.76 drochner if (sav->natt_type == 0 || sav->esp_frag == IP_MAXPACKET)
3806 1.76 drochner continue;
3807 1.76 drochner m = key_setsadbxfrag(sav->esp_frag);
3808 1.76 drochner break;
3809 1.76 drochner
3810 1.64 spz case SADB_X_EXT_NAT_T_OAI:
3811 1.64 spz case SADB_X_EXT_NAT_T_OAR:
3812 1.48 degroote continue;
3813 1.48 degroote
3814 1.1 jonathan case SADB_EXT_ADDRESS_PROXY:
3815 1.1 jonathan case SADB_EXT_IDENTITY_SRC:
3816 1.1 jonathan case SADB_EXT_IDENTITY_DST:
3817 1.1 jonathan /* XXX: should we brought from SPD ? */
3818 1.1 jonathan case SADB_EXT_SENSITIVITY:
3819 1.1 jonathan default:
3820 1.1 jonathan continue;
3821 1.1 jonathan }
3822 1.1 jonathan
3823 1.68 drochner KASSERT(!(m && p));
3824 1.68 drochner if (!m && !p)
3825 1.1 jonathan goto fail;
3826 1.1 jonathan if (p && tres) {
3827 1.239 ozaki M_PREPEND(tres, l, M_WAITOK);
3828 1.49 degroote memcpy(mtod(tres, void *), p, l);
3829 1.1 jonathan continue;
3830 1.1 jonathan }
3831 1.1 jonathan if (p) {
3832 1.239 ozaki m = key_alloc_mbuf(l, M_WAITOK);
3833 1.1 jonathan m_copyback(m, 0, l, p);
3834 1.1 jonathan }
3835 1.1 jonathan
3836 1.1 jonathan if (tres)
3837 1.1 jonathan m_cat(m, tres);
3838 1.1 jonathan tres = m;
3839 1.1 jonathan }
3840 1.1 jonathan
3841 1.1 jonathan m_cat(result, tres);
3842 1.68 drochner tres = NULL; /* avoid free on error below */
3843 1.1 jonathan
3844 1.1 jonathan if (result->m_len < sizeof(struct sadb_msg)) {
3845 1.1 jonathan result = m_pullup(result, sizeof(struct sadb_msg));
3846 1.1 jonathan if (result == NULL)
3847 1.1 jonathan goto fail;
3848 1.1 jonathan }
3849 1.1 jonathan
3850 1.1 jonathan result->m_pkthdr.len = 0;
3851 1.1 jonathan for (m = result; m; m = m->m_next)
3852 1.1 jonathan result->m_pkthdr.len += m->m_len;
3853 1.1 jonathan
3854 1.1 jonathan mtod(result, struct sadb_msg *)->sadb_msg_len =
3855 1.1 jonathan PFKEY_UNIT64(result->m_pkthdr.len);
3856 1.1 jonathan
3857 1.1 jonathan return result;
3858 1.1 jonathan
3859 1.1 jonathan fail:
3860 1.1 jonathan m_freem(result);
3861 1.1 jonathan m_freem(tres);
3862 1.1 jonathan return NULL;
3863 1.1 jonathan }
3864 1.1 jonathan
3865 1.48 degroote
3866 1.48 degroote /*
3867 1.48 degroote * set a type in sadb_x_nat_t_type
3868 1.48 degroote */
3869 1.48 degroote static struct mbuf *
3870 1.49 degroote key_setsadbxtype(u_int16_t type)
3871 1.48 degroote {
3872 1.48 degroote struct mbuf *m;
3873 1.48 degroote size_t len;
3874 1.48 degroote struct sadb_x_nat_t_type *p;
3875 1.48 degroote
3876 1.48 degroote len = PFKEY_ALIGN8(sizeof(struct sadb_x_nat_t_type));
3877 1.48 degroote
3878 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
3879 1.240 ozaki KASSERT(m->m_next == NULL);
3880 1.48 degroote
3881 1.48 degroote p = mtod(m, struct sadb_x_nat_t_type *);
3882 1.48 degroote
3883 1.49 degroote memset(p, 0, len);
3884 1.48 degroote p->sadb_x_nat_t_type_len = PFKEY_UNIT64(len);
3885 1.48 degroote p->sadb_x_nat_t_type_exttype = SADB_X_EXT_NAT_T_TYPE;
3886 1.48 degroote p->sadb_x_nat_t_type_type = type;
3887 1.48 degroote
3888 1.48 degroote return m;
3889 1.48 degroote }
3890 1.48 degroote /*
3891 1.48 degroote * set a port in sadb_x_nat_t_port. port is in network order
3892 1.48 degroote */
3893 1.48 degroote static struct mbuf *
3894 1.49 degroote key_setsadbxport(u_int16_t port, u_int16_t type)
3895 1.48 degroote {
3896 1.48 degroote struct mbuf *m;
3897 1.48 degroote size_t len;
3898 1.48 degroote struct sadb_x_nat_t_port *p;
3899 1.48 degroote
3900 1.48 degroote len = PFKEY_ALIGN8(sizeof(struct sadb_x_nat_t_port));
3901 1.48 degroote
3902 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
3903 1.240 ozaki KASSERT(m->m_next == NULL);
3904 1.48 degroote
3905 1.48 degroote p = mtod(m, struct sadb_x_nat_t_port *);
3906 1.48 degroote
3907 1.49 degroote memset(p, 0, len);
3908 1.48 degroote p->sadb_x_nat_t_port_len = PFKEY_UNIT64(len);
3909 1.48 degroote p->sadb_x_nat_t_port_exttype = type;
3910 1.48 degroote p->sadb_x_nat_t_port_port = port;
3911 1.48 degroote
3912 1.48 degroote return m;
3913 1.48 degroote }
3914 1.48 degroote
3915 1.76 drochner /*
3916 1.76 drochner * set fragmentation info in sadb_x_nat_t_frag
3917 1.76 drochner */
3918 1.76 drochner static struct mbuf *
3919 1.76 drochner key_setsadbxfrag(u_int16_t flen)
3920 1.76 drochner {
3921 1.76 drochner struct mbuf *m;
3922 1.76 drochner size_t len;
3923 1.76 drochner struct sadb_x_nat_t_frag *p;
3924 1.76 drochner
3925 1.76 drochner len = PFKEY_ALIGN8(sizeof(struct sadb_x_nat_t_frag));
3926 1.76 drochner
3927 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
3928 1.240 ozaki KASSERT(m->m_next == NULL);
3929 1.76 drochner
3930 1.76 drochner p = mtod(m, struct sadb_x_nat_t_frag *);
3931 1.76 drochner
3932 1.76 drochner memset(p, 0, len);
3933 1.76 drochner p->sadb_x_nat_t_frag_len = PFKEY_UNIT64(len);
3934 1.76 drochner p->sadb_x_nat_t_frag_exttype = SADB_X_EXT_NAT_T_FRAG;
3935 1.76 drochner p->sadb_x_nat_t_frag_fraglen = flen;
3936 1.76 drochner
3937 1.76 drochner return m;
3938 1.76 drochner }
3939 1.76 drochner
3940 1.79 gdt /*
3941 1.48 degroote * Get port from sockaddr, port is in network order
3942 1.48 degroote */
3943 1.79 gdt u_int16_t
3944 1.49 degroote key_portfromsaddr(const union sockaddr_union *saddr)
3945 1.48 degroote {
3946 1.48 degroote u_int16_t port;
3947 1.48 degroote
3948 1.48 degroote switch (saddr->sa.sa_family) {
3949 1.48 degroote case AF_INET: {
3950 1.48 degroote port = saddr->sin.sin_port;
3951 1.48 degroote break;
3952 1.48 degroote }
3953 1.48 degroote #ifdef INET6
3954 1.48 degroote case AF_INET6: {
3955 1.48 degroote port = saddr->sin6.sin6_port;
3956 1.48 degroote break;
3957 1.48 degroote }
3958 1.48 degroote #endif
3959 1.48 degroote default:
3960 1.83 christos printf("%s: unexpected address family\n", __func__);
3961 1.48 degroote port = 0;
3962 1.48 degroote break;
3963 1.48 degroote }
3964 1.48 degroote
3965 1.48 degroote return port;
3966 1.48 degroote }
3967 1.48 degroote
3968 1.48 degroote
3969 1.48 degroote /*
3970 1.48 degroote * Set port is struct sockaddr. port is in network order
3971 1.48 degroote */
3972 1.48 degroote static void
3973 1.49 degroote key_porttosaddr(union sockaddr_union *saddr, u_int16_t port)
3974 1.48 degroote {
3975 1.48 degroote switch (saddr->sa.sa_family) {
3976 1.48 degroote case AF_INET: {
3977 1.48 degroote saddr->sin.sin_port = port;
3978 1.48 degroote break;
3979 1.48 degroote }
3980 1.48 degroote #ifdef INET6
3981 1.48 degroote case AF_INET6: {
3982 1.48 degroote saddr->sin6.sin6_port = port;
3983 1.48 degroote break;
3984 1.48 degroote }
3985 1.48 degroote #endif
3986 1.48 degroote default:
3987 1.83 christos printf("%s: unexpected address family %d\n", __func__,
3988 1.83 christos saddr->sa.sa_family);
3989 1.48 degroote break;
3990 1.48 degroote }
3991 1.48 degroote
3992 1.48 degroote return;
3993 1.48 degroote }
3994 1.48 degroote
3995 1.48 degroote /*
3996 1.79 gdt * Safety check sa_len
3997 1.48 degroote */
3998 1.48 degroote static int
3999 1.49 degroote key_checksalen(const union sockaddr_union *saddr)
4000 1.48 degroote {
4001 1.118 ozaki switch (saddr->sa.sa_family) {
4002 1.118 ozaki case AF_INET:
4003 1.118 ozaki if (saddr->sa.sa_len != sizeof(struct sockaddr_in))
4004 1.118 ozaki return -1;
4005 1.118 ozaki break;
4006 1.48 degroote #ifdef INET6
4007 1.118 ozaki case AF_INET6:
4008 1.118 ozaki if (saddr->sa.sa_len != sizeof(struct sockaddr_in6))
4009 1.118 ozaki return -1;
4010 1.118 ozaki break;
4011 1.118 ozaki #endif
4012 1.118 ozaki default:
4013 1.118 ozaki printf("%s: unexpected sa_family %d\n", __func__,
4014 1.118 ozaki saddr->sa.sa_family);
4015 1.118 ozaki return -1;
4016 1.118 ozaki break;
4017 1.118 ozaki }
4018 1.48 degroote return 0;
4019 1.48 degroote }
4020 1.48 degroote
4021 1.48 degroote
4022 1.1 jonathan /*
4023 1.1 jonathan * set data into sadb_msg.
4024 1.1 jonathan */
4025 1.1 jonathan static struct mbuf *
4026 1.49 degroote key_setsadbmsg(u_int8_t type, u_int16_t tlen, u_int8_t satype,
4027 1.239 ozaki u_int32_t seq, pid_t pid, u_int16_t reserved, int mflag)
4028 1.1 jonathan {
4029 1.1 jonathan struct mbuf *m;
4030 1.1 jonathan struct sadb_msg *p;
4031 1.1 jonathan int len;
4032 1.1 jonathan
4033 1.157 ozaki CTASSERT(PFKEY_ALIGN8(sizeof(struct sadb_msg)) <= MCLBYTES);
4034 1.157 ozaki
4035 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
4036 1.157 ozaki
4037 1.239 ozaki m = key_alloc_mbuf_simple(len, mflag);
4038 1.1 jonathan if (!m)
4039 1.1 jonathan return NULL;
4040 1.1 jonathan m->m_pkthdr.len = m->m_len = len;
4041 1.1 jonathan m->m_next = NULL;
4042 1.1 jonathan
4043 1.1 jonathan p = mtod(m, struct sadb_msg *);
4044 1.1 jonathan
4045 1.49 degroote memset(p, 0, len);
4046 1.1 jonathan p->sadb_msg_version = PF_KEY_V2;
4047 1.1 jonathan p->sadb_msg_type = type;
4048 1.1 jonathan p->sadb_msg_errno = 0;
4049 1.1 jonathan p->sadb_msg_satype = satype;
4050 1.1 jonathan p->sadb_msg_len = PFKEY_UNIT64(tlen);
4051 1.1 jonathan p->sadb_msg_reserved = reserved;
4052 1.1 jonathan p->sadb_msg_seq = seq;
4053 1.1 jonathan p->sadb_msg_pid = (u_int32_t)pid;
4054 1.1 jonathan
4055 1.1 jonathan return m;
4056 1.1 jonathan }
4057 1.1 jonathan
4058 1.1 jonathan /*
4059 1.1 jonathan * copy secasvar data into sadb_address.
4060 1.1 jonathan */
4061 1.1 jonathan static struct mbuf *
4062 1.49 degroote key_setsadbsa(struct secasvar *sav)
4063 1.1 jonathan {
4064 1.1 jonathan struct mbuf *m;
4065 1.1 jonathan struct sadb_sa *p;
4066 1.1 jonathan int len;
4067 1.1 jonathan
4068 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_sa));
4069 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
4070 1.240 ozaki KASSERT(m->m_next == NULL);
4071 1.1 jonathan
4072 1.1 jonathan p = mtod(m, struct sadb_sa *);
4073 1.1 jonathan
4074 1.49 degroote memset(p, 0, len);
4075 1.1 jonathan p->sadb_sa_len = PFKEY_UNIT64(len);
4076 1.1 jonathan p->sadb_sa_exttype = SADB_EXT_SA;
4077 1.1 jonathan p->sadb_sa_spi = sav->spi;
4078 1.1 jonathan p->sadb_sa_replay = (sav->replay != NULL ? sav->replay->wsize : 0);
4079 1.1 jonathan p->sadb_sa_state = sav->state;
4080 1.1 jonathan p->sadb_sa_auth = sav->alg_auth;
4081 1.1 jonathan p->sadb_sa_encrypt = sav->alg_enc;
4082 1.1 jonathan p->sadb_sa_flags = sav->flags;
4083 1.1 jonathan
4084 1.1 jonathan return m;
4085 1.1 jonathan }
4086 1.1 jonathan
4087 1.1 jonathan /*
4088 1.1 jonathan * set data into sadb_address.
4089 1.1 jonathan */
4090 1.1 jonathan static struct mbuf *
4091 1.49 degroote key_setsadbaddr(u_int16_t exttype, const struct sockaddr *saddr,
4092 1.239 ozaki u_int8_t prefixlen, u_int16_t ul_proto, int mflag)
4093 1.1 jonathan {
4094 1.1 jonathan struct mbuf *m;
4095 1.1 jonathan struct sadb_address *p;
4096 1.1 jonathan size_t len;
4097 1.1 jonathan
4098 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_address)) +
4099 1.1 jonathan PFKEY_ALIGN8(saddr->sa_len);
4100 1.239 ozaki m = key_alloc_mbuf(len, mflag);
4101 1.1 jonathan if (!m || m->m_next) { /*XXX*/
4102 1.1 jonathan if (m)
4103 1.1 jonathan m_freem(m);
4104 1.1 jonathan return NULL;
4105 1.1 jonathan }
4106 1.1 jonathan
4107 1.1 jonathan p = mtod(m, struct sadb_address *);
4108 1.1 jonathan
4109 1.49 degroote memset(p, 0, len);
4110 1.1 jonathan p->sadb_address_len = PFKEY_UNIT64(len);
4111 1.1 jonathan p->sadb_address_exttype = exttype;
4112 1.1 jonathan p->sadb_address_proto = ul_proto;
4113 1.1 jonathan if (prefixlen == FULLMASK) {
4114 1.1 jonathan switch (saddr->sa_family) {
4115 1.1 jonathan case AF_INET:
4116 1.1 jonathan prefixlen = sizeof(struct in_addr) << 3;
4117 1.1 jonathan break;
4118 1.1 jonathan case AF_INET6:
4119 1.1 jonathan prefixlen = sizeof(struct in6_addr) << 3;
4120 1.1 jonathan break;
4121 1.1 jonathan default:
4122 1.1 jonathan ; /*XXX*/
4123 1.1 jonathan }
4124 1.1 jonathan }
4125 1.1 jonathan p->sadb_address_prefixlen = prefixlen;
4126 1.1 jonathan p->sadb_address_reserved = 0;
4127 1.1 jonathan
4128 1.49 degroote memcpy(mtod(m, char *) + PFKEY_ALIGN8(sizeof(struct sadb_address)),
4129 1.137 ozaki saddr, saddr->sa_len);
4130 1.1 jonathan
4131 1.1 jonathan return m;
4132 1.1 jonathan }
4133 1.1 jonathan
4134 1.1 jonathan #if 0
4135 1.1 jonathan /*
4136 1.1 jonathan * set data into sadb_ident.
4137 1.1 jonathan */
4138 1.1 jonathan static struct mbuf *
4139 1.49 degroote key_setsadbident(u_int16_t exttype, u_int16_t idtype,
4140 1.49 degroote void *string, int stringlen, u_int64_t id)
4141 1.1 jonathan {
4142 1.1 jonathan struct mbuf *m;
4143 1.1 jonathan struct sadb_ident *p;
4144 1.1 jonathan size_t len;
4145 1.1 jonathan
4146 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_ident)) + PFKEY_ALIGN8(stringlen);
4147 1.1 jonathan m = key_alloc_mbuf(len);
4148 1.1 jonathan if (!m || m->m_next) { /*XXX*/
4149 1.1 jonathan if (m)
4150 1.1 jonathan m_freem(m);
4151 1.1 jonathan return NULL;
4152 1.1 jonathan }
4153 1.1 jonathan
4154 1.1 jonathan p = mtod(m, struct sadb_ident *);
4155 1.1 jonathan
4156 1.49 degroote memset(p, 0, len);
4157 1.1 jonathan p->sadb_ident_len = PFKEY_UNIT64(len);
4158 1.1 jonathan p->sadb_ident_exttype = exttype;
4159 1.1 jonathan p->sadb_ident_type = idtype;
4160 1.1 jonathan p->sadb_ident_reserved = 0;
4161 1.1 jonathan p->sadb_ident_id = id;
4162 1.1 jonathan
4163 1.49 degroote memcpy(mtod(m, void *) + PFKEY_ALIGN8(sizeof(struct sadb_ident)),
4164 1.49 degroote string, stringlen);
4165 1.1 jonathan
4166 1.1 jonathan return m;
4167 1.1 jonathan }
4168 1.1 jonathan #endif
4169 1.1 jonathan
4170 1.1 jonathan /*
4171 1.1 jonathan * set data into sadb_x_sa2.
4172 1.1 jonathan */
4173 1.1 jonathan static struct mbuf *
4174 1.49 degroote key_setsadbxsa2(u_int8_t mode, u_int32_t seq, u_int16_t reqid)
4175 1.1 jonathan {
4176 1.1 jonathan struct mbuf *m;
4177 1.1 jonathan struct sadb_x_sa2 *p;
4178 1.1 jonathan size_t len;
4179 1.1 jonathan
4180 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_x_sa2));
4181 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
4182 1.240 ozaki KASSERT(m->m_next == NULL);
4183 1.1 jonathan
4184 1.1 jonathan p = mtod(m, struct sadb_x_sa2 *);
4185 1.1 jonathan
4186 1.49 degroote memset(p, 0, len);
4187 1.1 jonathan p->sadb_x_sa2_len = PFKEY_UNIT64(len);
4188 1.1 jonathan p->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
4189 1.1 jonathan p->sadb_x_sa2_mode = mode;
4190 1.1 jonathan p->sadb_x_sa2_reserved1 = 0;
4191 1.1 jonathan p->sadb_x_sa2_reserved2 = 0;
4192 1.1 jonathan p->sadb_x_sa2_sequence = seq;
4193 1.1 jonathan p->sadb_x_sa2_reqid = reqid;
4194 1.1 jonathan
4195 1.1 jonathan return m;
4196 1.1 jonathan }
4197 1.1 jonathan
4198 1.1 jonathan /*
4199 1.1 jonathan * set data into sadb_x_policy
4200 1.1 jonathan */
4201 1.1 jonathan static struct mbuf *
4202 1.239 ozaki key_setsadbxpolicy(const u_int16_t type, const u_int8_t dir, const u_int32_t id,
4203 1.239 ozaki int mflag)
4204 1.1 jonathan {
4205 1.1 jonathan struct mbuf *m;
4206 1.1 jonathan struct sadb_x_policy *p;
4207 1.1 jonathan size_t len;
4208 1.1 jonathan
4209 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_x_policy));
4210 1.239 ozaki m = key_alloc_mbuf(len, mflag);
4211 1.1 jonathan if (!m || m->m_next) { /*XXX*/
4212 1.1 jonathan if (m)
4213 1.1 jonathan m_freem(m);
4214 1.1 jonathan return NULL;
4215 1.1 jonathan }
4216 1.1 jonathan
4217 1.1 jonathan p = mtod(m, struct sadb_x_policy *);
4218 1.1 jonathan
4219 1.49 degroote memset(p, 0, len);
4220 1.1 jonathan p->sadb_x_policy_len = PFKEY_UNIT64(len);
4221 1.1 jonathan p->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
4222 1.1 jonathan p->sadb_x_policy_type = type;
4223 1.1 jonathan p->sadb_x_policy_dir = dir;
4224 1.1 jonathan p->sadb_x_policy_id = id;
4225 1.1 jonathan
4226 1.1 jonathan return m;
4227 1.1 jonathan }
4228 1.1 jonathan
4229 1.1 jonathan /* %%% utilities */
4230 1.1 jonathan /*
4231 1.1 jonathan * copy a buffer into the new buffer allocated.
4232 1.1 jonathan */
4233 1.1 jonathan static void *
4234 1.49 degroote key_newbuf(const void *src, u_int len)
4235 1.1 jonathan {
4236 1.38 christos void *new;
4237 1.1 jonathan
4238 1.132 ozaki new = kmem_alloc(len, KM_SLEEP);
4239 1.49 degroote memcpy(new, src, len);
4240 1.1 jonathan
4241 1.1 jonathan return new;
4242 1.1 jonathan }
4243 1.1 jonathan
4244 1.1 jonathan /* compare my own address
4245 1.1 jonathan * OUT: 1: true, i.e. my address.
4246 1.1 jonathan * 0: false
4247 1.1 jonathan */
4248 1.1 jonathan int
4249 1.66 drochner key_ismyaddr(const struct sockaddr *sa)
4250 1.1 jonathan {
4251 1.1 jonathan #ifdef INET
4252 1.66 drochner const struct sockaddr_in *sin;
4253 1.100 ozaki const struct in_ifaddr *ia;
4254 1.101 ozaki int s;
4255 1.1 jonathan #endif
4256 1.1 jonathan
4257 1.112 ozaki KASSERT(sa != NULL);
4258 1.1 jonathan
4259 1.1 jonathan switch (sa->sa_family) {
4260 1.1 jonathan #ifdef INET
4261 1.1 jonathan case AF_INET:
4262 1.66 drochner sin = (const struct sockaddr_in *)sa;
4263 1.101 ozaki s = pserialize_read_enter();
4264 1.99 ozaki IN_ADDRLIST_READER_FOREACH(ia) {
4265 1.1 jonathan if (sin->sin_family == ia->ia_addr.sin_family &&
4266 1.1 jonathan sin->sin_len == ia->ia_addr.sin_len &&
4267 1.1 jonathan sin->sin_addr.s_addr == ia->ia_addr.sin_addr.s_addr)
4268 1.1 jonathan {
4269 1.101 ozaki pserialize_read_exit(s);
4270 1.1 jonathan return 1;
4271 1.1 jonathan }
4272 1.1 jonathan }
4273 1.101 ozaki pserialize_read_exit(s);
4274 1.1 jonathan break;
4275 1.1 jonathan #endif
4276 1.1 jonathan #ifdef INET6
4277 1.1 jonathan case AF_INET6:
4278 1.66 drochner return key_ismyaddr6((const struct sockaddr_in6 *)sa);
4279 1.1 jonathan #endif
4280 1.1 jonathan }
4281 1.1 jonathan
4282 1.1 jonathan return 0;
4283 1.1 jonathan }
4284 1.1 jonathan
4285 1.1 jonathan #ifdef INET6
4286 1.1 jonathan /*
4287 1.1 jonathan * compare my own address for IPv6.
4288 1.1 jonathan * 1: ours
4289 1.1 jonathan * 0: other
4290 1.1 jonathan * NOTE: derived ip6_input() in KAME. This is necessary to modify more.
4291 1.1 jonathan */
4292 1.1 jonathan #include <netinet6/in6_var.h>
4293 1.1 jonathan
4294 1.1 jonathan static int
4295 1.66 drochner key_ismyaddr6(const struct sockaddr_in6 *sin6)
4296 1.1 jonathan {
4297 1.98 ozaki struct in6_ifaddr *ia;
4298 1.101 ozaki int s;
4299 1.105 ozaki struct psref psref;
4300 1.105 ozaki int bound;
4301 1.105 ozaki int ours = 1;
4302 1.1 jonathan
4303 1.105 ozaki bound = curlwp_bind();
4304 1.101 ozaki s = pserialize_read_enter();
4305 1.98 ozaki IN6_ADDRLIST_READER_FOREACH(ia) {
4306 1.105 ozaki bool ingroup;
4307 1.105 ozaki
4308 1.145 ozaki if (key_sockaddr_match((const struct sockaddr *)&sin6,
4309 1.145 ozaki (const struct sockaddr *)&ia->ia_addr, 0)) {
4310 1.101 ozaki pserialize_read_exit(s);
4311 1.105 ozaki goto ours;
4312 1.101 ozaki }
4313 1.105 ozaki ia6_acquire(ia, &psref);
4314 1.105 ozaki pserialize_read_exit(s);
4315 1.1 jonathan
4316 1.1 jonathan /*
4317 1.1 jonathan * XXX Multicast
4318 1.1 jonathan * XXX why do we care about multlicast here while we don't care
4319 1.1 jonathan * about IPv4 multicast??
4320 1.1 jonathan * XXX scope
4321 1.1 jonathan */
4322 1.105 ozaki ingroup = in6_multi_group(&sin6->sin6_addr, ia->ia_ifp);
4323 1.105 ozaki if (ingroup) {
4324 1.105 ozaki ia6_release(ia, &psref);
4325 1.105 ozaki goto ours;
4326 1.101 ozaki }
4327 1.105 ozaki
4328 1.105 ozaki s = pserialize_read_enter();
4329 1.105 ozaki ia6_release(ia, &psref);
4330 1.1 jonathan }
4331 1.101 ozaki pserialize_read_exit(s);
4332 1.1 jonathan
4333 1.1 jonathan /* loopback, just for safety */
4334 1.1 jonathan if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
4335 1.105 ozaki goto ours;
4336 1.105 ozaki
4337 1.105 ozaki ours = 0;
4338 1.105 ozaki ours:
4339 1.105 ozaki curlwp_bindx(bound);
4340 1.1 jonathan
4341 1.105 ozaki return ours;
4342 1.1 jonathan }
4343 1.1 jonathan #endif /*INET6*/
4344 1.1 jonathan
4345 1.1 jonathan /*
4346 1.1 jonathan * compare two secasindex structure.
4347 1.1 jonathan * flag can specify to compare 2 saidxes.
4348 1.1 jonathan * compare two secasindex structure without both mode and reqid.
4349 1.1 jonathan * don't compare port.
4350 1.22 perry * IN:
4351 1.1 jonathan * saidx0: source, it can be in SAD.
4352 1.1 jonathan * saidx1: object.
4353 1.22 perry * OUT:
4354 1.1 jonathan * 1 : equal
4355 1.1 jonathan * 0 : not equal
4356 1.1 jonathan */
4357 1.1 jonathan static int
4358 1.145 ozaki key_saidx_match(
4359 1.1 jonathan const struct secasindex *saidx0,
4360 1.1 jonathan const struct secasindex *saidx1,
4361 1.1 jonathan int flag)
4362 1.1 jonathan {
4363 1.96 christos int chkport;
4364 1.94 christos const struct sockaddr *sa0src, *sa0dst, *sa1src, *sa1dst;
4365 1.48 degroote
4366 1.161 ozaki KASSERT(saidx0 != NULL);
4367 1.161 ozaki KASSERT(saidx1 != NULL);
4368 1.161 ozaki
4369 1.1 jonathan /* sanity */
4370 1.1 jonathan if (saidx0->proto != saidx1->proto)
4371 1.1 jonathan return 0;
4372 1.1 jonathan
4373 1.1 jonathan if (flag == CMP_EXACTLY) {
4374 1.1 jonathan if (saidx0->mode != saidx1->mode)
4375 1.1 jonathan return 0;
4376 1.1 jonathan if (saidx0->reqid != saidx1->reqid)
4377 1.1 jonathan return 0;
4378 1.49 degroote if (memcmp(&saidx0->src, &saidx1->src, saidx0->src.sa.sa_len) != 0 ||
4379 1.49 degroote memcmp(&saidx0->dst, &saidx1->dst, saidx0->dst.sa.sa_len) != 0)
4380 1.1 jonathan return 0;
4381 1.1 jonathan } else {
4382 1.1 jonathan
4383 1.1 jonathan /* CMP_MODE_REQID, CMP_REQID, CMP_HEAD */
4384 1.137 ozaki if (flag == CMP_MODE_REQID ||flag == CMP_REQID) {
4385 1.1 jonathan /*
4386 1.1 jonathan * If reqid of SPD is non-zero, unique SA is required.
4387 1.1 jonathan * The result must be of same reqid in this case.
4388 1.1 jonathan */
4389 1.1 jonathan if (saidx1->reqid != 0 && saidx0->reqid != saidx1->reqid)
4390 1.1 jonathan return 0;
4391 1.1 jonathan }
4392 1.1 jonathan
4393 1.1 jonathan if (flag == CMP_MODE_REQID) {
4394 1.137 ozaki if (saidx0->mode != IPSEC_MODE_ANY &&
4395 1.137 ozaki saidx0->mode != saidx1->mode)
4396 1.1 jonathan return 0;
4397 1.1 jonathan }
4398 1.1 jonathan
4399 1.48 degroote
4400 1.94 christos sa0src = &saidx0->src.sa;
4401 1.94 christos sa0dst = &saidx0->dst.sa;
4402 1.94 christos sa1src = &saidx1->src.sa;
4403 1.94 christos sa1dst = &saidx1->dst.sa;
4404 1.94 christos /*
4405 1.94 christos * If NAT-T is enabled, check ports for tunnel mode.
4406 1.94 christos * Don't do it for transport mode, as there is no
4407 1.94 christos * port information available in the SP.
4408 1.94 christos * Also don't check ports if they are set to zero
4409 1.94 christos * in the SPD: This means we have a non-generated
4410 1.94 christos * SPD which can't know UDP ports.
4411 1.94 christos */
4412 1.96 christos if (saidx1->mode == IPSEC_MODE_TUNNEL)
4413 1.96 christos chkport = PORT_LOOSE;
4414 1.96 christos else
4415 1.96 christos chkport = PORT_NONE;
4416 1.94 christos
4417 1.145 ozaki if (!key_sockaddr_match(sa0src, sa1src, chkport)) {
4418 1.1 jonathan return 0;
4419 1.1 jonathan }
4420 1.145 ozaki if (!key_sockaddr_match(sa0dst, sa1dst, chkport)) {
4421 1.1 jonathan return 0;
4422 1.1 jonathan }
4423 1.1 jonathan }
4424 1.1 jonathan
4425 1.1 jonathan return 1;
4426 1.1 jonathan }
4427 1.1 jonathan
4428 1.1 jonathan /*
4429 1.1 jonathan * compare two secindex structure exactly.
4430 1.1 jonathan * IN:
4431 1.1 jonathan * spidx0: source, it is often in SPD.
4432 1.1 jonathan * spidx1: object, it is often from PFKEY message.
4433 1.1 jonathan * OUT:
4434 1.1 jonathan * 1 : equal
4435 1.1 jonathan * 0 : not equal
4436 1.1 jonathan */
4437 1.144 ozaki static int
4438 1.145 ozaki key_spidx_match_exactly(
4439 1.66 drochner const struct secpolicyindex *spidx0,
4440 1.66 drochner const struct secpolicyindex *spidx1)
4441 1.1 jonathan {
4442 1.1 jonathan
4443 1.161 ozaki KASSERT(spidx0 != NULL);
4444 1.161 ozaki KASSERT(spidx1 != NULL);
4445 1.1 jonathan
4446 1.161 ozaki /* sanity */
4447 1.137 ozaki if (spidx0->prefs != spidx1->prefs ||
4448 1.137 ozaki spidx0->prefd != spidx1->prefd ||
4449 1.137 ozaki spidx0->ul_proto != spidx1->ul_proto)
4450 1.1 jonathan return 0;
4451 1.1 jonathan
4452 1.145 ozaki return key_sockaddr_match(&spidx0->src.sa, &spidx1->src.sa, PORT_STRICT) &&
4453 1.145 ozaki key_sockaddr_match(&spidx0->dst.sa, &spidx1->dst.sa, PORT_STRICT);
4454 1.1 jonathan }
4455 1.1 jonathan
4456 1.1 jonathan /*
4457 1.1 jonathan * compare two secindex structure with mask.
4458 1.1 jonathan * IN:
4459 1.1 jonathan * spidx0: source, it is often in SPD.
4460 1.1 jonathan * spidx1: object, it is often from IP header.
4461 1.1 jonathan * OUT:
4462 1.1 jonathan * 1 : equal
4463 1.1 jonathan * 0 : not equal
4464 1.1 jonathan */
4465 1.144 ozaki static int
4466 1.145 ozaki key_spidx_match_withmask(
4467 1.66 drochner const struct secpolicyindex *spidx0,
4468 1.66 drochner const struct secpolicyindex *spidx1)
4469 1.1 jonathan {
4470 1.1 jonathan
4471 1.142 ozaki KASSERT(spidx0 != NULL);
4472 1.142 ozaki KASSERT(spidx1 != NULL);
4473 1.1 jonathan
4474 1.1 jonathan if (spidx0->src.sa.sa_family != spidx1->src.sa.sa_family ||
4475 1.1 jonathan spidx0->dst.sa.sa_family != spidx1->dst.sa.sa_family ||
4476 1.1 jonathan spidx0->src.sa.sa_len != spidx1->src.sa.sa_len ||
4477 1.1 jonathan spidx0->dst.sa.sa_len != spidx1->dst.sa.sa_len)
4478 1.1 jonathan return 0;
4479 1.1 jonathan
4480 1.1 jonathan /* if spidx.ul_proto == IPSEC_ULPROTO_ANY, ignore. */
4481 1.137 ozaki if (spidx0->ul_proto != (u_int16_t)IPSEC_ULPROTO_ANY &&
4482 1.137 ozaki spidx0->ul_proto != spidx1->ul_proto)
4483 1.1 jonathan return 0;
4484 1.1 jonathan
4485 1.1 jonathan switch (spidx0->src.sa.sa_family) {
4486 1.1 jonathan case AF_INET:
4487 1.137 ozaki if (spidx0->src.sin.sin_port != IPSEC_PORT_ANY &&
4488 1.137 ozaki spidx0->src.sin.sin_port != spidx1->src.sin.sin_port)
4489 1.1 jonathan return 0;
4490 1.145 ozaki if (!key_bb_match_withmask(&spidx0->src.sin.sin_addr,
4491 1.1 jonathan &spidx1->src.sin.sin_addr, spidx0->prefs))
4492 1.1 jonathan return 0;
4493 1.1 jonathan break;
4494 1.1 jonathan case AF_INET6:
4495 1.137 ozaki if (spidx0->src.sin6.sin6_port != IPSEC_PORT_ANY &&
4496 1.137 ozaki spidx0->src.sin6.sin6_port != spidx1->src.sin6.sin6_port)
4497 1.1 jonathan return 0;
4498 1.1 jonathan /*
4499 1.1 jonathan * scope_id check. if sin6_scope_id is 0, we regard it
4500 1.22 perry * as a wildcard scope, which matches any scope zone ID.
4501 1.1 jonathan */
4502 1.1 jonathan if (spidx0->src.sin6.sin6_scope_id &&
4503 1.1 jonathan spidx1->src.sin6.sin6_scope_id &&
4504 1.1 jonathan spidx0->src.sin6.sin6_scope_id != spidx1->src.sin6.sin6_scope_id)
4505 1.1 jonathan return 0;
4506 1.145 ozaki if (!key_bb_match_withmask(&spidx0->src.sin6.sin6_addr,
4507 1.1 jonathan &spidx1->src.sin6.sin6_addr, spidx0->prefs))
4508 1.1 jonathan return 0;
4509 1.1 jonathan break;
4510 1.1 jonathan default:
4511 1.1 jonathan /* XXX */
4512 1.49 degroote if (memcmp(&spidx0->src, &spidx1->src, spidx0->src.sa.sa_len) != 0)
4513 1.1 jonathan return 0;
4514 1.1 jonathan break;
4515 1.1 jonathan }
4516 1.1 jonathan
4517 1.1 jonathan switch (spidx0->dst.sa.sa_family) {
4518 1.1 jonathan case AF_INET:
4519 1.137 ozaki if (spidx0->dst.sin.sin_port != IPSEC_PORT_ANY &&
4520 1.137 ozaki spidx0->dst.sin.sin_port != spidx1->dst.sin.sin_port)
4521 1.1 jonathan return 0;
4522 1.145 ozaki if (!key_bb_match_withmask(&spidx0->dst.sin.sin_addr,
4523 1.1 jonathan &spidx1->dst.sin.sin_addr, spidx0->prefd))
4524 1.1 jonathan return 0;
4525 1.1 jonathan break;
4526 1.1 jonathan case AF_INET6:
4527 1.137 ozaki if (spidx0->dst.sin6.sin6_port != IPSEC_PORT_ANY &&
4528 1.137 ozaki spidx0->dst.sin6.sin6_port != spidx1->dst.sin6.sin6_port)
4529 1.1 jonathan return 0;
4530 1.1 jonathan /*
4531 1.1 jonathan * scope_id check. if sin6_scope_id is 0, we regard it
4532 1.22 perry * as a wildcard scope, which matches any scope zone ID.
4533 1.1 jonathan */
4534 1.1 jonathan if (spidx0->src.sin6.sin6_scope_id &&
4535 1.1 jonathan spidx1->src.sin6.sin6_scope_id &&
4536 1.1 jonathan spidx0->dst.sin6.sin6_scope_id != spidx1->dst.sin6.sin6_scope_id)
4537 1.1 jonathan return 0;
4538 1.145 ozaki if (!key_bb_match_withmask(&spidx0->dst.sin6.sin6_addr,
4539 1.1 jonathan &spidx1->dst.sin6.sin6_addr, spidx0->prefd))
4540 1.1 jonathan return 0;
4541 1.1 jonathan break;
4542 1.1 jonathan default:
4543 1.1 jonathan /* XXX */
4544 1.49 degroote if (memcmp(&spidx0->dst, &spidx1->dst, spidx0->dst.sa.sa_len) != 0)
4545 1.1 jonathan return 0;
4546 1.1 jonathan break;
4547 1.1 jonathan }
4548 1.1 jonathan
4549 1.1 jonathan /* XXX Do we check other field ? e.g. flowinfo */
4550 1.1 jonathan
4551 1.1 jonathan return 1;
4552 1.1 jonathan }
4553 1.1 jonathan
4554 1.1 jonathan /* returns 0 on match */
4555 1.1 jonathan static int
4556 1.96 christos key_portcomp(in_port_t port1, in_port_t port2, int howport)
4557 1.96 christos {
4558 1.96 christos switch (howport) {
4559 1.96 christos case PORT_NONE:
4560 1.96 christos return 0;
4561 1.96 christos case PORT_LOOSE:
4562 1.96 christos if (port1 == 0 || port2 == 0)
4563 1.96 christos return 0;
4564 1.96 christos /*FALLTHROUGH*/
4565 1.96 christos case PORT_STRICT:
4566 1.96 christos if (port1 != port2) {
4567 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
4568 1.111 ozaki "port fail %d != %d\n", port1, port2);
4569 1.96 christos return 1;
4570 1.96 christos }
4571 1.96 christos return 0;
4572 1.96 christos default:
4573 1.96 christos KASSERT(0);
4574 1.96 christos return 1;
4575 1.96 christos }
4576 1.96 christos }
4577 1.96 christos
4578 1.145 ozaki /* returns 1 on match */
4579 1.96 christos static int
4580 1.145 ozaki key_sockaddr_match(
4581 1.1 jonathan const struct sockaddr *sa1,
4582 1.1 jonathan const struct sockaddr *sa2,
4583 1.96 christos int howport)
4584 1.1 jonathan {
4585 1.96 christos const struct sockaddr_in *sin1, *sin2;
4586 1.96 christos const struct sockaddr_in6 *sin61, *sin62;
4587 1.229 christos char s1[IPSEC_ADDRSTRLEN], s2[IPSEC_ADDRSTRLEN];
4588 1.96 christos
4589 1.92 christos if (sa1->sa_family != sa2->sa_family || sa1->sa_len != sa2->sa_len) {
4590 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
4591 1.111 ozaki "fam/len fail %d != %d || %d != %d\n",
4592 1.92 christos sa1->sa_family, sa2->sa_family, sa1->sa_len,
4593 1.111 ozaki sa2->sa_len);
4594 1.145 ozaki return 0;
4595 1.92 christos }
4596 1.1 jonathan
4597 1.1 jonathan switch (sa1->sa_family) {
4598 1.1 jonathan case AF_INET:
4599 1.92 christos if (sa1->sa_len != sizeof(struct sockaddr_in)) {
4600 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
4601 1.111 ozaki "len fail %d != %zu\n",
4602 1.111 ozaki sa1->sa_len, sizeof(struct sockaddr_in));
4603 1.145 ozaki return 0;
4604 1.92 christos }
4605 1.96 christos sin1 = (const struct sockaddr_in *)sa1;
4606 1.96 christos sin2 = (const struct sockaddr_in *)sa2;
4607 1.96 christos if (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) {
4608 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
4609 1.229 christos "addr fail %s != %s\n",
4610 1.229 christos (in_print(s1, sizeof(s1), &sin1->sin_addr), s1),
4611 1.229 christos (in_print(s2, sizeof(s2), &sin2->sin_addr), s2));
4612 1.145 ozaki return 0;
4613 1.1 jonathan }
4614 1.96 christos if (key_portcomp(sin1->sin_port, sin2->sin_port, howport)) {
4615 1.145 ozaki return 0;
4616 1.92 christos }
4617 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_MATCH,
4618 1.229 christos "addr success %s[%d] == %s[%d]\n",
4619 1.229 christos (in_print(s1, sizeof(s1), &sin1->sin_addr), s1),
4620 1.229 christos sin1->sin_port,
4621 1.229 christos (in_print(s2, sizeof(s2), &sin2->sin_addr), s2),
4622 1.229 christos sin2->sin_port);
4623 1.1 jonathan break;
4624 1.1 jonathan case AF_INET6:
4625 1.96 christos sin61 = (const struct sockaddr_in6 *)sa1;
4626 1.96 christos sin62 = (const struct sockaddr_in6 *)sa2;
4627 1.1 jonathan if (sa1->sa_len != sizeof(struct sockaddr_in6))
4628 1.145 ozaki return 0; /*EINVAL*/
4629 1.96 christos
4630 1.96 christos if (sin61->sin6_scope_id != sin62->sin6_scope_id) {
4631 1.145 ozaki return 0;
4632 1.1 jonathan }
4633 1.96 christos if (!IN6_ARE_ADDR_EQUAL(&sin61->sin6_addr, &sin62->sin6_addr)) {
4634 1.145 ozaki return 0;
4635 1.1 jonathan }
4636 1.96 christos if (key_portcomp(sin61->sin6_port, sin62->sin6_port, howport)) {
4637 1.145 ozaki return 0;
4638 1.1 jonathan }
4639 1.35 degroote break;
4640 1.1 jonathan default:
4641 1.62 cegger if (memcmp(sa1, sa2, sa1->sa_len) != 0)
4642 1.145 ozaki return 0;
4643 1.1 jonathan break;
4644 1.1 jonathan }
4645 1.1 jonathan
4646 1.145 ozaki return 1;
4647 1.1 jonathan }
4648 1.1 jonathan
4649 1.1 jonathan /*
4650 1.1 jonathan * compare two buffers with mask.
4651 1.1 jonathan * IN:
4652 1.1 jonathan * addr1: source
4653 1.1 jonathan * addr2: object
4654 1.1 jonathan * bits: Number of bits to compare
4655 1.1 jonathan * OUT:
4656 1.1 jonathan * 1 : equal
4657 1.1 jonathan * 0 : not equal
4658 1.1 jonathan */
4659 1.1 jonathan static int
4660 1.145 ozaki key_bb_match_withmask(const void *a1, const void *a2, u_int bits)
4661 1.1 jonathan {
4662 1.1 jonathan const unsigned char *p1 = a1;
4663 1.1 jonathan const unsigned char *p2 = a2;
4664 1.1 jonathan
4665 1.1 jonathan /* XXX: This could be considerably faster if we compare a word
4666 1.1 jonathan * at a time, but it is complicated on LSB Endian machines */
4667 1.1 jonathan
4668 1.1 jonathan /* Handle null pointers */
4669 1.1 jonathan if (p1 == NULL || p2 == NULL)
4670 1.1 jonathan return (p1 == p2);
4671 1.1 jonathan
4672 1.1 jonathan while (bits >= 8) {
4673 1.1 jonathan if (*p1++ != *p2++)
4674 1.1 jonathan return 0;
4675 1.1 jonathan bits -= 8;
4676 1.1 jonathan }
4677 1.1 jonathan
4678 1.1 jonathan if (bits > 0) {
4679 1.1 jonathan u_int8_t mask = ~((1<<(8-bits))-1);
4680 1.1 jonathan if ((*p1 & mask) != (*p2 & mask))
4681 1.1 jonathan return 0;
4682 1.1 jonathan }
4683 1.1 jonathan return 1; /* Match! */
4684 1.1 jonathan }
4685 1.1 jonathan
4686 1.126 ozaki static void
4687 1.159 ozaki key_timehandler_spd(time_t now)
4688 1.1 jonathan {
4689 1.1 jonathan u_int dir;
4690 1.194 ozaki struct secpolicy *sp;
4691 1.1 jonathan
4692 1.1 jonathan for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
4693 1.194 ozaki retry:
4694 1.208 ozaki mutex_enter(&key_spd.lock);
4695 1.194 ozaki SPLIST_WRITER_FOREACH(sp, dir) {
4696 1.197 ozaki KASSERT(sp->state != IPSEC_SPSTATE_DEAD);
4697 1.1 jonathan
4698 1.1 jonathan if (sp->lifetime == 0 && sp->validtime == 0)
4699 1.1 jonathan continue;
4700 1.1 jonathan
4701 1.137 ozaki if ((sp->lifetime && now - sp->created > sp->lifetime) ||
4702 1.137 ozaki (sp->validtime && now - sp->lastused > sp->validtime)) {
4703 1.197 ozaki key_unlink_sp(sp);
4704 1.208 ozaki mutex_exit(&key_spd.lock);
4705 1.1 jonathan key_spdexpire(sp);
4706 1.197 ozaki key_destroy_sp(sp);
4707 1.194 ozaki goto retry;
4708 1.1 jonathan }
4709 1.1 jonathan }
4710 1.208 ozaki mutex_exit(&key_spd.lock);
4711 1.1 jonathan }
4712 1.197 ozaki
4713 1.197 ozaki retry_socksplist:
4714 1.208 ozaki mutex_enter(&key_spd.lock);
4715 1.197 ozaki SOCKSPLIST_WRITER_FOREACH(sp) {
4716 1.197 ozaki if (sp->state != IPSEC_SPSTATE_DEAD)
4717 1.197 ozaki continue;
4718 1.197 ozaki
4719 1.197 ozaki key_unlink_sp(sp);
4720 1.208 ozaki mutex_exit(&key_spd.lock);
4721 1.197 ozaki key_destroy_sp(sp);
4722 1.197 ozaki goto retry_socksplist;
4723 1.197 ozaki }
4724 1.208 ozaki mutex_exit(&key_spd.lock);
4725 1.159 ozaki }
4726 1.1 jonathan
4727 1.159 ozaki static void
4728 1.159 ozaki key_timehandler_sad(time_t now)
4729 1.159 ozaki {
4730 1.202 ozaki struct secashead *sah;
4731 1.216 ozaki int s;
4732 1.1 jonathan
4733 1.202 ozaki restart:
4734 1.216 ozaki mutex_enter(&key_sad.lock);
4735 1.202 ozaki SAHLIST_WRITER_FOREACH(sah) {
4736 1.216 ozaki /* If sah has been dead and has no sav, then delete it */
4737 1.216 ozaki if (sah->state == SADB_SASTATE_DEAD &&
4738 1.216 ozaki !key_sah_has_sav(sah)) {
4739 1.216 ozaki key_unlink_sah(sah);
4740 1.216 ozaki mutex_exit(&key_sad.lock);
4741 1.216 ozaki key_destroy_sah(sah);
4742 1.202 ozaki goto restart;
4743 1.1 jonathan }
4744 1.216 ozaki }
4745 1.216 ozaki mutex_exit(&key_sad.lock);
4746 1.216 ozaki
4747 1.216 ozaki s = pserialize_read_enter();
4748 1.216 ozaki SAHLIST_READER_FOREACH(sah) {
4749 1.216 ozaki struct secasvar *sav;
4750 1.216 ozaki
4751 1.216 ozaki key_sah_ref(sah);
4752 1.216 ozaki pserialize_read_exit(s);
4753 1.1 jonathan
4754 1.1 jonathan /* if LARVAL entry doesn't become MATURE, delete it. */
4755 1.223 ozaki mutex_enter(&key_sad.lock);
4756 1.203 ozaki restart_sav_LARVAL:
4757 1.223 ozaki SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_LARVAL) {
4758 1.1 jonathan if (now - sav->created > key_larval_lifetime) {
4759 1.218 ozaki key_sa_chgstate(sav, SADB_SASTATE_DEAD);
4760 1.203 ozaki goto restart_sav_LARVAL;
4761 1.1 jonathan }
4762 1.1 jonathan }
4763 1.223 ozaki mutex_exit(&key_sad.lock);
4764 1.1 jonathan
4765 1.1 jonathan /*
4766 1.1 jonathan * check MATURE entry to start to send expire message
4767 1.1 jonathan * whether or not.
4768 1.1 jonathan */
4769 1.203 ozaki restart_sav_MATURE:
4770 1.223 ozaki mutex_enter(&key_sad.lock);
4771 1.223 ozaki SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_MATURE) {
4772 1.1 jonathan /* we don't need to check. */
4773 1.1 jonathan if (sav->lft_s == NULL)
4774 1.1 jonathan continue;
4775 1.1 jonathan
4776 1.1 jonathan /* sanity check */
4777 1.178 ozaki KASSERT(sav->lft_c != NULL);
4778 1.1 jonathan
4779 1.1 jonathan /* check SOFT lifetime */
4780 1.137 ozaki if (sav->lft_s->sadb_lifetime_addtime != 0 &&
4781 1.137 ozaki now - sav->created > sav->lft_s->sadb_lifetime_addtime) {
4782 1.1 jonathan /*
4783 1.1 jonathan * check SA to be used whether or not.
4784 1.1 jonathan * when SA hasn't been used, delete it.
4785 1.1 jonathan */
4786 1.1 jonathan if (sav->lft_c->sadb_lifetime_usetime == 0) {
4787 1.1 jonathan key_sa_chgstate(sav, SADB_SASTATE_DEAD);
4788 1.223 ozaki mutex_exit(&key_sad.lock);
4789 1.1 jonathan } else {
4790 1.1 jonathan key_sa_chgstate(sav, SADB_SASTATE_DYING);
4791 1.223 ozaki mutex_exit(&key_sad.lock);
4792 1.1 jonathan /*
4793 1.1 jonathan * XXX If we keep to send expire
4794 1.1 jonathan * message in the status of
4795 1.1 jonathan * DYING. Do remove below code.
4796 1.1 jonathan */
4797 1.1 jonathan key_expire(sav);
4798 1.1 jonathan }
4799 1.203 ozaki goto restart_sav_MATURE;
4800 1.1 jonathan }
4801 1.1 jonathan /* check SOFT lifetime by bytes */
4802 1.1 jonathan /*
4803 1.1 jonathan * XXX I don't know the way to delete this SA
4804 1.1 jonathan * when new SA is installed. Caution when it's
4805 1.1 jonathan * installed too big lifetime by time.
4806 1.1 jonathan */
4807 1.137 ozaki else if (sav->lft_s->sadb_lifetime_bytes != 0 &&
4808 1.137 ozaki sav->lft_s->sadb_lifetime_bytes <
4809 1.137 ozaki sav->lft_c->sadb_lifetime_bytes) {
4810 1.1 jonathan
4811 1.1 jonathan key_sa_chgstate(sav, SADB_SASTATE_DYING);
4812 1.223 ozaki mutex_exit(&key_sad.lock);
4813 1.1 jonathan /*
4814 1.1 jonathan * XXX If we keep to send expire
4815 1.1 jonathan * message in the status of
4816 1.1 jonathan * DYING. Do remove below code.
4817 1.1 jonathan */
4818 1.1 jonathan key_expire(sav);
4819 1.203 ozaki goto restart_sav_MATURE;
4820 1.1 jonathan }
4821 1.1 jonathan }
4822 1.223 ozaki mutex_exit(&key_sad.lock);
4823 1.1 jonathan
4824 1.1 jonathan /* check DYING entry to change status to DEAD. */
4825 1.223 ozaki mutex_enter(&key_sad.lock);
4826 1.203 ozaki restart_sav_DYING:
4827 1.223 ozaki SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_DYING) {
4828 1.1 jonathan /* we don't need to check. */
4829 1.1 jonathan if (sav->lft_h == NULL)
4830 1.1 jonathan continue;
4831 1.1 jonathan
4832 1.1 jonathan /* sanity check */
4833 1.178 ozaki KASSERT(sav->lft_c != NULL);
4834 1.1 jonathan
4835 1.137 ozaki if (sav->lft_h->sadb_lifetime_addtime != 0 &&
4836 1.137 ozaki now - sav->created > sav->lft_h->sadb_lifetime_addtime) {
4837 1.1 jonathan key_sa_chgstate(sav, SADB_SASTATE_DEAD);
4838 1.203 ozaki goto restart_sav_DYING;
4839 1.1 jonathan }
4840 1.1 jonathan #if 0 /* XXX Should we keep to send expire message until HARD lifetime ? */
4841 1.1 jonathan else if (sav->lft_s != NULL
4842 1.1 jonathan && sav->lft_s->sadb_lifetime_addtime != 0
4843 1.1 jonathan && now - sav->created > sav->lft_s->sadb_lifetime_addtime) {
4844 1.1 jonathan /*
4845 1.1 jonathan * XXX: should be checked to be
4846 1.1 jonathan * installed the valid SA.
4847 1.1 jonathan */
4848 1.1 jonathan
4849 1.1 jonathan /*
4850 1.1 jonathan * If there is no SA then sending
4851 1.1 jonathan * expire message.
4852 1.1 jonathan */
4853 1.1 jonathan key_expire(sav);
4854 1.1 jonathan }
4855 1.1 jonathan #endif
4856 1.1 jonathan /* check HARD lifetime by bytes */
4857 1.137 ozaki else if (sav->lft_h->sadb_lifetime_bytes != 0 &&
4858 1.137 ozaki sav->lft_h->sadb_lifetime_bytes <
4859 1.137 ozaki sav->lft_c->sadb_lifetime_bytes) {
4860 1.1 jonathan key_sa_chgstate(sav, SADB_SASTATE_DEAD);
4861 1.203 ozaki goto restart_sav_DYING;
4862 1.1 jonathan }
4863 1.1 jonathan }
4864 1.223 ozaki mutex_exit(&key_sad.lock);
4865 1.1 jonathan
4866 1.1 jonathan /* delete entry in DEAD */
4867 1.218 ozaki restart_sav_DEAD:
4868 1.223 ozaki mutex_enter(&key_sad.lock);
4869 1.223 ozaki SAVLIST_WRITER_FOREACH(sav, sah, SADB_SASTATE_DEAD) {
4870 1.223 ozaki key_unlink_sav(sav);
4871 1.223 ozaki mutex_exit(&key_sad.lock);
4872 1.223 ozaki key_destroy_sav(sav);
4873 1.218 ozaki goto restart_sav_DEAD;
4874 1.1 jonathan }
4875 1.223 ozaki mutex_exit(&key_sad.lock);
4876 1.216 ozaki
4877 1.216 ozaki s = pserialize_read_enter();
4878 1.216 ozaki key_sah_unref(sah);
4879 1.1 jonathan }
4880 1.216 ozaki pserialize_read_exit(s);
4881 1.159 ozaki }
4882 1.1 jonathan
4883 1.159 ozaki static void
4884 1.159 ozaki key_timehandler_acq(time_t now)
4885 1.159 ozaki {
4886 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
4887 1.1 jonathan struct secacq *acq, *nextacq;
4888 1.1 jonathan
4889 1.141 ozaki restart:
4890 1.208 ozaki mutex_enter(&key_misc.lock);
4891 1.208 ozaki LIST_FOREACH_SAFE(acq, &key_misc.acqlist, chain, nextacq) {
4892 1.138 ozaki if (now - acq->created > key_blockacq_lifetime) {
4893 1.1 jonathan LIST_REMOVE(acq, chain);
4894 1.208 ozaki mutex_exit(&key_misc.lock);
4895 1.127 ozaki kmem_free(acq, sizeof(*acq));
4896 1.141 ozaki goto restart;
4897 1.1 jonathan }
4898 1.1 jonathan }
4899 1.208 ozaki mutex_exit(&key_misc.lock);
4900 1.1 jonathan #endif
4901 1.159 ozaki }
4902 1.1 jonathan
4903 1.159 ozaki static void
4904 1.159 ozaki key_timehandler_spacq(time_t now)
4905 1.159 ozaki {
4906 1.139 ozaki #ifdef notyet
4907 1.1 jonathan struct secspacq *acq, *nextacq;
4908 1.1 jonathan
4909 1.208 ozaki LIST_FOREACH_SAFE(acq, &key_misc.spacqlist, chain, nextacq) {
4910 1.138 ozaki if (now - acq->created > key_blockacq_lifetime) {
4911 1.138 ozaki KASSERT(__LIST_CHAINED(acq));
4912 1.1 jonathan LIST_REMOVE(acq, chain);
4913 1.127 ozaki kmem_free(acq, sizeof(*acq));
4914 1.1 jonathan }
4915 1.1 jonathan }
4916 1.139 ozaki #endif
4917 1.159 ozaki }
4918 1.159 ozaki
4919 1.220 ozaki static unsigned int key_timehandler_work_enqueued = 0;
4920 1.220 ozaki
4921 1.159 ozaki /*
4922 1.159 ozaki * time handler.
4923 1.159 ozaki * scanning SPD and SAD to check status for each entries,
4924 1.159 ozaki * and do to remove or to expire.
4925 1.159 ozaki */
4926 1.159 ozaki static void
4927 1.159 ozaki key_timehandler_work(struct work *wk, void *arg)
4928 1.159 ozaki {
4929 1.159 ozaki time_t now = time_uptime;
4930 1.195 ozaki IPSEC_DECLARE_LOCK_VARIABLE;
4931 1.159 ozaki
4932 1.220 ozaki /* We can allow enqueuing another work at this point */
4933 1.220 ozaki atomic_swap_uint(&key_timehandler_work_enqueued, 0);
4934 1.220 ozaki
4935 1.195 ozaki IPSEC_ACQUIRE_GLOBAL_LOCKS();
4936 1.159 ozaki
4937 1.159 ozaki key_timehandler_spd(now);
4938 1.159 ozaki key_timehandler_sad(now);
4939 1.159 ozaki key_timehandler_acq(now);
4940 1.159 ozaki key_timehandler_spacq(now);
4941 1.1 jonathan
4942 1.220 ozaki key_acquire_sendup_pending_mbuf();
4943 1.220 ozaki
4944 1.1 jonathan /* do exchange to tick time !! */
4945 1.40 degroote callout_reset(&key_timehandler_ch, hz, key_timehandler, NULL);
4946 1.1 jonathan
4947 1.195 ozaki IPSEC_RELEASE_GLOBAL_LOCKS();
4948 1.1 jonathan return;
4949 1.1 jonathan }
4950 1.1 jonathan
4951 1.126 ozaki static void
4952 1.126 ozaki key_timehandler(void *arg)
4953 1.126 ozaki {
4954 1.126 ozaki
4955 1.220 ozaki /* Avoid enqueuing another work when one is already enqueued */
4956 1.220 ozaki if (atomic_swap_uint(&key_timehandler_work_enqueued, 1) == 1)
4957 1.220 ozaki return;
4958 1.220 ozaki
4959 1.126 ozaki workqueue_enqueue(key_timehandler_wq, &key_timehandler_wk, NULL);
4960 1.126 ozaki }
4961 1.126 ozaki
4962 1.1 jonathan u_long
4963 1.61 cegger key_random(void)
4964 1.1 jonathan {
4965 1.1 jonathan u_long value;
4966 1.1 jonathan
4967 1.1 jonathan key_randomfill(&value, sizeof(value));
4968 1.1 jonathan return value;
4969 1.1 jonathan }
4970 1.1 jonathan
4971 1.1 jonathan void
4972 1.49 degroote key_randomfill(void *p, size_t l)
4973 1.1 jonathan {
4974 1.75 drochner
4975 1.75 drochner cprng_fast(p, l);
4976 1.1 jonathan }
4977 1.1 jonathan
4978 1.1 jonathan /*
4979 1.1 jonathan * map SADB_SATYPE_* to IPPROTO_*.
4980 1.1 jonathan * if satype == SADB_SATYPE then satype is mapped to ~0.
4981 1.1 jonathan * OUT:
4982 1.1 jonathan * 0: invalid satype.
4983 1.1 jonathan */
4984 1.1 jonathan static u_int16_t
4985 1.49 degroote key_satype2proto(u_int8_t satype)
4986 1.1 jonathan {
4987 1.1 jonathan switch (satype) {
4988 1.1 jonathan case SADB_SATYPE_UNSPEC:
4989 1.1 jonathan return IPSEC_PROTO_ANY;
4990 1.1 jonathan case SADB_SATYPE_AH:
4991 1.1 jonathan return IPPROTO_AH;
4992 1.1 jonathan case SADB_SATYPE_ESP:
4993 1.1 jonathan return IPPROTO_ESP;
4994 1.1 jonathan case SADB_X_SATYPE_IPCOMP:
4995 1.1 jonathan return IPPROTO_IPCOMP;
4996 1.12 jonathan case SADB_X_SATYPE_TCPSIGNATURE:
4997 1.12 jonathan return IPPROTO_TCP;
4998 1.1 jonathan default:
4999 1.1 jonathan return 0;
5000 1.1 jonathan }
5001 1.1 jonathan /* NOTREACHED */
5002 1.1 jonathan }
5003 1.1 jonathan
5004 1.1 jonathan /*
5005 1.1 jonathan * map IPPROTO_* to SADB_SATYPE_*
5006 1.1 jonathan * OUT:
5007 1.1 jonathan * 0: invalid protocol type.
5008 1.1 jonathan */
5009 1.1 jonathan static u_int8_t
5010 1.49 degroote key_proto2satype(u_int16_t proto)
5011 1.1 jonathan {
5012 1.1 jonathan switch (proto) {
5013 1.1 jonathan case IPPROTO_AH:
5014 1.1 jonathan return SADB_SATYPE_AH;
5015 1.1 jonathan case IPPROTO_ESP:
5016 1.1 jonathan return SADB_SATYPE_ESP;
5017 1.1 jonathan case IPPROTO_IPCOMP:
5018 1.1 jonathan return SADB_X_SATYPE_IPCOMP;
5019 1.12 jonathan case IPPROTO_TCP:
5020 1.12 jonathan return SADB_X_SATYPE_TCPSIGNATURE;
5021 1.1 jonathan default:
5022 1.1 jonathan return 0;
5023 1.1 jonathan }
5024 1.1 jonathan /* NOTREACHED */
5025 1.1 jonathan }
5026 1.1 jonathan
5027 1.79 gdt static int
5028 1.49 degroote key_setsecasidx(int proto, int mode, int reqid,
5029 1.151 ozaki const struct sockaddr *src, const struct sockaddr *dst,
5030 1.151 ozaki struct secasindex * saidx)
5031 1.48 degroote {
5032 1.137 ozaki const union sockaddr_union *src_u = (const union sockaddr_union *)src;
5033 1.137 ozaki const union sockaddr_union *dst_u = (const union sockaddr_union *)dst;
5034 1.48 degroote
5035 1.48 degroote /* sa len safety check */
5036 1.48 degroote if (key_checksalen(src_u) != 0)
5037 1.48 degroote return -1;
5038 1.48 degroote if (key_checksalen(dst_u) != 0)
5039 1.48 degroote return -1;
5040 1.79 gdt
5041 1.48 degroote memset(saidx, 0, sizeof(*saidx));
5042 1.48 degroote saidx->proto = proto;
5043 1.48 degroote saidx->mode = mode;
5044 1.48 degroote saidx->reqid = reqid;
5045 1.48 degroote memcpy(&saidx->src, src_u, src_u->sa.sa_len);
5046 1.48 degroote memcpy(&saidx->dst, dst_u, dst_u->sa.sa_len);
5047 1.48 degroote
5048 1.137 ozaki key_porttosaddr(&((saidx)->src), 0);
5049 1.137 ozaki key_porttosaddr(&((saidx)->dst), 0);
5050 1.48 degroote return 0;
5051 1.48 degroote }
5052 1.48 degroote
5053 1.151 ozaki static void
5054 1.151 ozaki key_init_spidx_bymsghdr(struct secpolicyindex *spidx,
5055 1.151 ozaki const struct sadb_msghdr *mhp)
5056 1.151 ozaki {
5057 1.151 ozaki const struct sadb_address *src0, *dst0;
5058 1.151 ozaki const struct sockaddr *src, *dst;
5059 1.151 ozaki const struct sadb_x_policy *xpl0;
5060 1.151 ozaki
5061 1.230 christos src0 = mhp->ext[SADB_EXT_ADDRESS_SRC];
5062 1.230 christos dst0 = mhp->ext[SADB_EXT_ADDRESS_DST];
5063 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
5064 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
5065 1.230 christos xpl0 = mhp->ext[SADB_X_EXT_POLICY];
5066 1.151 ozaki
5067 1.151 ozaki memset(spidx, 0, sizeof(*spidx));
5068 1.151 ozaki spidx->dir = xpl0->sadb_x_policy_dir;
5069 1.151 ozaki spidx->prefs = src0->sadb_address_prefixlen;
5070 1.151 ozaki spidx->prefd = dst0->sadb_address_prefixlen;
5071 1.151 ozaki spidx->ul_proto = src0->sadb_address_proto;
5072 1.151 ozaki /* XXX boundary check against sa_len */
5073 1.151 ozaki memcpy(&spidx->src, src, src->sa_len);
5074 1.151 ozaki memcpy(&spidx->dst, dst, dst->sa_len);
5075 1.151 ozaki }
5076 1.151 ozaki
5077 1.1 jonathan /* %%% PF_KEY */
5078 1.1 jonathan /*
5079 1.1 jonathan * SADB_GETSPI processing is to receive
5080 1.1 jonathan * <base, (SA2), src address, dst address, (SPI range)>
5081 1.1 jonathan * from the IKMPd, to assign a unique spi value, to hang on the INBOUND
5082 1.1 jonathan * tree with the status of LARVAL, and send
5083 1.1 jonathan * <base, SA(*), address(SD)>
5084 1.1 jonathan * to the IKMPd.
5085 1.1 jonathan *
5086 1.1 jonathan * IN: mhp: pointer to the pointer to each header.
5087 1.1 jonathan * OUT: NULL if fail.
5088 1.1 jonathan * other if success, return pointer to the message to send.
5089 1.1 jonathan */
5090 1.1 jonathan static int
5091 1.162 ozaki key_api_getspi(struct socket *so, struct mbuf *m,
5092 1.49 degroote const struct sadb_msghdr *mhp)
5093 1.1 jonathan {
5094 1.151 ozaki const struct sockaddr *src, *dst;
5095 1.1 jonathan struct secasindex saidx;
5096 1.204 ozaki struct secashead *sah;
5097 1.1 jonathan struct secasvar *newsav;
5098 1.1 jonathan u_int8_t proto;
5099 1.1 jonathan u_int32_t spi;
5100 1.1 jonathan u_int8_t mode;
5101 1.34 degroote u_int16_t reqid;
5102 1.1 jonathan int error;
5103 1.1 jonathan
5104 1.1 jonathan if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5105 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
5106 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5107 1.1 jonathan return key_senderror(so, m, EINVAL);
5108 1.1 jonathan }
5109 1.1 jonathan if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5110 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5111 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5112 1.1 jonathan return key_senderror(so, m, EINVAL);
5113 1.1 jonathan }
5114 1.1 jonathan if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
5115 1.230 christos const struct sadb_x_sa2 *sa2 = mhp->ext[SADB_X_EXT_SA2];
5116 1.230 christos mode = sa2->sadb_x_sa2_mode;
5117 1.230 christos reqid = sa2->sadb_x_sa2_reqid;
5118 1.1 jonathan } else {
5119 1.1 jonathan mode = IPSEC_MODE_ANY;
5120 1.1 jonathan reqid = 0;
5121 1.1 jonathan }
5122 1.1 jonathan
5123 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
5124 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
5125 1.1 jonathan
5126 1.1 jonathan /* map satype to proto */
5127 1.137 ozaki proto = key_satype2proto(mhp->msg->sadb_msg_satype);
5128 1.137 ozaki if (proto == 0) {
5129 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
5130 1.1 jonathan return key_senderror(so, m, EINVAL);
5131 1.1 jonathan }
5132 1.1 jonathan
5133 1.1 jonathan
5134 1.151 ozaki error = key_setsecasidx(proto, mode, reqid, src, dst, &saidx);
5135 1.137 ozaki if (error != 0)
5136 1.48 degroote return key_senderror(so, m, EINVAL);
5137 1.1 jonathan
5138 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
5139 1.137 ozaki if (error != 0)
5140 1.64 spz return key_senderror(so, m, EINVAL);
5141 1.64 spz
5142 1.1 jonathan /* SPI allocation */
5143 1.230 christos spi = key_do_getnewspi(mhp->ext[SADB_EXT_SPIRANGE], &saidx);
5144 1.1 jonathan if (spi == 0)
5145 1.1 jonathan return key_senderror(so, m, EINVAL);
5146 1.1 jonathan
5147 1.1 jonathan /* get a SA index */
5148 1.216 ozaki sah = key_getsah_ref(&saidx, CMP_REQID);
5149 1.204 ozaki if (sah == NULL) {
5150 1.1 jonathan /* create a new SA index */
5151 1.204 ozaki sah = key_newsah(&saidx);
5152 1.204 ozaki if (sah == NULL) {
5153 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
5154 1.1 jonathan return key_senderror(so, m, ENOBUFS);
5155 1.1 jonathan }
5156 1.1 jonathan }
5157 1.1 jonathan
5158 1.1 jonathan /* get a new SA */
5159 1.1 jonathan /* XXX rewrite */
5160 1.171 ozaki newsav = KEY_NEWSAV(m, mhp, &error);
5161 1.1 jonathan if (newsav == NULL) {
5162 1.216 ozaki key_sah_unref(sah);
5163 1.1 jonathan /* XXX don't free new SA index allocated in above. */
5164 1.1 jonathan return key_senderror(so, m, error);
5165 1.1 jonathan }
5166 1.1 jonathan
5167 1.1 jonathan /* set spi */
5168 1.1 jonathan newsav->spi = htonl(spi);
5169 1.1 jonathan
5170 1.223 ozaki /* Add to sah#savlist */
5171 1.223 ozaki key_init_sav(newsav);
5172 1.204 ozaki newsav->sah = sah;
5173 1.171 ozaki newsav->state = SADB_SASTATE_LARVAL;
5174 1.208 ozaki mutex_enter(&key_sad.lock);
5175 1.204 ozaki SAVLIST_WRITER_INSERT_TAIL(sah, SADB_SASTATE_LARVAL, newsav);
5176 1.208 ozaki mutex_exit(&key_sad.lock);
5177 1.204 ozaki key_validate_savlist(sah, SADB_SASTATE_LARVAL);
5178 1.171 ozaki
5179 1.216 ozaki key_sah_unref(sah);
5180 1.216 ozaki
5181 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
5182 1.208 ozaki /* delete the entry in key_misc.acqlist */
5183 1.1 jonathan if (mhp->msg->sadb_msg_seq != 0) {
5184 1.1 jonathan struct secacq *acq;
5185 1.208 ozaki mutex_enter(&key_misc.lock);
5186 1.137 ozaki acq = key_getacqbyseq(mhp->msg->sadb_msg_seq);
5187 1.137 ozaki if (acq != NULL) {
5188 1.1 jonathan /* reset counter in order to deletion by timehandler. */
5189 1.69 drochner acq->created = time_uptime;
5190 1.1 jonathan acq->count = 0;
5191 1.1 jonathan }
5192 1.208 ozaki mutex_exit(&key_misc.lock);
5193 1.118 ozaki }
5194 1.1 jonathan #endif
5195 1.1 jonathan
5196 1.1 jonathan {
5197 1.1 jonathan struct mbuf *n, *nn;
5198 1.1 jonathan struct sadb_sa *m_sa;
5199 1.1 jonathan int off, len;
5200 1.1 jonathan
5201 1.157 ozaki CTASSERT(PFKEY_ALIGN8(sizeof(struct sadb_msg)) +
5202 1.157 ozaki PFKEY_ALIGN8(sizeof(struct sadb_sa)) <= MCLBYTES);
5203 1.157 ozaki
5204 1.1 jonathan /* create new sadb_msg to reply. */
5205 1.1 jonathan len = PFKEY_ALIGN8(sizeof(struct sadb_msg)) +
5206 1.1 jonathan PFKEY_ALIGN8(sizeof(struct sadb_sa));
5207 1.1 jonathan
5208 1.239 ozaki n = key_alloc_mbuf_simple(len, M_WAITOK);
5209 1.1 jonathan n->m_len = len;
5210 1.1 jonathan n->m_next = NULL;
5211 1.1 jonathan off = 0;
5212 1.1 jonathan
5213 1.39 degroote m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, char *) + off);
5214 1.1 jonathan off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
5215 1.1 jonathan
5216 1.39 degroote m_sa = (struct sadb_sa *)(mtod(n, char *) + off);
5217 1.1 jonathan m_sa->sadb_sa_len = PFKEY_UNIT64(sizeof(struct sadb_sa));
5218 1.1 jonathan m_sa->sadb_sa_exttype = SADB_EXT_SA;
5219 1.1 jonathan m_sa->sadb_sa_spi = htonl(spi);
5220 1.1 jonathan off += PFKEY_ALIGN8(sizeof(struct sadb_sa));
5221 1.1 jonathan
5222 1.110 ozaki KASSERTMSG(off == len, "length inconsistency");
5223 1.1 jonathan
5224 1.1 jonathan n->m_next = key_gather_mbuf(m, mhp, 0, 2, SADB_EXT_ADDRESS_SRC,
5225 1.1 jonathan SADB_EXT_ADDRESS_DST);
5226 1.1 jonathan
5227 1.1 jonathan if (n->m_len < sizeof(struct sadb_msg)) {
5228 1.1 jonathan n = m_pullup(n, sizeof(struct sadb_msg));
5229 1.1 jonathan if (n == NULL)
5230 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_ONE);
5231 1.1 jonathan }
5232 1.1 jonathan
5233 1.1 jonathan n->m_pkthdr.len = 0;
5234 1.1 jonathan for (nn = n; nn; nn = nn->m_next)
5235 1.1 jonathan n->m_pkthdr.len += nn->m_len;
5236 1.1 jonathan
5237 1.158 ozaki key_fill_replymsg(n, newsav->seq);
5238 1.1 jonathan
5239 1.1 jonathan m_freem(m);
5240 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
5241 1.1 jonathan }
5242 1.1 jonathan }
5243 1.1 jonathan
5244 1.1 jonathan /*
5245 1.1 jonathan * allocating new SPI
5246 1.162 ozaki * called by key_api_getspi().
5247 1.1 jonathan * OUT:
5248 1.1 jonathan * 0: failure.
5249 1.1 jonathan * others: success.
5250 1.1 jonathan */
5251 1.1 jonathan static u_int32_t
5252 1.66 drochner key_do_getnewspi(const struct sadb_spirange *spirange,
5253 1.66 drochner const struct secasindex *saidx)
5254 1.1 jonathan {
5255 1.1 jonathan u_int32_t newspi;
5256 1.25 christos u_int32_t spmin, spmax;
5257 1.1 jonathan int count = key_spi_trycnt;
5258 1.1 jonathan
5259 1.1 jonathan /* set spi range to allocate */
5260 1.1 jonathan if (spirange != NULL) {
5261 1.25 christos spmin = spirange->sadb_spirange_min;
5262 1.25 christos spmax = spirange->sadb_spirange_max;
5263 1.1 jonathan } else {
5264 1.25 christos spmin = key_spi_minval;
5265 1.25 christos spmax = key_spi_maxval;
5266 1.1 jonathan }
5267 1.1 jonathan /* IPCOMP needs 2-byte SPI */
5268 1.1 jonathan if (saidx->proto == IPPROTO_IPCOMP) {
5269 1.1 jonathan u_int32_t t;
5270 1.25 christos if (spmin >= 0x10000)
5271 1.25 christos spmin = 0xffff;
5272 1.25 christos if (spmax >= 0x10000)
5273 1.25 christos spmax = 0xffff;
5274 1.25 christos if (spmin > spmax) {
5275 1.25 christos t = spmin; spmin = spmax; spmax = t;
5276 1.1 jonathan }
5277 1.1 jonathan }
5278 1.1 jonathan
5279 1.25 christos if (spmin == spmax) {
5280 1.174 ozaki if (key_checkspidup(saidx, htonl(spmin))) {
5281 1.134 ozaki IPSECLOG(LOG_DEBUG, "SPI %u exists already.\n", spmin);
5282 1.1 jonathan return 0;
5283 1.1 jonathan }
5284 1.1 jonathan
5285 1.1 jonathan count--; /* taking one cost. */
5286 1.25 christos newspi = spmin;
5287 1.1 jonathan
5288 1.1 jonathan } else {
5289 1.1 jonathan
5290 1.1 jonathan /* init SPI */
5291 1.1 jonathan newspi = 0;
5292 1.1 jonathan
5293 1.1 jonathan /* when requesting to allocate spi ranged */
5294 1.1 jonathan while (count--) {
5295 1.1 jonathan /* generate pseudo-random SPI value ranged. */
5296 1.25 christos newspi = spmin + (key_random() % (spmax - spmin + 1));
5297 1.1 jonathan
5298 1.174 ozaki if (!key_checkspidup(saidx, htonl(newspi)))
5299 1.1 jonathan break;
5300 1.1 jonathan }
5301 1.1 jonathan
5302 1.1 jonathan if (count == 0 || newspi == 0) {
5303 1.134 ozaki IPSECLOG(LOG_DEBUG, "to allocate spi is failed.\n");
5304 1.1 jonathan return 0;
5305 1.1 jonathan }
5306 1.1 jonathan }
5307 1.1 jonathan
5308 1.1 jonathan /* statistics */
5309 1.1 jonathan keystat.getspi_count =
5310 1.137 ozaki (keystat.getspi_count + key_spi_trycnt - count) / 2;
5311 1.1 jonathan
5312 1.1 jonathan return newspi;
5313 1.1 jonathan }
5314 1.1 jonathan
5315 1.48 degroote static int
5316 1.49 degroote key_handle_natt_info(struct secasvar *sav,
5317 1.49 degroote const struct sadb_msghdr *mhp)
5318 1.48 degroote {
5319 1.91 christos const char *msg = "?" ;
5320 1.91 christos struct sadb_x_nat_t_type *type;
5321 1.91 christos struct sadb_x_nat_t_port *sport, *dport;
5322 1.91 christos struct sadb_address *iaddr, *raddr;
5323 1.91 christos struct sadb_x_nat_t_frag *frag;
5324 1.91 christos
5325 1.91 christos if (mhp->ext[SADB_X_EXT_NAT_T_TYPE] == NULL ||
5326 1.91 christos mhp->ext[SADB_X_EXT_NAT_T_SPORT] == NULL ||
5327 1.91 christos mhp->ext[SADB_X_EXT_NAT_T_DPORT] == NULL)
5328 1.91 christos return 0;
5329 1.48 degroote
5330 1.91 christos if (mhp->extlen[SADB_X_EXT_NAT_T_TYPE] < sizeof(*type)) {
5331 1.91 christos msg = "TYPE";
5332 1.91 christos goto bad;
5333 1.91 christos }
5334 1.48 degroote
5335 1.91 christos if (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport)) {
5336 1.91 christos msg = "SPORT";
5337 1.91 christos goto bad;
5338 1.91 christos }
5339 1.48 degroote
5340 1.91 christos if (mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
5341 1.91 christos msg = "DPORT";
5342 1.91 christos goto bad;
5343 1.91 christos }
5344 1.48 degroote
5345 1.91 christos if (mhp->ext[SADB_X_EXT_NAT_T_OAI] != NULL) {
5346 1.134 ozaki IPSECLOG(LOG_DEBUG, "NAT-T OAi present\n");
5347 1.91 christos if (mhp->extlen[SADB_X_EXT_NAT_T_OAI] < sizeof(*iaddr)) {
5348 1.91 christos msg = "OAI";
5349 1.91 christos goto bad;
5350 1.64 spz }
5351 1.91 christos }
5352 1.64 spz
5353 1.91 christos if (mhp->ext[SADB_X_EXT_NAT_T_OAR] != NULL) {
5354 1.134 ozaki IPSECLOG(LOG_DEBUG, "NAT-T OAr present\n");
5355 1.91 christos if (mhp->extlen[SADB_X_EXT_NAT_T_OAR] < sizeof(*raddr)) {
5356 1.91 christos msg = "OAR";
5357 1.91 christos goto bad;
5358 1.48 degroote }
5359 1.91 christos }
5360 1.48 degroote
5361 1.91 christos if (mhp->ext[SADB_X_EXT_NAT_T_FRAG] != NULL) {
5362 1.91 christos if (mhp->extlen[SADB_X_EXT_NAT_T_FRAG] < sizeof(*frag)) {
5363 1.91 christos msg = "FRAG";
5364 1.91 christos goto bad;
5365 1.91 christos }
5366 1.91 christos }
5367 1.48 degroote
5368 1.230 christos type = mhp->ext[SADB_X_EXT_NAT_T_TYPE];
5369 1.230 christos sport = mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5370 1.230 christos dport = mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5371 1.230 christos iaddr = mhp->ext[SADB_X_EXT_NAT_T_OAI];
5372 1.230 christos raddr = mhp->ext[SADB_X_EXT_NAT_T_OAR];
5373 1.230 christos frag = mhp->ext[SADB_X_EXT_NAT_T_FRAG];
5374 1.48 degroote
5375 1.134 ozaki IPSECLOG(LOG_DEBUG, "type %d, sport = %d, dport = %d\n",
5376 1.134 ozaki type->sadb_x_nat_t_type_type,
5377 1.91 christos ntohs(sport->sadb_x_nat_t_port_port),
5378 1.134 ozaki ntohs(dport->sadb_x_nat_t_port_port));
5379 1.91 christos
5380 1.91 christos sav->natt_type = type->sadb_x_nat_t_type_type;
5381 1.137 ozaki key_porttosaddr(&sav->sah->saidx.src, sport->sadb_x_nat_t_port_port);
5382 1.137 ozaki key_porttosaddr(&sav->sah->saidx.dst, dport->sadb_x_nat_t_port_port);
5383 1.91 christos if (frag)
5384 1.91 christos sav->esp_frag = frag->sadb_x_nat_t_frag_fraglen;
5385 1.91 christos else
5386 1.91 christos sav->esp_frag = IP_MAXPACKET;
5387 1.48 degroote
5388 1.48 degroote return 0;
5389 1.91 christos bad:
5390 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message %s\n", msg);
5391 1.91 christos __USE(msg);
5392 1.91 christos return -1;
5393 1.48 degroote }
5394 1.64 spz
5395 1.64 spz /* Just update the IPSEC_NAT_T ports if present */
5396 1.64 spz static int
5397 1.64 spz key_set_natt_ports(union sockaddr_union *src, union sockaddr_union *dst,
5398 1.64 spz const struct sadb_msghdr *mhp)
5399 1.64 spz {
5400 1.64 spz if (mhp->ext[SADB_X_EXT_NAT_T_OAI] != NULL)
5401 1.134 ozaki IPSECLOG(LOG_DEBUG, "NAT-T OAi present\n");
5402 1.64 spz if (mhp->ext[SADB_X_EXT_NAT_T_OAR] != NULL)
5403 1.134 ozaki IPSECLOG(LOG_DEBUG, "NAT-T OAr present\n");
5404 1.64 spz
5405 1.64 spz if ((mhp->ext[SADB_X_EXT_NAT_T_TYPE] != NULL) &&
5406 1.64 spz (mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL) &&
5407 1.64 spz (mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL)) {
5408 1.64 spz struct sadb_x_nat_t_type *type;
5409 1.64 spz struct sadb_x_nat_t_port *sport;
5410 1.64 spz struct sadb_x_nat_t_port *dport;
5411 1.64 spz
5412 1.64 spz if ((mhp->extlen[SADB_X_EXT_NAT_T_TYPE] < sizeof(*type)) ||
5413 1.64 spz (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport)) ||
5414 1.64 spz (mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport))) {
5415 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message\n");
5416 1.64 spz return -1;
5417 1.64 spz }
5418 1.64 spz
5419 1.230 christos type = mhp->ext[SADB_X_EXT_NAT_T_TYPE];
5420 1.230 christos sport = mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5421 1.230 christos dport = mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5422 1.64 spz
5423 1.91 christos key_porttosaddr(src, sport->sadb_x_nat_t_port_port);
5424 1.91 christos key_porttosaddr(dst, dport->sadb_x_nat_t_port_port);
5425 1.91 christos
5426 1.134 ozaki IPSECLOG(LOG_DEBUG, "type %d, sport = %d, dport = %d\n",
5427 1.134 ozaki type->sadb_x_nat_t_type_type,
5428 1.91 christos ntohs(sport->sadb_x_nat_t_port_port),
5429 1.134 ozaki ntohs(dport->sadb_x_nat_t_port_port));
5430 1.64 spz }
5431 1.64 spz
5432 1.64 spz return 0;
5433 1.64 spz }
5434 1.48 degroote
5435 1.48 degroote
5436 1.1 jonathan /*
5437 1.1 jonathan * SADB_UPDATE processing
5438 1.1 jonathan * receive
5439 1.1 jonathan * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
5440 1.1 jonathan * key(AE), (identity(SD),) (sensitivity)>
5441 1.1 jonathan * from the ikmpd, and update a secasvar entry whose status is SADB_SASTATE_LARVAL.
5442 1.1 jonathan * and send
5443 1.1 jonathan * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
5444 1.1 jonathan * (identity(SD),) (sensitivity)>
5445 1.1 jonathan * to the ikmpd.
5446 1.1 jonathan *
5447 1.1 jonathan * m will always be freed.
5448 1.1 jonathan */
5449 1.1 jonathan static int
5450 1.162 ozaki key_api_update(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp)
5451 1.1 jonathan {
5452 1.1 jonathan struct sadb_sa *sa0;
5453 1.151 ozaki const struct sockaddr *src, *dst;
5454 1.1 jonathan struct secasindex saidx;
5455 1.1 jonathan struct secashead *sah;
5456 1.167 ozaki struct secasvar *sav, *newsav;
5457 1.1 jonathan u_int16_t proto;
5458 1.1 jonathan u_int8_t mode;
5459 1.34 degroote u_int16_t reqid;
5460 1.1 jonathan int error;
5461 1.1 jonathan
5462 1.1 jonathan /* map satype to proto */
5463 1.137 ozaki proto = key_satype2proto(mhp->msg->sadb_msg_satype);
5464 1.137 ozaki if (proto == 0) {
5465 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
5466 1.1 jonathan return key_senderror(so, m, EINVAL);
5467 1.1 jonathan }
5468 1.1 jonathan
5469 1.1 jonathan if (mhp->ext[SADB_EXT_SA] == NULL ||
5470 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5471 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
5472 1.1 jonathan (mhp->msg->sadb_msg_satype == SADB_SATYPE_ESP &&
5473 1.1 jonathan mhp->ext[SADB_EXT_KEY_ENCRYPT] == NULL) ||
5474 1.1 jonathan (mhp->msg->sadb_msg_satype == SADB_SATYPE_AH &&
5475 1.1 jonathan mhp->ext[SADB_EXT_KEY_AUTH] == NULL) ||
5476 1.1 jonathan (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL &&
5477 1.1 jonathan mhp->ext[SADB_EXT_LIFETIME_SOFT] == NULL) ||
5478 1.1 jonathan (mhp->ext[SADB_EXT_LIFETIME_HARD] == NULL &&
5479 1.1 jonathan mhp->ext[SADB_EXT_LIFETIME_SOFT] != NULL)) {
5480 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5481 1.1 jonathan return key_senderror(so, m, EINVAL);
5482 1.1 jonathan }
5483 1.1 jonathan if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
5484 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5485 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5486 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5487 1.1 jonathan return key_senderror(so, m, EINVAL);
5488 1.1 jonathan }
5489 1.1 jonathan if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
5490 1.230 christos const struct sadb_x_sa2 *sa2 = mhp->ext[SADB_X_EXT_SA2];
5491 1.230 christos mode = sa2->sadb_x_sa2_mode;
5492 1.230 christos reqid = sa2->sadb_x_sa2_reqid;
5493 1.1 jonathan } else {
5494 1.1 jonathan mode = IPSEC_MODE_ANY;
5495 1.1 jonathan reqid = 0;
5496 1.1 jonathan }
5497 1.1 jonathan /* XXX boundary checking for other extensions */
5498 1.1 jonathan
5499 1.230 christos sa0 = mhp->ext[SADB_EXT_SA];
5500 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
5501 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
5502 1.1 jonathan
5503 1.151 ozaki error = key_setsecasidx(proto, mode, reqid, src, dst, &saidx);
5504 1.137 ozaki if (error != 0)
5505 1.48 degroote return key_senderror(so, m, EINVAL);
5506 1.48 degroote
5507 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
5508 1.137 ozaki if (error != 0)
5509 1.64 spz return key_senderror(so, m, EINVAL);
5510 1.1 jonathan
5511 1.1 jonathan /* get a SA header */
5512 1.216 ozaki sah = key_getsah_ref(&saidx, CMP_REQID);
5513 1.137 ozaki if (sah == NULL) {
5514 1.134 ozaki IPSECLOG(LOG_DEBUG, "no SA index found.\n");
5515 1.1 jonathan return key_senderror(so, m, ENOENT);
5516 1.1 jonathan }
5517 1.1 jonathan
5518 1.1 jonathan /* set spidx if there */
5519 1.1 jonathan /* XXX rewrite */
5520 1.1 jonathan error = key_setident(sah, m, mhp);
5521 1.1 jonathan if (error)
5522 1.216 ozaki goto error_sah;
5523 1.1 jonathan
5524 1.1 jonathan /* find a SA with sequence number. */
5525 1.1 jonathan #ifdef IPSEC_DOSEQCHECK
5526 1.137 ozaki if (mhp->msg->sadb_msg_seq != 0) {
5527 1.137 ozaki sav = key_getsavbyseq(sah, mhp->msg->sadb_msg_seq);
5528 1.137 ozaki if (sav == NULL) {
5529 1.137 ozaki IPSECLOG(LOG_DEBUG,
5530 1.137 ozaki "no larval SA with sequence %u exists.\n",
5531 1.137 ozaki mhp->msg->sadb_msg_seq);
5532 1.216 ozaki error = ENOENT;
5533 1.216 ozaki goto error_sah;
5534 1.137 ozaki }
5535 1.1 jonathan }
5536 1.1 jonathan #else
5537 1.137 ozaki sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
5538 1.137 ozaki if (sav == NULL) {
5539 1.134 ozaki IPSECLOG(LOG_DEBUG, "no such a SA found (spi:%u)\n",
5540 1.134 ozaki (u_int32_t)ntohl(sa0->sadb_sa_spi));
5541 1.216 ozaki error = EINVAL;
5542 1.216 ozaki goto error_sah;
5543 1.1 jonathan }
5544 1.1 jonathan #endif
5545 1.1 jonathan
5546 1.1 jonathan /* validity check */
5547 1.1 jonathan if (sav->sah->saidx.proto != proto) {
5548 1.134 ozaki IPSECLOG(LOG_DEBUG, "protocol mismatched (DB=%u param=%u)\n",
5549 1.134 ozaki sav->sah->saidx.proto, proto);
5550 1.174 ozaki error = EINVAL;
5551 1.174 ozaki goto error;
5552 1.1 jonathan }
5553 1.1 jonathan #ifdef IPSEC_DOSEQCHECK
5554 1.1 jonathan if (sav->spi != sa0->sadb_sa_spi) {
5555 1.134 ozaki IPSECLOG(LOG_DEBUG, "SPI mismatched (DB:%u param:%u)\n",
5556 1.1 jonathan (u_int32_t)ntohl(sav->spi),
5557 1.134 ozaki (u_int32_t)ntohl(sa0->sadb_sa_spi));
5558 1.174 ozaki error = EINVAL;
5559 1.174 ozaki goto error;
5560 1.1 jonathan }
5561 1.1 jonathan #endif
5562 1.1 jonathan if (sav->pid != mhp->msg->sadb_msg_pid) {
5563 1.134 ozaki IPSECLOG(LOG_DEBUG, "pid mismatched (DB:%u param:%u)\n",
5564 1.134 ozaki sav->pid, mhp->msg->sadb_msg_pid);
5565 1.174 ozaki error = EINVAL;
5566 1.174 ozaki goto error;
5567 1.1 jonathan }
5568 1.1 jonathan
5569 1.167 ozaki /*
5570 1.167 ozaki * Allocate a new SA instead of modifying the existing SA directly
5571 1.167 ozaki * to avoid race conditions.
5572 1.167 ozaki */
5573 1.167 ozaki newsav = kmem_zalloc(sizeof(struct secasvar), KM_SLEEP);
5574 1.167 ozaki
5575 1.1 jonathan /* copy sav values */
5576 1.167 ozaki newsav->spi = sav->spi;
5577 1.167 ozaki newsav->seq = sav->seq;
5578 1.167 ozaki newsav->created = sav->created;
5579 1.167 ozaki newsav->pid = sav->pid;
5580 1.171 ozaki newsav->sah = sav->sah;
5581 1.167 ozaki
5582 1.167 ozaki error = key_setsaval(newsav, m, mhp);
5583 1.1 jonathan if (error) {
5584 1.171 ozaki key_delsav(newsav);
5585 1.174 ozaki goto error;
5586 1.167 ozaki }
5587 1.167 ozaki
5588 1.167 ozaki error = key_handle_natt_info(newsav, mhp);
5589 1.167 ozaki if (error != 0) {
5590 1.171 ozaki key_delsav(newsav);
5591 1.174 ozaki goto error;
5592 1.1 jonathan }
5593 1.1 jonathan
5594 1.171 ozaki error = key_init_xform(newsav);
5595 1.166 ozaki if (error != 0) {
5596 1.171 ozaki key_delsav(newsav);
5597 1.174 ozaki goto error;
5598 1.1 jonathan }
5599 1.1 jonathan
5600 1.223 ozaki /* Add to sah#savlist */
5601 1.223 ozaki key_init_sav(newsav);
5602 1.171 ozaki newsav->state = SADB_SASTATE_MATURE;
5603 1.212 ozaki mutex_enter(&key_sad.lock);
5604 1.203 ozaki SAVLIST_WRITER_INSERT_TAIL(sah, SADB_SASTATE_MATURE, newsav);
5605 1.212 ozaki mutex_exit(&key_sad.lock);
5606 1.183 ozaki key_validate_savlist(sah, SADB_SASTATE_MATURE);
5607 1.171 ozaki
5608 1.216 ozaki key_sah_unref(sah);
5609 1.216 ozaki sah = NULL;
5610 1.216 ozaki
5611 1.223 ozaki key_destroy_sav_with_ref(sav);
5612 1.223 ozaki sav = NULL;
5613 1.223 ozaki
5614 1.1 jonathan {
5615 1.1 jonathan struct mbuf *n;
5616 1.1 jonathan
5617 1.1 jonathan /* set msg buf from mhp */
5618 1.1 jonathan n = key_getmsgbuf_x1(m, mhp);
5619 1.1 jonathan if (n == NULL) {
5620 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
5621 1.1 jonathan return key_senderror(so, m, ENOBUFS);
5622 1.1 jonathan }
5623 1.1 jonathan
5624 1.1 jonathan m_freem(m);
5625 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
5626 1.1 jonathan }
5627 1.174 ozaki error:
5628 1.206 ozaki KEY_SA_UNREF(&sav);
5629 1.216 ozaki error_sah:
5630 1.216 ozaki key_sah_unref(sah);
5631 1.174 ozaki return key_senderror(so, m, error);
5632 1.1 jonathan }
5633 1.1 jonathan
5634 1.1 jonathan /*
5635 1.1 jonathan * search SAD with sequence for a SA which state is SADB_SASTATE_LARVAL.
5636 1.162 ozaki * only called by key_api_update().
5637 1.1 jonathan * OUT:
5638 1.1 jonathan * NULL : not found
5639 1.1 jonathan * others : found, pointer to a SA.
5640 1.1 jonathan */
5641 1.1 jonathan #ifdef IPSEC_DOSEQCHECK
5642 1.1 jonathan static struct secasvar *
5643 1.49 degroote key_getsavbyseq(struct secashead *sah, u_int32_t seq)
5644 1.1 jonathan {
5645 1.1 jonathan struct secasvar *sav;
5646 1.1 jonathan u_int state;
5647 1.205 ozaki int s;
5648 1.1 jonathan
5649 1.1 jonathan state = SADB_SASTATE_LARVAL;
5650 1.1 jonathan
5651 1.1 jonathan /* search SAD with sequence number ? */
5652 1.205 ozaki s = pserialize_read_enter();
5653 1.203 ozaki SAVLIST_READER_FOREACH(sav, sah, state) {
5654 1.134 ozaki KEY_CHKSASTATE(state, sav->state);
5655 1.1 jonathan
5656 1.1 jonathan if (sav->seq == seq) {
5657 1.1 jonathan SA_ADDREF(sav);
5658 1.111 ozaki KEYDEBUG_PRINTF(KEYDEBUG_IPSEC_STAMP,
5659 1.111 ozaki "DP cause refcnt++:%d SA:%p\n",
5660 1.217 ozaki key_sa_refcnt(sav), sav);
5661 1.205 ozaki break;
5662 1.1 jonathan }
5663 1.1 jonathan }
5664 1.205 ozaki pserialize_read_exit(s);
5665 1.1 jonathan
5666 1.205 ozaki return sav;
5667 1.1 jonathan }
5668 1.1 jonathan #endif
5669 1.1 jonathan
5670 1.1 jonathan /*
5671 1.1 jonathan * SADB_ADD processing
5672 1.1 jonathan * add an entry to SA database, when received
5673 1.1 jonathan * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
5674 1.1 jonathan * key(AE), (identity(SD),) (sensitivity)>
5675 1.1 jonathan * from the ikmpd,
5676 1.1 jonathan * and send
5677 1.1 jonathan * <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
5678 1.1 jonathan * (identity(SD),) (sensitivity)>
5679 1.1 jonathan * to the ikmpd.
5680 1.1 jonathan *
5681 1.1 jonathan * IGNORE identity and sensitivity messages.
5682 1.1 jonathan *
5683 1.1 jonathan * m will always be freed.
5684 1.1 jonathan */
5685 1.1 jonathan static int
5686 1.162 ozaki key_api_add(struct socket *so, struct mbuf *m,
5687 1.49 degroote const struct sadb_msghdr *mhp)
5688 1.1 jonathan {
5689 1.1 jonathan struct sadb_sa *sa0;
5690 1.151 ozaki const struct sockaddr *src, *dst;
5691 1.1 jonathan struct secasindex saidx;
5692 1.204 ozaki struct secashead *sah;
5693 1.1 jonathan struct secasvar *newsav;
5694 1.1 jonathan u_int16_t proto;
5695 1.1 jonathan u_int8_t mode;
5696 1.34 degroote u_int16_t reqid;
5697 1.1 jonathan int error;
5698 1.1 jonathan
5699 1.1 jonathan /* map satype to proto */
5700 1.137 ozaki proto = key_satype2proto(mhp->msg->sadb_msg_satype);
5701 1.137 ozaki if (proto == 0) {
5702 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
5703 1.1 jonathan return key_senderror(so, m, EINVAL);
5704 1.1 jonathan }
5705 1.1 jonathan
5706 1.1 jonathan if (mhp->ext[SADB_EXT_SA] == NULL ||
5707 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5708 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
5709 1.1 jonathan (mhp->msg->sadb_msg_satype == SADB_SATYPE_ESP &&
5710 1.1 jonathan mhp->ext[SADB_EXT_KEY_ENCRYPT] == NULL) ||
5711 1.1 jonathan (mhp->msg->sadb_msg_satype == SADB_SATYPE_AH &&
5712 1.1 jonathan mhp->ext[SADB_EXT_KEY_AUTH] == NULL) ||
5713 1.1 jonathan (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL &&
5714 1.1 jonathan mhp->ext[SADB_EXT_LIFETIME_SOFT] == NULL) ||
5715 1.1 jonathan (mhp->ext[SADB_EXT_LIFETIME_HARD] == NULL &&
5716 1.1 jonathan mhp->ext[SADB_EXT_LIFETIME_SOFT] != NULL)) {
5717 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5718 1.1 jonathan return key_senderror(so, m, EINVAL);
5719 1.1 jonathan }
5720 1.1 jonathan if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
5721 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5722 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5723 1.1 jonathan /* XXX need more */
5724 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5725 1.1 jonathan return key_senderror(so, m, EINVAL);
5726 1.1 jonathan }
5727 1.1 jonathan if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
5728 1.230 christos const struct sadb_x_sa2 *sa2 = mhp->ext[SADB_X_EXT_SA2];
5729 1.230 christos mode = sa2->sadb_x_sa2_mode;
5730 1.230 christos reqid = sa2->sadb_x_sa2_reqid;
5731 1.1 jonathan } else {
5732 1.1 jonathan mode = IPSEC_MODE_ANY;
5733 1.1 jonathan reqid = 0;
5734 1.1 jonathan }
5735 1.1 jonathan
5736 1.230 christos sa0 = mhp->ext[SADB_EXT_SA];
5737 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
5738 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
5739 1.1 jonathan
5740 1.151 ozaki error = key_setsecasidx(proto, mode, reqid, src, dst, &saidx);
5741 1.137 ozaki if (error != 0)
5742 1.48 degroote return key_senderror(so, m, EINVAL);
5743 1.1 jonathan
5744 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
5745 1.137 ozaki if (error != 0)
5746 1.64 spz return key_senderror(so, m, EINVAL);
5747 1.64 spz
5748 1.1 jonathan /* get a SA header */
5749 1.216 ozaki sah = key_getsah_ref(&saidx, CMP_REQID);
5750 1.204 ozaki if (sah == NULL) {
5751 1.1 jonathan /* create a new SA header */
5752 1.204 ozaki sah = key_newsah(&saidx);
5753 1.204 ozaki if (sah == NULL) {
5754 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
5755 1.1 jonathan return key_senderror(so, m, ENOBUFS);
5756 1.1 jonathan }
5757 1.1 jonathan }
5758 1.1 jonathan
5759 1.1 jonathan /* set spidx if there */
5760 1.1 jonathan /* XXX rewrite */
5761 1.204 ozaki error = key_setident(sah, m, mhp);
5762 1.216 ozaki if (error)
5763 1.216 ozaki goto error;
5764 1.1 jonathan
5765 1.174 ozaki {
5766 1.174 ozaki struct secasvar *sav;
5767 1.174 ozaki
5768 1.1 jonathan /* We can create new SA only if SPI is differenct. */
5769 1.204 ozaki sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
5770 1.174 ozaki if (sav != NULL) {
5771 1.206 ozaki KEY_SA_UNREF(&sav);
5772 1.134 ozaki IPSECLOG(LOG_DEBUG, "SA already exists.\n");
5773 1.216 ozaki error = EEXIST;
5774 1.216 ozaki goto error;
5775 1.1 jonathan }
5776 1.174 ozaki }
5777 1.174 ozaki
5778 1.174 ozaki /* create new SA entry. */
5779 1.171 ozaki newsav = KEY_NEWSAV(m, mhp, &error);
5780 1.216 ozaki if (newsav == NULL)
5781 1.216 ozaki goto error;
5782 1.204 ozaki newsav->sah = sah;
5783 1.1 jonathan
5784 1.137 ozaki error = key_handle_natt_info(newsav, mhp);
5785 1.170 ozaki if (error != 0) {
5786 1.171 ozaki key_delsav(newsav);
5787 1.216 ozaki error = EINVAL;
5788 1.216 ozaki goto error;
5789 1.170 ozaki }
5790 1.64 spz
5791 1.171 ozaki error = key_init_xform(newsav);
5792 1.137 ozaki if (error != 0) {
5793 1.171 ozaki key_delsav(newsav);
5794 1.216 ozaki goto error;
5795 1.1 jonathan }
5796 1.1 jonathan
5797 1.223 ozaki /* Add to sah#savlist */
5798 1.223 ozaki key_init_sav(newsav);
5799 1.171 ozaki newsav->state = SADB_SASTATE_MATURE;
5800 1.212 ozaki mutex_enter(&key_sad.lock);
5801 1.204 ozaki SAVLIST_WRITER_INSERT_TAIL(sah, SADB_SASTATE_MATURE, newsav);
5802 1.212 ozaki mutex_exit(&key_sad.lock);
5803 1.204 ozaki key_validate_savlist(sah, SADB_SASTATE_MATURE);
5804 1.171 ozaki
5805 1.216 ozaki key_sah_unref(sah);
5806 1.216 ozaki sah = NULL;
5807 1.216 ozaki
5808 1.1 jonathan /*
5809 1.1 jonathan * don't call key_freesav() here, as we would like to keep the SA
5810 1.1 jonathan * in the database on success.
5811 1.1 jonathan */
5812 1.1 jonathan
5813 1.1 jonathan {
5814 1.1 jonathan struct mbuf *n;
5815 1.1 jonathan
5816 1.1 jonathan /* set msg buf from mhp */
5817 1.1 jonathan n = key_getmsgbuf_x1(m, mhp);
5818 1.1 jonathan if (n == NULL) {
5819 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
5820 1.1 jonathan return key_senderror(so, m, ENOBUFS);
5821 1.1 jonathan }
5822 1.1 jonathan
5823 1.1 jonathan m_freem(m);
5824 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
5825 1.1 jonathan }
5826 1.216 ozaki error:
5827 1.216 ozaki key_sah_unref(sah);
5828 1.216 ozaki return key_senderror(so, m, error);
5829 1.1 jonathan }
5830 1.1 jonathan
5831 1.1 jonathan /* m is retained */
5832 1.1 jonathan static int
5833 1.49 degroote key_setident(struct secashead *sah, struct mbuf *m,
5834 1.49 degroote const struct sadb_msghdr *mhp)
5835 1.1 jonathan {
5836 1.1 jonathan const struct sadb_ident *idsrc, *iddst;
5837 1.1 jonathan int idsrclen, iddstlen;
5838 1.1 jonathan
5839 1.132 ozaki KASSERT(!cpu_softintr_p());
5840 1.112 ozaki KASSERT(sah != NULL);
5841 1.112 ozaki KASSERT(m != NULL);
5842 1.112 ozaki KASSERT(mhp != NULL);
5843 1.112 ozaki KASSERT(mhp->msg != NULL);
5844 1.1 jonathan
5845 1.129 ozaki /*
5846 1.162 ozaki * Can be called with an existing sah from key_api_update().
5847 1.129 ozaki */
5848 1.129 ozaki if (sah->idents != NULL) {
5849 1.132 ozaki kmem_free(sah->idents, sah->idents_len);
5850 1.129 ozaki sah->idents = NULL;
5851 1.132 ozaki sah->idents_len = 0;
5852 1.129 ozaki }
5853 1.129 ozaki if (sah->identd != NULL) {
5854 1.132 ozaki kmem_free(sah->identd, sah->identd_len);
5855 1.129 ozaki sah->identd = NULL;
5856 1.132 ozaki sah->identd_len = 0;
5857 1.129 ozaki }
5858 1.129 ozaki
5859 1.1 jonathan /* don't make buffer if not there */
5860 1.1 jonathan if (mhp->ext[SADB_EXT_IDENTITY_SRC] == NULL &&
5861 1.1 jonathan mhp->ext[SADB_EXT_IDENTITY_DST] == NULL) {
5862 1.1 jonathan sah->idents = NULL;
5863 1.1 jonathan sah->identd = NULL;
5864 1.1 jonathan return 0;
5865 1.1 jonathan }
5866 1.22 perry
5867 1.1 jonathan if (mhp->ext[SADB_EXT_IDENTITY_SRC] == NULL ||
5868 1.1 jonathan mhp->ext[SADB_EXT_IDENTITY_DST] == NULL) {
5869 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid identity.\n");
5870 1.1 jonathan return EINVAL;
5871 1.1 jonathan }
5872 1.1 jonathan
5873 1.230 christos idsrc = mhp->ext[SADB_EXT_IDENTITY_SRC];
5874 1.230 christos iddst = mhp->ext[SADB_EXT_IDENTITY_DST];
5875 1.1 jonathan idsrclen = mhp->extlen[SADB_EXT_IDENTITY_SRC];
5876 1.1 jonathan iddstlen = mhp->extlen[SADB_EXT_IDENTITY_DST];
5877 1.1 jonathan
5878 1.1 jonathan /* validity check */
5879 1.1 jonathan if (idsrc->sadb_ident_type != iddst->sadb_ident_type) {
5880 1.134 ozaki IPSECLOG(LOG_DEBUG, "ident type mismatch.\n");
5881 1.1 jonathan return EINVAL;
5882 1.1 jonathan }
5883 1.1 jonathan
5884 1.1 jonathan switch (idsrc->sadb_ident_type) {
5885 1.1 jonathan case SADB_IDENTTYPE_PREFIX:
5886 1.1 jonathan case SADB_IDENTTYPE_FQDN:
5887 1.1 jonathan case SADB_IDENTTYPE_USERFQDN:
5888 1.1 jonathan default:
5889 1.1 jonathan /* XXX do nothing */
5890 1.1 jonathan sah->idents = NULL;
5891 1.1 jonathan sah->identd = NULL;
5892 1.1 jonathan return 0;
5893 1.1 jonathan }
5894 1.1 jonathan
5895 1.1 jonathan /* make structure */
5896 1.132 ozaki sah->idents = kmem_alloc(idsrclen, KM_SLEEP);
5897 1.132 ozaki sah->idents_len = idsrclen;
5898 1.132 ozaki sah->identd = kmem_alloc(iddstlen, KM_SLEEP);
5899 1.132 ozaki sah->identd_len = iddstlen;
5900 1.49 degroote memcpy(sah->idents, idsrc, idsrclen);
5901 1.49 degroote memcpy(sah->identd, iddst, iddstlen);
5902 1.1 jonathan
5903 1.1 jonathan return 0;
5904 1.1 jonathan }
5905 1.1 jonathan
5906 1.1 jonathan /*
5907 1.240 ozaki * m will not be freed on return. It may return NULL.
5908 1.22 perry * it is caller's responsibility to free the result.
5909 1.1 jonathan */
5910 1.1 jonathan static struct mbuf *
5911 1.49 degroote key_getmsgbuf_x1(struct mbuf *m, const struct sadb_msghdr *mhp)
5912 1.1 jonathan {
5913 1.1 jonathan struct mbuf *n;
5914 1.1 jonathan
5915 1.112 ozaki KASSERT(m != NULL);
5916 1.112 ozaki KASSERT(mhp != NULL);
5917 1.112 ozaki KASSERT(mhp->msg != NULL);
5918 1.1 jonathan
5919 1.1 jonathan /* create new sadb_msg to reply. */
5920 1.93 christos n = key_gather_mbuf(m, mhp, 1, 15, SADB_EXT_RESERVED,
5921 1.1 jonathan SADB_EXT_SA, SADB_X_EXT_SA2,
5922 1.1 jonathan SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST,
5923 1.1 jonathan SADB_EXT_LIFETIME_HARD, SADB_EXT_LIFETIME_SOFT,
5924 1.93 christos SADB_EXT_IDENTITY_SRC, SADB_EXT_IDENTITY_DST,
5925 1.93 christos SADB_X_EXT_NAT_T_TYPE, SADB_X_EXT_NAT_T_SPORT,
5926 1.93 christos SADB_X_EXT_NAT_T_DPORT, SADB_X_EXT_NAT_T_OAI,
5927 1.93 christos SADB_X_EXT_NAT_T_OAR, SADB_X_EXT_NAT_T_FRAG);
5928 1.1 jonathan
5929 1.1 jonathan if (n->m_len < sizeof(struct sadb_msg)) {
5930 1.1 jonathan n = m_pullup(n, sizeof(struct sadb_msg));
5931 1.1 jonathan if (n == NULL)
5932 1.1 jonathan return NULL;
5933 1.1 jonathan }
5934 1.1 jonathan mtod(n, struct sadb_msg *)->sadb_msg_errno = 0;
5935 1.1 jonathan mtod(n, struct sadb_msg *)->sadb_msg_len =
5936 1.1 jonathan PFKEY_UNIT64(n->m_pkthdr.len);
5937 1.1 jonathan
5938 1.1 jonathan return n;
5939 1.1 jonathan }
5940 1.1 jonathan
5941 1.49 degroote static int key_delete_all (struct socket *, struct mbuf *,
5942 1.49 degroote const struct sadb_msghdr *, u_int16_t);
5943 1.1 jonathan
5944 1.1 jonathan /*
5945 1.1 jonathan * SADB_DELETE processing
5946 1.1 jonathan * receive
5947 1.1 jonathan * <base, SA(*), address(SD)>
5948 1.1 jonathan * from the ikmpd, and set SADB_SASTATE_DEAD,
5949 1.1 jonathan * and send,
5950 1.1 jonathan * <base, SA(*), address(SD)>
5951 1.1 jonathan * to the ikmpd.
5952 1.1 jonathan *
5953 1.1 jonathan * m will always be freed.
5954 1.1 jonathan */
5955 1.1 jonathan static int
5956 1.162 ozaki key_api_delete(struct socket *so, struct mbuf *m,
5957 1.49 degroote const struct sadb_msghdr *mhp)
5958 1.1 jonathan {
5959 1.1 jonathan struct sadb_sa *sa0;
5960 1.151 ozaki const struct sockaddr *src, *dst;
5961 1.1 jonathan struct secasindex saidx;
5962 1.1 jonathan struct secashead *sah;
5963 1.1 jonathan struct secasvar *sav = NULL;
5964 1.1 jonathan u_int16_t proto;
5965 1.48 degroote int error;
5966 1.1 jonathan
5967 1.1 jonathan /* map satype to proto */
5968 1.137 ozaki proto = key_satype2proto(mhp->msg->sadb_msg_satype);
5969 1.137 ozaki if (proto == 0) {
5970 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
5971 1.1 jonathan return key_senderror(so, m, EINVAL);
5972 1.1 jonathan }
5973 1.1 jonathan
5974 1.1 jonathan if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5975 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
5976 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5977 1.1 jonathan return key_senderror(so, m, EINVAL);
5978 1.1 jonathan }
5979 1.1 jonathan
5980 1.1 jonathan if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5981 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5982 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5983 1.1 jonathan return key_senderror(so, m, EINVAL);
5984 1.1 jonathan }
5985 1.1 jonathan
5986 1.1 jonathan if (mhp->ext[SADB_EXT_SA] == NULL) {
5987 1.1 jonathan /*
5988 1.1 jonathan * Caller wants us to delete all non-LARVAL SAs
5989 1.1 jonathan * that match the src/dst. This is used during
5990 1.1 jonathan * IKE INITIAL-CONTACT.
5991 1.1 jonathan */
5992 1.134 ozaki IPSECLOG(LOG_DEBUG, "doing delete all.\n");
5993 1.1 jonathan return key_delete_all(so, m, mhp, proto);
5994 1.1 jonathan } else if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa)) {
5995 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
5996 1.1 jonathan return key_senderror(so, m, EINVAL);
5997 1.1 jonathan }
5998 1.1 jonathan
5999 1.230 christos sa0 = mhp->ext[SADB_EXT_SA];
6000 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
6001 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
6002 1.1 jonathan
6003 1.151 ozaki error = key_setsecasidx(proto, IPSEC_MODE_ANY, 0, src, dst, &saidx);
6004 1.137 ozaki if (error != 0)
6005 1.48 degroote return key_senderror(so, m, EINVAL);
6006 1.1 jonathan
6007 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
6008 1.137 ozaki if (error != 0)
6009 1.64 spz return key_senderror(so, m, EINVAL);
6010 1.64 spz
6011 1.1 jonathan /* get a SA header */
6012 1.216 ozaki sah = key_getsah_ref(&saidx, CMP_HEAD);
6013 1.155 ozaki if (sah != NULL) {
6014 1.1 jonathan /* get a SA with SPI. */
6015 1.1 jonathan sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
6016 1.216 ozaki key_sah_unref(sah);
6017 1.1 jonathan }
6018 1.155 ozaki
6019 1.155 ozaki if (sav == NULL) {
6020 1.134 ozaki IPSECLOG(LOG_DEBUG, "no SA found.\n");
6021 1.1 jonathan return key_senderror(so, m, ENOENT);
6022 1.1 jonathan }
6023 1.1 jonathan
6024 1.223 ozaki key_destroy_sav_with_ref(sav);
6025 1.223 ozaki sav = NULL;
6026 1.1 jonathan
6027 1.1 jonathan {
6028 1.1 jonathan struct mbuf *n;
6029 1.1 jonathan
6030 1.1 jonathan /* create new sadb_msg to reply. */
6031 1.1 jonathan n = key_gather_mbuf(m, mhp, 1, 4, SADB_EXT_RESERVED,
6032 1.1 jonathan SADB_EXT_SA, SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
6033 1.1 jonathan if (!n)
6034 1.1 jonathan return key_senderror(so, m, ENOBUFS);
6035 1.1 jonathan
6036 1.158 ozaki n = key_fill_replymsg(n, 0);
6037 1.158 ozaki if (n == NULL)
6038 1.158 ozaki return key_senderror(so, m, ENOBUFS);
6039 1.1 jonathan
6040 1.1 jonathan m_freem(m);
6041 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
6042 1.1 jonathan }
6043 1.1 jonathan }
6044 1.1 jonathan
6045 1.1 jonathan /*
6046 1.162 ozaki * delete all SAs for src/dst. Called from key_api_delete().
6047 1.1 jonathan */
6048 1.1 jonathan static int
6049 1.49 degroote key_delete_all(struct socket *so, struct mbuf *m,
6050 1.49 degroote const struct sadb_msghdr *mhp, u_int16_t proto)
6051 1.1 jonathan {
6052 1.151 ozaki const struct sockaddr *src, *dst;
6053 1.1 jonathan struct secasindex saidx;
6054 1.1 jonathan struct secashead *sah;
6055 1.203 ozaki struct secasvar *sav;
6056 1.120 ozaki u_int state;
6057 1.48 degroote int error;
6058 1.1 jonathan
6059 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
6060 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
6061 1.1 jonathan
6062 1.151 ozaki error = key_setsecasidx(proto, IPSEC_MODE_ANY, 0, src, dst, &saidx);
6063 1.137 ozaki if (error != 0)
6064 1.48 degroote return key_senderror(so, m, EINVAL);
6065 1.1 jonathan
6066 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
6067 1.137 ozaki if (error != 0)
6068 1.64 spz return key_senderror(so, m, EINVAL);
6069 1.64 spz
6070 1.216 ozaki sah = key_getsah_ref(&saidx, CMP_HEAD);
6071 1.155 ozaki if (sah != NULL) {
6072 1.1 jonathan /* Delete all non-LARVAL SAs. */
6073 1.120 ozaki SASTATE_ALIVE_FOREACH(state) {
6074 1.1 jonathan if (state == SADB_SASTATE_LARVAL)
6075 1.1 jonathan continue;
6076 1.203 ozaki restart:
6077 1.223 ozaki mutex_enter(&key_sad.lock);
6078 1.203 ozaki SAVLIST_WRITER_FOREACH(sav, sah, state) {
6079 1.223 ozaki sav->state = SADB_SASTATE_DEAD;
6080 1.223 ozaki key_unlink_sav(sav);
6081 1.223 ozaki mutex_exit(&key_sad.lock);
6082 1.223 ozaki key_destroy_sav(sav);
6083 1.203 ozaki goto restart;
6084 1.1 jonathan }
6085 1.223 ozaki mutex_exit(&key_sad.lock);
6086 1.1 jonathan }
6087 1.216 ozaki key_sah_unref(sah);
6088 1.1 jonathan }
6089 1.1 jonathan {
6090 1.1 jonathan struct mbuf *n;
6091 1.1 jonathan
6092 1.1 jonathan /* create new sadb_msg to reply. */
6093 1.1 jonathan n = key_gather_mbuf(m, mhp, 1, 3, SADB_EXT_RESERVED,
6094 1.1 jonathan SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
6095 1.1 jonathan if (!n)
6096 1.1 jonathan return key_senderror(so, m, ENOBUFS);
6097 1.1 jonathan
6098 1.158 ozaki n = key_fill_replymsg(n, 0);
6099 1.158 ozaki if (n == NULL)
6100 1.158 ozaki return key_senderror(so, m, ENOBUFS);
6101 1.1 jonathan
6102 1.1 jonathan m_freem(m);
6103 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
6104 1.1 jonathan }
6105 1.1 jonathan }
6106 1.1 jonathan
6107 1.1 jonathan /*
6108 1.1 jonathan * SADB_GET processing
6109 1.1 jonathan * receive
6110 1.1 jonathan * <base, SA(*), address(SD)>
6111 1.1 jonathan * from the ikmpd, and get a SP and a SA to respond,
6112 1.1 jonathan * and send,
6113 1.1 jonathan * <base, SA, (lifetime(HSC),) address(SD), (address(P),) key(AE),
6114 1.1 jonathan * (identity(SD),) (sensitivity)>
6115 1.1 jonathan * to the ikmpd.
6116 1.1 jonathan *
6117 1.1 jonathan * m will always be freed.
6118 1.1 jonathan */
6119 1.1 jonathan static int
6120 1.162 ozaki key_api_get(struct socket *so, struct mbuf *m,
6121 1.79 gdt const struct sadb_msghdr *mhp)
6122 1.1 jonathan {
6123 1.1 jonathan struct sadb_sa *sa0;
6124 1.151 ozaki const struct sockaddr *src, *dst;
6125 1.1 jonathan struct secasindex saidx;
6126 1.1 jonathan struct secasvar *sav = NULL;
6127 1.1 jonathan u_int16_t proto;
6128 1.48 degroote int error;
6129 1.1 jonathan
6130 1.1 jonathan /* map satype to proto */
6131 1.1 jonathan if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
6132 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
6133 1.1 jonathan return key_senderror(so, m, EINVAL);
6134 1.1 jonathan }
6135 1.1 jonathan
6136 1.1 jonathan if (mhp->ext[SADB_EXT_SA] == NULL ||
6137 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
6138 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
6139 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
6140 1.1 jonathan return key_senderror(so, m, EINVAL);
6141 1.1 jonathan }
6142 1.1 jonathan if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
6143 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
6144 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
6145 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
6146 1.1 jonathan return key_senderror(so, m, EINVAL);
6147 1.1 jonathan }
6148 1.1 jonathan
6149 1.230 christos sa0 = mhp->ext[SADB_EXT_SA];
6150 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
6151 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
6152 1.1 jonathan
6153 1.151 ozaki error = key_setsecasidx(proto, IPSEC_MODE_ANY, 0, src, dst, &saidx);
6154 1.137 ozaki if (error != 0)
6155 1.48 degroote return key_senderror(so, m, EINVAL);
6156 1.1 jonathan
6157 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
6158 1.137 ozaki if (error != 0)
6159 1.64 spz return key_senderror(so, m, EINVAL);
6160 1.64 spz
6161 1.1 jonathan /* get a SA header */
6162 1.216 ozaki {
6163 1.216 ozaki struct secashead *sah;
6164 1.216 ozaki int s = pserialize_read_enter();
6165 1.216 ozaki
6166 1.155 ozaki sah = key_getsah(&saidx, CMP_HEAD);
6167 1.155 ozaki if (sah != NULL) {
6168 1.1 jonathan /* get a SA with SPI. */
6169 1.1 jonathan sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
6170 1.1 jonathan }
6171 1.216 ozaki pserialize_read_exit(s);
6172 1.216 ozaki }
6173 1.155 ozaki if (sav == NULL) {
6174 1.134 ozaki IPSECLOG(LOG_DEBUG, "no SA found.\n");
6175 1.1 jonathan return key_senderror(so, m, ENOENT);
6176 1.1 jonathan }
6177 1.1 jonathan
6178 1.1 jonathan {
6179 1.1 jonathan struct mbuf *n;
6180 1.1 jonathan u_int8_t satype;
6181 1.1 jonathan
6182 1.1 jonathan /* map proto to satype */
6183 1.216 ozaki satype = key_proto2satype(sav->sah->saidx.proto);
6184 1.137 ozaki if (satype == 0) {
6185 1.206 ozaki KEY_SA_UNREF(&sav);
6186 1.134 ozaki IPSECLOG(LOG_DEBUG, "there was invalid proto in SAD.\n");
6187 1.1 jonathan return key_senderror(so, m, EINVAL);
6188 1.1 jonathan }
6189 1.1 jonathan
6190 1.1 jonathan /* create new sadb_msg to reply. */
6191 1.1 jonathan n = key_setdumpsa(sav, SADB_GET, satype, mhp->msg->sadb_msg_seq,
6192 1.1 jonathan mhp->msg->sadb_msg_pid);
6193 1.206 ozaki KEY_SA_UNREF(&sav);
6194 1.1 jonathan if (!n)
6195 1.1 jonathan return key_senderror(so, m, ENOBUFS);
6196 1.1 jonathan
6197 1.1 jonathan m_freem(m);
6198 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
6199 1.1 jonathan }
6200 1.1 jonathan }
6201 1.1 jonathan
6202 1.1 jonathan /* XXX make it sysctl-configurable? */
6203 1.1 jonathan static void
6204 1.49 degroote key_getcomb_setlifetime(struct sadb_comb *comb)
6205 1.1 jonathan {
6206 1.1 jonathan
6207 1.1 jonathan comb->sadb_comb_soft_allocations = 1;
6208 1.1 jonathan comb->sadb_comb_hard_allocations = 1;
6209 1.1 jonathan comb->sadb_comb_soft_bytes = 0;
6210 1.1 jonathan comb->sadb_comb_hard_bytes = 0;
6211 1.1 jonathan comb->sadb_comb_hard_addtime = 86400; /* 1 day */
6212 1.192 ozaki comb->sadb_comb_soft_addtime = comb->sadb_comb_hard_addtime * 80 / 100;
6213 1.192 ozaki comb->sadb_comb_hard_usetime = 28800; /* 8 hours */
6214 1.192 ozaki comb->sadb_comb_soft_usetime = comb->sadb_comb_hard_usetime * 80 / 100;
6215 1.1 jonathan }
6216 1.1 jonathan
6217 1.1 jonathan /*
6218 1.1 jonathan * XXX reorder combinations by preference
6219 1.1 jonathan * XXX no idea if the user wants ESP authentication or not
6220 1.1 jonathan */
6221 1.1 jonathan static struct mbuf *
6222 1.239 ozaki key_getcomb_esp(int mflag)
6223 1.1 jonathan {
6224 1.1 jonathan struct sadb_comb *comb;
6225 1.65 drochner const struct enc_xform *algo;
6226 1.1 jonathan struct mbuf *result = NULL, *m, *n;
6227 1.1 jonathan int encmin;
6228 1.1 jonathan int i, off, o;
6229 1.1 jonathan int totlen;
6230 1.1 jonathan const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
6231 1.1 jonathan
6232 1.1 jonathan m = NULL;
6233 1.1 jonathan for (i = 1; i <= SADB_EALG_MAX; i++) {
6234 1.1 jonathan algo = esp_algorithm_lookup(i);
6235 1.1 jonathan if (algo == NULL)
6236 1.1 jonathan continue;
6237 1.1 jonathan
6238 1.1 jonathan /* discard algorithms with key size smaller than system min */
6239 1.1 jonathan if (_BITS(algo->maxkey) < ipsec_esp_keymin)
6240 1.1 jonathan continue;
6241 1.1 jonathan if (_BITS(algo->minkey) < ipsec_esp_keymin)
6242 1.1 jonathan encmin = ipsec_esp_keymin;
6243 1.1 jonathan else
6244 1.1 jonathan encmin = _BITS(algo->minkey);
6245 1.1 jonathan
6246 1.1 jonathan if (ipsec_esp_auth)
6247 1.239 ozaki m = key_getcomb_ah(mflag);
6248 1.1 jonathan else {
6249 1.108 ozaki KASSERTMSG(l <= MLEN,
6250 1.108 ozaki "l=%u > MLEN=%lu", l, (u_long) MLEN);
6251 1.239 ozaki MGET(m, mflag, MT_DATA);
6252 1.1 jonathan if (m) {
6253 1.1 jonathan M_ALIGN(m, l);
6254 1.1 jonathan m->m_len = l;
6255 1.1 jonathan m->m_next = NULL;
6256 1.49 degroote memset(mtod(m, void *), 0, m->m_len);
6257 1.1 jonathan }
6258 1.1 jonathan }
6259 1.1 jonathan if (!m)
6260 1.1 jonathan goto fail;
6261 1.1 jonathan
6262 1.1 jonathan totlen = 0;
6263 1.1 jonathan for (n = m; n; n = n->m_next)
6264 1.1 jonathan totlen += n->m_len;
6265 1.108 ozaki KASSERTMSG((totlen % l) == 0, "totlen=%u, l=%u", totlen, l);
6266 1.1 jonathan
6267 1.1 jonathan for (off = 0; off < totlen; off += l) {
6268 1.1 jonathan n = m_pulldown(m, off, l, &o);
6269 1.1 jonathan if (!n) {
6270 1.1 jonathan /* m is already freed */
6271 1.1 jonathan goto fail;
6272 1.1 jonathan }
6273 1.39 degroote comb = (struct sadb_comb *)(mtod(n, char *) + o);
6274 1.49 degroote memset(comb, 0, sizeof(*comb));
6275 1.1 jonathan key_getcomb_setlifetime(comb);
6276 1.1 jonathan comb->sadb_comb_encrypt = i;
6277 1.1 jonathan comb->sadb_comb_encrypt_minbits = encmin;
6278 1.1 jonathan comb->sadb_comb_encrypt_maxbits = _BITS(algo->maxkey);
6279 1.1 jonathan }
6280 1.1 jonathan
6281 1.1 jonathan if (!result)
6282 1.1 jonathan result = m;
6283 1.1 jonathan else
6284 1.1 jonathan m_cat(result, m);
6285 1.1 jonathan }
6286 1.1 jonathan
6287 1.1 jonathan return result;
6288 1.1 jonathan
6289 1.1 jonathan fail:
6290 1.1 jonathan if (result)
6291 1.1 jonathan m_freem(result);
6292 1.1 jonathan return NULL;
6293 1.1 jonathan }
6294 1.1 jonathan
6295 1.1 jonathan static void
6296 1.49 degroote key_getsizes_ah(const struct auth_hash *ah, int alg,
6297 1.49 degroote u_int16_t* ksmin, u_int16_t* ksmax)
6298 1.1 jonathan {
6299 1.25 christos *ksmin = *ksmax = ah->keysize;
6300 1.1 jonathan if (ah->keysize == 0) {
6301 1.1 jonathan /*
6302 1.1 jonathan * Transform takes arbitrary key size but algorithm
6303 1.1 jonathan * key size is restricted. Enforce this here.
6304 1.1 jonathan */
6305 1.1 jonathan switch (alg) {
6306 1.25 christos case SADB_X_AALG_MD5: *ksmin = *ksmax = 16; break;
6307 1.25 christos case SADB_X_AALG_SHA: *ksmin = *ksmax = 20; break;
6308 1.106 ozaki case SADB_X_AALG_NULL: *ksmin = 0; *ksmax = 256; break;
6309 1.1 jonathan default:
6310 1.136 ozaki IPSECLOG(LOG_DEBUG, "unknown AH algorithm %u\n", alg);
6311 1.1 jonathan break;
6312 1.1 jonathan }
6313 1.1 jonathan }
6314 1.1 jonathan }
6315 1.1 jonathan
6316 1.1 jonathan /*
6317 1.1 jonathan * XXX reorder combinations by preference
6318 1.1 jonathan */
6319 1.1 jonathan static struct mbuf *
6320 1.239 ozaki key_getcomb_ah(int mflag)
6321 1.1 jonathan {
6322 1.1 jonathan struct sadb_comb *comb;
6323 1.65 drochner const struct auth_hash *algo;
6324 1.1 jonathan struct mbuf *m;
6325 1.1 jonathan u_int16_t minkeysize, maxkeysize;
6326 1.1 jonathan int i;
6327 1.1 jonathan const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
6328 1.1 jonathan
6329 1.1 jonathan m = NULL;
6330 1.1 jonathan for (i = 1; i <= SADB_AALG_MAX; i++) {
6331 1.1 jonathan #if 1
6332 1.1 jonathan /* we prefer HMAC algorithms, not old algorithms */
6333 1.70 drochner if (i != SADB_AALG_SHA1HMAC &&
6334 1.70 drochner i != SADB_AALG_MD5HMAC &&
6335 1.70 drochner i != SADB_X_AALG_SHA2_256 &&
6336 1.70 drochner i != SADB_X_AALG_SHA2_384 &&
6337 1.70 drochner i != SADB_X_AALG_SHA2_512)
6338 1.1 jonathan continue;
6339 1.1 jonathan #endif
6340 1.1 jonathan algo = ah_algorithm_lookup(i);
6341 1.1 jonathan if (!algo)
6342 1.1 jonathan continue;
6343 1.1 jonathan key_getsizes_ah(algo, i, &minkeysize, &maxkeysize);
6344 1.1 jonathan /* discard algorithms with key size smaller than system min */
6345 1.1 jonathan if (_BITS(minkeysize) < ipsec_ah_keymin)
6346 1.1 jonathan continue;
6347 1.1 jonathan
6348 1.1 jonathan if (!m) {
6349 1.108 ozaki KASSERTMSG(l <= MLEN,
6350 1.108 ozaki "l=%u > MLEN=%lu", l, (u_long) MLEN);
6351 1.239 ozaki MGET(m, mflag, MT_DATA);
6352 1.1 jonathan if (m) {
6353 1.1 jonathan M_ALIGN(m, l);
6354 1.1 jonathan m->m_len = l;
6355 1.1 jonathan m->m_next = NULL;
6356 1.1 jonathan }
6357 1.1 jonathan } else
6358 1.239 ozaki M_PREPEND(m, l, mflag);
6359 1.1 jonathan if (!m)
6360 1.1 jonathan return NULL;
6361 1.1 jonathan
6362 1.164 ozaki if (m->m_len < sizeof(struct sadb_comb)) {
6363 1.164 ozaki m = m_pullup(m, sizeof(struct sadb_comb));
6364 1.164 ozaki if (m == NULL)
6365 1.164 ozaki return NULL;
6366 1.164 ozaki }
6367 1.164 ozaki
6368 1.1 jonathan comb = mtod(m, struct sadb_comb *);
6369 1.49 degroote memset(comb, 0, sizeof(*comb));
6370 1.1 jonathan key_getcomb_setlifetime(comb);
6371 1.1 jonathan comb->sadb_comb_auth = i;
6372 1.1 jonathan comb->sadb_comb_auth_minbits = _BITS(minkeysize);
6373 1.1 jonathan comb->sadb_comb_auth_maxbits = _BITS(maxkeysize);
6374 1.1 jonathan }
6375 1.1 jonathan
6376 1.1 jonathan return m;
6377 1.1 jonathan }
6378 1.1 jonathan
6379 1.1 jonathan /*
6380 1.1 jonathan * not really an official behavior. discussed in pf_key (at) inner.net in Sep2000.
6381 1.1 jonathan * XXX reorder combinations by preference
6382 1.1 jonathan */
6383 1.1 jonathan static struct mbuf *
6384 1.239 ozaki key_getcomb_ipcomp(int mflag)
6385 1.1 jonathan {
6386 1.1 jonathan struct sadb_comb *comb;
6387 1.65 drochner const struct comp_algo *algo;
6388 1.1 jonathan struct mbuf *m;
6389 1.1 jonathan int i;
6390 1.1 jonathan const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
6391 1.1 jonathan
6392 1.1 jonathan m = NULL;
6393 1.1 jonathan for (i = 1; i <= SADB_X_CALG_MAX; i++) {
6394 1.1 jonathan algo = ipcomp_algorithm_lookup(i);
6395 1.1 jonathan if (!algo)
6396 1.1 jonathan continue;
6397 1.1 jonathan
6398 1.1 jonathan if (!m) {
6399 1.108 ozaki KASSERTMSG(l <= MLEN,
6400 1.108 ozaki "l=%u > MLEN=%lu", l, (u_long) MLEN);
6401 1.239 ozaki MGET(m, mflag, MT_DATA);
6402 1.1 jonathan if (m) {
6403 1.1 jonathan M_ALIGN(m, l);
6404 1.1 jonathan m->m_len = l;
6405 1.1 jonathan m->m_next = NULL;
6406 1.1 jonathan }
6407 1.1 jonathan } else
6408 1.239 ozaki M_PREPEND(m, l, mflag);
6409 1.1 jonathan if (!m)
6410 1.1 jonathan return NULL;
6411 1.1 jonathan
6412 1.164 ozaki if (m->m_len < sizeof(struct sadb_comb)) {
6413 1.164 ozaki m = m_pullup(m, sizeof(struct sadb_comb));
6414 1.164 ozaki if (m == NULL)
6415 1.164 ozaki return NULL;
6416 1.164 ozaki }
6417 1.164 ozaki
6418 1.1 jonathan comb = mtod(m, struct sadb_comb *);
6419 1.49 degroote memset(comb, 0, sizeof(*comb));
6420 1.1 jonathan key_getcomb_setlifetime(comb);
6421 1.1 jonathan comb->sadb_comb_encrypt = i;
6422 1.1 jonathan /* what should we set into sadb_comb_*_{min,max}bits? */
6423 1.1 jonathan }
6424 1.1 jonathan
6425 1.1 jonathan return m;
6426 1.1 jonathan }
6427 1.1 jonathan
6428 1.1 jonathan /*
6429 1.1 jonathan * XXX no way to pass mode (transport/tunnel) to userland
6430 1.1 jonathan * XXX replay checking?
6431 1.1 jonathan * XXX sysctl interface to ipsec_{ah,esp}_keymin
6432 1.1 jonathan */
6433 1.1 jonathan static struct mbuf *
6434 1.239 ozaki key_getprop(const struct secasindex *saidx, int mflag)
6435 1.1 jonathan {
6436 1.1 jonathan struct sadb_prop *prop;
6437 1.1 jonathan struct mbuf *m, *n;
6438 1.1 jonathan const int l = PFKEY_ALIGN8(sizeof(struct sadb_prop));
6439 1.1 jonathan int totlen;
6440 1.1 jonathan
6441 1.1 jonathan switch (saidx->proto) {
6442 1.1 jonathan case IPPROTO_ESP:
6443 1.239 ozaki m = key_getcomb_esp(mflag);
6444 1.1 jonathan break;
6445 1.1 jonathan case IPPROTO_AH:
6446 1.239 ozaki m = key_getcomb_ah(mflag);
6447 1.1 jonathan break;
6448 1.1 jonathan case IPPROTO_IPCOMP:
6449 1.239 ozaki m = key_getcomb_ipcomp(mflag);
6450 1.1 jonathan break;
6451 1.1 jonathan default:
6452 1.1 jonathan return NULL;
6453 1.1 jonathan }
6454 1.1 jonathan
6455 1.1 jonathan if (!m)
6456 1.1 jonathan return NULL;
6457 1.239 ozaki M_PREPEND(m, l, mflag);
6458 1.1 jonathan if (!m)
6459 1.1 jonathan return NULL;
6460 1.1 jonathan
6461 1.1 jonathan totlen = 0;
6462 1.1 jonathan for (n = m; n; n = n->m_next)
6463 1.1 jonathan totlen += n->m_len;
6464 1.1 jonathan
6465 1.1 jonathan prop = mtod(m, struct sadb_prop *);
6466 1.49 degroote memset(prop, 0, sizeof(*prop));
6467 1.1 jonathan prop->sadb_prop_len = PFKEY_UNIT64(totlen);
6468 1.1 jonathan prop->sadb_prop_exttype = SADB_EXT_PROPOSAL;
6469 1.1 jonathan prop->sadb_prop_replay = 32; /* XXX */
6470 1.1 jonathan
6471 1.1 jonathan return m;
6472 1.1 jonathan }
6473 1.1 jonathan
6474 1.1 jonathan /*
6475 1.162 ozaki * SADB_ACQUIRE processing called by key_checkrequest() and key_api_acquire().
6476 1.1 jonathan * send
6477 1.1 jonathan * <base, SA, address(SD), (address(P)), x_policy,
6478 1.1 jonathan * (identity(SD),) (sensitivity,) proposal>
6479 1.1 jonathan * to KMD, and expect to receive
6480 1.7 wiz * <base> with SADB_ACQUIRE if error occurred,
6481 1.1 jonathan * or
6482 1.1 jonathan * <base, src address, dst address, (SPI range)> with SADB_GETSPI
6483 1.1 jonathan * from KMD by PF_KEY.
6484 1.1 jonathan *
6485 1.1 jonathan * XXX x_policy is outside of RFC2367 (KAME extension).
6486 1.1 jonathan * XXX sensitivity is not supported.
6487 1.1 jonathan * XXX for ipcomp, RFC2367 does not define how to fill in proposal.
6488 1.1 jonathan * see comment for key_getcomb_ipcomp().
6489 1.1 jonathan *
6490 1.1 jonathan * OUT:
6491 1.1 jonathan * 0 : succeed
6492 1.1 jonathan * others: error number
6493 1.1 jonathan */
6494 1.1 jonathan static int
6495 1.239 ozaki key_acquire(const struct secasindex *saidx, const struct secpolicy *sp, int mflag)
6496 1.1 jonathan {
6497 1.1 jonathan struct mbuf *result = NULL, *m;
6498 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
6499 1.1 jonathan struct secacq *newacq;
6500 1.1 jonathan #endif
6501 1.1 jonathan u_int8_t satype;
6502 1.1 jonathan int error = -1;
6503 1.1 jonathan u_int32_t seq;
6504 1.1 jonathan
6505 1.1 jonathan /* sanity check */
6506 1.108 ozaki KASSERT(saidx != NULL);
6507 1.1 jonathan satype = key_proto2satype(saidx->proto);
6508 1.108 ozaki KASSERTMSG(satype != 0, "null satype, protocol %u", saidx->proto);
6509 1.1 jonathan
6510 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
6511 1.1 jonathan /*
6512 1.1 jonathan * We never do anything about acquirng SA. There is anather
6513 1.1 jonathan * solution that kernel blocks to send SADB_ACQUIRE message until
6514 1.1 jonathan * getting something message from IKEd. In later case, to be
6515 1.1 jonathan * managed with ACQUIRING list.
6516 1.1 jonathan */
6517 1.1 jonathan /* Get an entry to check whether sending message or not. */
6518 1.208 ozaki mutex_enter(&key_misc.lock);
6519 1.137 ozaki newacq = key_getacq(saidx);
6520 1.137 ozaki if (newacq != NULL) {
6521 1.1 jonathan if (key_blockacq_count < newacq->count) {
6522 1.1 jonathan /* reset counter and do send message. */
6523 1.1 jonathan newacq->count = 0;
6524 1.1 jonathan } else {
6525 1.1 jonathan /* increment counter and do nothing. */
6526 1.1 jonathan newacq->count++;
6527 1.208 ozaki mutex_exit(&key_misc.lock);
6528 1.1 jonathan return 0;
6529 1.1 jonathan }
6530 1.1 jonathan } else {
6531 1.1 jonathan /* make new entry for blocking to send SADB_ACQUIRE. */
6532 1.137 ozaki newacq = key_newacq(saidx);
6533 1.215 ozaki if (newacq == NULL) {
6534 1.215 ozaki mutex_exit(&key_misc.lock);
6535 1.1 jonathan return ENOBUFS;
6536 1.215 ozaki }
6537 1.1 jonathan
6538 1.208 ozaki /* add to key_misc.acqlist */
6539 1.208 ozaki LIST_INSERT_HEAD(&key_misc.acqlist, newacq, chain);
6540 1.1 jonathan }
6541 1.1 jonathan
6542 1.1 jonathan seq = newacq->seq;
6543 1.208 ozaki mutex_exit(&key_misc.lock);
6544 1.1 jonathan #else
6545 1.1 jonathan seq = (acq_seq = (acq_seq == ~0 ? 1 : ++acq_seq));
6546 1.1 jonathan #endif
6547 1.239 ozaki m = key_setsadbmsg(SADB_ACQUIRE, 0, satype, seq, 0, 0, mflag);
6548 1.1 jonathan if (!m) {
6549 1.1 jonathan error = ENOBUFS;
6550 1.1 jonathan goto fail;
6551 1.1 jonathan }
6552 1.1 jonathan result = m;
6553 1.1 jonathan
6554 1.1 jonathan /* set sadb_address for saidx's. */
6555 1.137 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC, &saidx->src.sa, FULLMASK,
6556 1.239 ozaki IPSEC_ULPROTO_ANY, mflag);
6557 1.1 jonathan if (!m) {
6558 1.1 jonathan error = ENOBUFS;
6559 1.1 jonathan goto fail;
6560 1.1 jonathan }
6561 1.1 jonathan m_cat(result, m);
6562 1.1 jonathan
6563 1.137 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_DST, &saidx->dst.sa, FULLMASK,
6564 1.239 ozaki IPSEC_ULPROTO_ANY, mflag);
6565 1.1 jonathan if (!m) {
6566 1.1 jonathan error = ENOBUFS;
6567 1.1 jonathan goto fail;
6568 1.1 jonathan }
6569 1.1 jonathan m_cat(result, m);
6570 1.1 jonathan
6571 1.1 jonathan /* XXX proxy address (optional) */
6572 1.1 jonathan
6573 1.1 jonathan /* set sadb_x_policy */
6574 1.1 jonathan if (sp) {
6575 1.239 ozaki m = key_setsadbxpolicy(sp->policy, sp->spidx.dir, sp->id,
6576 1.239 ozaki mflag);
6577 1.1 jonathan if (!m) {
6578 1.1 jonathan error = ENOBUFS;
6579 1.1 jonathan goto fail;
6580 1.1 jonathan }
6581 1.1 jonathan m_cat(result, m);
6582 1.1 jonathan }
6583 1.1 jonathan
6584 1.1 jonathan /* XXX identity (optional) */
6585 1.1 jonathan #if 0
6586 1.1 jonathan if (idexttype && fqdn) {
6587 1.1 jonathan /* create identity extension (FQDN) */
6588 1.1 jonathan struct sadb_ident *id;
6589 1.1 jonathan int fqdnlen;
6590 1.1 jonathan
6591 1.1 jonathan fqdnlen = strlen(fqdn) + 1; /* +1 for terminating-NUL */
6592 1.1 jonathan id = (struct sadb_ident *)p;
6593 1.49 degroote memset(id, 0, sizeof(*id) + PFKEY_ALIGN8(fqdnlen));
6594 1.1 jonathan id->sadb_ident_len = PFKEY_UNIT64(sizeof(*id) + PFKEY_ALIGN8(fqdnlen));
6595 1.1 jonathan id->sadb_ident_exttype = idexttype;
6596 1.1 jonathan id->sadb_ident_type = SADB_IDENTTYPE_FQDN;
6597 1.49 degroote memcpy(id + 1, fqdn, fqdnlen);
6598 1.1 jonathan p += sizeof(struct sadb_ident) + PFKEY_ALIGN8(fqdnlen);
6599 1.1 jonathan }
6600 1.1 jonathan
6601 1.1 jonathan if (idexttype) {
6602 1.1 jonathan /* create identity extension (USERFQDN) */
6603 1.1 jonathan struct sadb_ident *id;
6604 1.1 jonathan int userfqdnlen;
6605 1.1 jonathan
6606 1.1 jonathan if (userfqdn) {
6607 1.1 jonathan /* +1 for terminating-NUL */
6608 1.1 jonathan userfqdnlen = strlen(userfqdn) + 1;
6609 1.1 jonathan } else
6610 1.1 jonathan userfqdnlen = 0;
6611 1.1 jonathan id = (struct sadb_ident *)p;
6612 1.49 degroote memset(id, 0, sizeof(*id) + PFKEY_ALIGN8(userfqdnlen));
6613 1.1 jonathan id->sadb_ident_len = PFKEY_UNIT64(sizeof(*id) + PFKEY_ALIGN8(userfqdnlen));
6614 1.1 jonathan id->sadb_ident_exttype = idexttype;
6615 1.1 jonathan id->sadb_ident_type = SADB_IDENTTYPE_USERFQDN;
6616 1.1 jonathan /* XXX is it correct? */
6617 1.28 ad if (curlwp)
6618 1.28 ad id->sadb_ident_id = kauth_cred_getuid(curlwp->l_cred);
6619 1.1 jonathan if (userfqdn && userfqdnlen)
6620 1.49 degroote memcpy(id + 1, userfqdn, userfqdnlen);
6621 1.1 jonathan p += sizeof(struct sadb_ident) + PFKEY_ALIGN8(userfqdnlen);
6622 1.1 jonathan }
6623 1.1 jonathan #endif
6624 1.1 jonathan
6625 1.1 jonathan /* XXX sensitivity (optional) */
6626 1.1 jonathan
6627 1.1 jonathan /* create proposal/combination extension */
6628 1.239 ozaki m = key_getprop(saidx, mflag);
6629 1.1 jonathan #if 0
6630 1.1 jonathan /*
6631 1.1 jonathan * spec conformant: always attach proposal/combination extension,
6632 1.1 jonathan * the problem is that we have no way to attach it for ipcomp,
6633 1.1 jonathan * due to the way sadb_comb is declared in RFC2367.
6634 1.1 jonathan */
6635 1.1 jonathan if (!m) {
6636 1.1 jonathan error = ENOBUFS;
6637 1.1 jonathan goto fail;
6638 1.1 jonathan }
6639 1.1 jonathan m_cat(result, m);
6640 1.1 jonathan #else
6641 1.1 jonathan /*
6642 1.1 jonathan * outside of spec; make proposal/combination extension optional.
6643 1.1 jonathan */
6644 1.1 jonathan if (m)
6645 1.1 jonathan m_cat(result, m);
6646 1.1 jonathan #endif
6647 1.1 jonathan
6648 1.1 jonathan if ((result->m_flags & M_PKTHDR) == 0) {
6649 1.1 jonathan error = EINVAL;
6650 1.1 jonathan goto fail;
6651 1.1 jonathan }
6652 1.1 jonathan
6653 1.1 jonathan if (result->m_len < sizeof(struct sadb_msg)) {
6654 1.1 jonathan result = m_pullup(result, sizeof(struct sadb_msg));
6655 1.1 jonathan if (result == NULL) {
6656 1.1 jonathan error = ENOBUFS;
6657 1.1 jonathan goto fail;
6658 1.1 jonathan }
6659 1.1 jonathan }
6660 1.1 jonathan
6661 1.1 jonathan result->m_pkthdr.len = 0;
6662 1.1 jonathan for (m = result; m; m = m->m_next)
6663 1.1 jonathan result->m_pkthdr.len += m->m_len;
6664 1.1 jonathan
6665 1.1 jonathan mtod(result, struct sadb_msg *)->sadb_msg_len =
6666 1.1 jonathan PFKEY_UNIT64(result->m_pkthdr.len);
6667 1.1 jonathan
6668 1.220 ozaki /*
6669 1.220 ozaki * XXX we cannot call key_sendup_mbuf directly here because
6670 1.220 ozaki * it can cause a deadlock:
6671 1.220 ozaki * - We have a reference to an SP (and an SA) here
6672 1.220 ozaki * - key_sendup_mbuf will try to take key_so_mtx
6673 1.220 ozaki * - Some other thread may try to localcount_drain to the SP with
6674 1.220 ozaki * holding key_so_mtx in say key_api_spdflush
6675 1.220 ozaki * - In this case localcount_drain never return because key_sendup_mbuf
6676 1.220 ozaki * that has stuck on key_so_mtx never release a reference to the SP
6677 1.220 ozaki *
6678 1.220 ozaki * So defer key_sendup_mbuf to the timer.
6679 1.220 ozaki */
6680 1.222 ozaki return key_acquire_sendup_mbuf_later(result);
6681 1.1 jonathan
6682 1.1 jonathan fail:
6683 1.1 jonathan if (result)
6684 1.1 jonathan m_freem(result);
6685 1.1 jonathan return error;
6686 1.1 jonathan }
6687 1.1 jonathan
6688 1.220 ozaki static struct mbuf *key_acquire_mbuf_head = NULL;
6689 1.222 ozaki static unsigned key_acquire_mbuf_count = 0;
6690 1.222 ozaki #define KEY_ACQUIRE_MBUF_MAX 10
6691 1.220 ozaki
6692 1.220 ozaki static void
6693 1.220 ozaki key_acquire_sendup_pending_mbuf(void)
6694 1.220 ozaki {
6695 1.221 ozaki struct mbuf *m, *prev;
6696 1.220 ozaki int error;
6697 1.220 ozaki
6698 1.220 ozaki again:
6699 1.221 ozaki prev = NULL;
6700 1.220 ozaki mutex_enter(&key_misc.lock);
6701 1.220 ozaki m = key_acquire_mbuf_head;
6702 1.220 ozaki /* Get an earliest mbuf (one at the tail of the list) */
6703 1.220 ozaki while (m != NULL) {
6704 1.220 ozaki if (m->m_nextpkt == NULL) {
6705 1.220 ozaki if (prev != NULL)
6706 1.220 ozaki prev->m_nextpkt = NULL;
6707 1.220 ozaki if (m == key_acquire_mbuf_head)
6708 1.220 ozaki key_acquire_mbuf_head = NULL;
6709 1.222 ozaki key_acquire_mbuf_count--;
6710 1.220 ozaki break;
6711 1.220 ozaki }
6712 1.220 ozaki prev = m;
6713 1.220 ozaki m = m->m_nextpkt;
6714 1.220 ozaki }
6715 1.220 ozaki mutex_exit(&key_misc.lock);
6716 1.220 ozaki
6717 1.220 ozaki if (m == NULL)
6718 1.220 ozaki return;
6719 1.220 ozaki
6720 1.222 ozaki m->m_nextpkt = NULL;
6721 1.220 ozaki error = key_sendup_mbuf(NULL, m, KEY_SENDUP_REGISTERED);
6722 1.220 ozaki if (error != 0)
6723 1.220 ozaki IPSECLOG(LOG_WARNING, "key_sendup_mbuf failed (error=%d)\n",
6724 1.220 ozaki error);
6725 1.220 ozaki
6726 1.220 ozaki if (prev != NULL)
6727 1.220 ozaki goto again;
6728 1.220 ozaki }
6729 1.220 ozaki
6730 1.222 ozaki static int
6731 1.220 ozaki key_acquire_sendup_mbuf_later(struct mbuf *m)
6732 1.220 ozaki {
6733 1.220 ozaki
6734 1.220 ozaki mutex_enter(&key_misc.lock);
6735 1.222 ozaki /* Avoid queuing too much mbufs */
6736 1.222 ozaki if (key_acquire_mbuf_count >= KEY_ACQUIRE_MBUF_MAX) {
6737 1.222 ozaki mutex_exit(&key_misc.lock);
6738 1.222 ozaki m_freem(m);
6739 1.222 ozaki return ENOBUFS; /* XXX */
6740 1.222 ozaki }
6741 1.220 ozaki /* Enqueue mbuf at the head of the list */
6742 1.220 ozaki m->m_nextpkt = key_acquire_mbuf_head;
6743 1.220 ozaki key_acquire_mbuf_head = m;
6744 1.222 ozaki key_acquire_mbuf_count++;
6745 1.220 ozaki mutex_exit(&key_misc.lock);
6746 1.220 ozaki
6747 1.220 ozaki /* Kick the timer */
6748 1.220 ozaki key_timehandler(NULL);
6749 1.222 ozaki
6750 1.222 ozaki return 0;
6751 1.220 ozaki }
6752 1.220 ozaki
6753 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
6754 1.1 jonathan static struct secacq *
6755 1.1 jonathan key_newacq(const struct secasindex *saidx)
6756 1.1 jonathan {
6757 1.1 jonathan struct secacq *newacq;
6758 1.1 jonathan
6759 1.1 jonathan /* get new entry */
6760 1.130 ozaki newacq = kmem_intr_zalloc(sizeof(struct secacq), KM_NOSLEEP);
6761 1.1 jonathan if (newacq == NULL) {
6762 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
6763 1.1 jonathan return NULL;
6764 1.1 jonathan }
6765 1.1 jonathan
6766 1.1 jonathan /* copy secindex */
6767 1.49 degroote memcpy(&newacq->saidx, saidx, sizeof(newacq->saidx));
6768 1.1 jonathan newacq->seq = (acq_seq == ~0 ? 1 : ++acq_seq);
6769 1.69 drochner newacq->created = time_uptime;
6770 1.1 jonathan newacq->count = 0;
6771 1.1 jonathan
6772 1.1 jonathan return newacq;
6773 1.1 jonathan }
6774 1.1 jonathan
6775 1.1 jonathan static struct secacq *
6776 1.1 jonathan key_getacq(const struct secasindex *saidx)
6777 1.1 jonathan {
6778 1.1 jonathan struct secacq *acq;
6779 1.1 jonathan
6780 1.208 ozaki KASSERT(mutex_owned(&key_misc.lock));
6781 1.141 ozaki
6782 1.208 ozaki LIST_FOREACH(acq, &key_misc.acqlist, chain) {
6783 1.145 ozaki if (key_saidx_match(saidx, &acq->saidx, CMP_EXACTLY))
6784 1.1 jonathan return acq;
6785 1.1 jonathan }
6786 1.1 jonathan
6787 1.1 jonathan return NULL;
6788 1.1 jonathan }
6789 1.1 jonathan
6790 1.1 jonathan static struct secacq *
6791 1.49 degroote key_getacqbyseq(u_int32_t seq)
6792 1.1 jonathan {
6793 1.1 jonathan struct secacq *acq;
6794 1.1 jonathan
6795 1.208 ozaki KASSERT(mutex_owned(&key_misc.lock));
6796 1.141 ozaki
6797 1.208 ozaki LIST_FOREACH(acq, &key_misc.acqlist, chain) {
6798 1.1 jonathan if (acq->seq == seq)
6799 1.1 jonathan return acq;
6800 1.1 jonathan }
6801 1.1 jonathan
6802 1.1 jonathan return NULL;
6803 1.1 jonathan }
6804 1.1 jonathan #endif
6805 1.1 jonathan
6806 1.139 ozaki #ifdef notyet
6807 1.1 jonathan static struct secspacq *
6808 1.66 drochner key_newspacq(const struct secpolicyindex *spidx)
6809 1.1 jonathan {
6810 1.1 jonathan struct secspacq *acq;
6811 1.1 jonathan
6812 1.1 jonathan /* get new entry */
6813 1.130 ozaki acq = kmem_intr_zalloc(sizeof(struct secspacq), KM_NOSLEEP);
6814 1.1 jonathan if (acq == NULL) {
6815 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
6816 1.1 jonathan return NULL;
6817 1.1 jonathan }
6818 1.1 jonathan
6819 1.1 jonathan /* copy secindex */
6820 1.49 degroote memcpy(&acq->spidx, spidx, sizeof(acq->spidx));
6821 1.69 drochner acq->created = time_uptime;
6822 1.1 jonathan acq->count = 0;
6823 1.1 jonathan
6824 1.1 jonathan return acq;
6825 1.1 jonathan }
6826 1.1 jonathan
6827 1.1 jonathan static struct secspacq *
6828 1.66 drochner key_getspacq(const struct secpolicyindex *spidx)
6829 1.1 jonathan {
6830 1.1 jonathan struct secspacq *acq;
6831 1.1 jonathan
6832 1.208 ozaki LIST_FOREACH(acq, &key_misc.spacqlist, chain) {
6833 1.145 ozaki if (key_spidx_match_exactly(spidx, &acq->spidx))
6834 1.1 jonathan return acq;
6835 1.1 jonathan }
6836 1.1 jonathan
6837 1.1 jonathan return NULL;
6838 1.1 jonathan }
6839 1.139 ozaki #endif /* notyet */
6840 1.1 jonathan
6841 1.1 jonathan /*
6842 1.1 jonathan * SADB_ACQUIRE processing,
6843 1.1 jonathan * in first situation, is receiving
6844 1.1 jonathan * <base>
6845 1.1 jonathan * from the ikmpd, and clear sequence of its secasvar entry.
6846 1.1 jonathan *
6847 1.1 jonathan * In second situation, is receiving
6848 1.1 jonathan * <base, address(SD), (address(P),) (identity(SD),) (sensitivity,) proposal>
6849 1.1 jonathan * from a user land process, and return
6850 1.1 jonathan * <base, address(SD), (address(P),) (identity(SD),) (sensitivity,) proposal>
6851 1.1 jonathan * to the socket.
6852 1.1 jonathan *
6853 1.1 jonathan * m will always be freed.
6854 1.1 jonathan */
6855 1.1 jonathan static int
6856 1.162 ozaki key_api_acquire(struct socket *so, struct mbuf *m,
6857 1.49 degroote const struct sadb_msghdr *mhp)
6858 1.1 jonathan {
6859 1.151 ozaki const struct sockaddr *src, *dst;
6860 1.1 jonathan struct secasindex saidx;
6861 1.1 jonathan u_int16_t proto;
6862 1.1 jonathan int error;
6863 1.1 jonathan
6864 1.1 jonathan /*
6865 1.1 jonathan * Error message from KMd.
6866 1.7 wiz * We assume that if error was occurred in IKEd, the length of PFKEY
6867 1.1 jonathan * message is equal to the size of sadb_msg structure.
6868 1.7 wiz * We do not raise error even if error occurred in this function.
6869 1.1 jonathan */
6870 1.1 jonathan if (mhp->msg->sadb_msg_len == PFKEY_UNIT64(sizeof(struct sadb_msg))) {
6871 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
6872 1.1 jonathan struct secacq *acq;
6873 1.1 jonathan
6874 1.1 jonathan /* check sequence number */
6875 1.1 jonathan if (mhp->msg->sadb_msg_seq == 0) {
6876 1.134 ozaki IPSECLOG(LOG_DEBUG, "must specify sequence number.\n");
6877 1.1 jonathan m_freem(m);
6878 1.1 jonathan return 0;
6879 1.1 jonathan }
6880 1.1 jonathan
6881 1.208 ozaki mutex_enter(&key_misc.lock);
6882 1.137 ozaki acq = key_getacqbyseq(mhp->msg->sadb_msg_seq);
6883 1.137 ozaki if (acq == NULL) {
6884 1.208 ozaki mutex_exit(&key_misc.lock);
6885 1.1 jonathan /*
6886 1.1 jonathan * the specified larval SA is already gone, or we got
6887 1.1 jonathan * a bogus sequence number. we can silently ignore it.
6888 1.1 jonathan */
6889 1.1 jonathan m_freem(m);
6890 1.1 jonathan return 0;
6891 1.1 jonathan }
6892 1.1 jonathan
6893 1.1 jonathan /* reset acq counter in order to deletion by timehander. */
6894 1.69 drochner acq->created = time_uptime;
6895 1.1 jonathan acq->count = 0;
6896 1.208 ozaki mutex_exit(&key_misc.lock);
6897 1.1 jonathan #endif
6898 1.1 jonathan m_freem(m);
6899 1.1 jonathan return 0;
6900 1.1 jonathan }
6901 1.1 jonathan
6902 1.1 jonathan /*
6903 1.1 jonathan * This message is from user land.
6904 1.1 jonathan */
6905 1.1 jonathan
6906 1.1 jonathan /* map satype to proto */
6907 1.137 ozaki proto = key_satype2proto(mhp->msg->sadb_msg_satype);
6908 1.137 ozaki if (proto == 0) {
6909 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
6910 1.1 jonathan return key_senderror(so, m, EINVAL);
6911 1.1 jonathan }
6912 1.1 jonathan
6913 1.1 jonathan if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
6914 1.1 jonathan mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
6915 1.1 jonathan mhp->ext[SADB_EXT_PROPOSAL] == NULL) {
6916 1.1 jonathan /* error */
6917 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
6918 1.1 jonathan return key_senderror(so, m, EINVAL);
6919 1.1 jonathan }
6920 1.1 jonathan if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
6921 1.1 jonathan mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
6922 1.1 jonathan mhp->extlen[SADB_EXT_PROPOSAL] < sizeof(struct sadb_prop)) {
6923 1.1 jonathan /* error */
6924 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message is passed.\n");
6925 1.1 jonathan return key_senderror(so, m, EINVAL);
6926 1.1 jonathan }
6927 1.1 jonathan
6928 1.151 ozaki src = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_SRC);
6929 1.151 ozaki dst = key_msghdr_get_sockaddr(mhp, SADB_EXT_ADDRESS_DST);
6930 1.1 jonathan
6931 1.151 ozaki error = key_setsecasidx(proto, IPSEC_MODE_ANY, 0, src, dst, &saidx);
6932 1.137 ozaki if (error != 0)
6933 1.48 degroote return key_senderror(so, m, EINVAL);
6934 1.1 jonathan
6935 1.137 ozaki error = key_set_natt_ports(&saidx.src, &saidx.dst, mhp);
6936 1.137 ozaki if (error != 0)
6937 1.64 spz return key_senderror(so, m, EINVAL);
6938 1.64 spz
6939 1.1 jonathan /* get a SA index */
6940 1.216 ozaki {
6941 1.216 ozaki struct secashead *sah;
6942 1.216 ozaki int s = pserialize_read_enter();
6943 1.216 ozaki
6944 1.155 ozaki sah = key_getsah(&saidx, CMP_MODE_REQID);
6945 1.1 jonathan if (sah != NULL) {
6946 1.216 ozaki pserialize_read_exit(s);
6947 1.134 ozaki IPSECLOG(LOG_DEBUG, "a SA exists already.\n");
6948 1.1 jonathan return key_senderror(so, m, EEXIST);
6949 1.1 jonathan }
6950 1.216 ozaki pserialize_read_exit(s);
6951 1.216 ozaki }
6952 1.1 jonathan
6953 1.239 ozaki error = key_acquire(&saidx, NULL, M_WAITOK);
6954 1.1 jonathan if (error != 0) {
6955 1.134 ozaki IPSECLOG(LOG_DEBUG, "error %d returned from key_acquire.\n",
6956 1.166 ozaki error);
6957 1.1 jonathan return key_senderror(so, m, error);
6958 1.1 jonathan }
6959 1.1 jonathan
6960 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_REGISTERED);
6961 1.1 jonathan }
6962 1.1 jonathan
6963 1.1 jonathan /*
6964 1.1 jonathan * SADB_REGISTER processing.
6965 1.1 jonathan * If SATYPE_UNSPEC has been passed as satype, only return sabd_supported.
6966 1.1 jonathan * receive
6967 1.1 jonathan * <base>
6968 1.1 jonathan * from the ikmpd, and register a socket to send PF_KEY messages,
6969 1.1 jonathan * and send
6970 1.1 jonathan * <base, supported>
6971 1.1 jonathan * to KMD by PF_KEY.
6972 1.1 jonathan * If socket is detached, must free from regnode.
6973 1.1 jonathan *
6974 1.1 jonathan * m will always be freed.
6975 1.1 jonathan */
6976 1.1 jonathan static int
6977 1.162 ozaki key_api_register(struct socket *so, struct mbuf *m,
6978 1.49 degroote const struct sadb_msghdr *mhp)
6979 1.1 jonathan {
6980 1.1 jonathan struct secreg *reg, *newreg = 0;
6981 1.1 jonathan
6982 1.1 jonathan /* check for invalid register message */
6983 1.208 ozaki if (mhp->msg->sadb_msg_satype >= __arraycount(key_misc.reglist))
6984 1.1 jonathan return key_senderror(so, m, EINVAL);
6985 1.1 jonathan
6986 1.1 jonathan /* When SATYPE_UNSPEC is specified, only return sabd_supported. */
6987 1.1 jonathan if (mhp->msg->sadb_msg_satype == SADB_SATYPE_UNSPEC)
6988 1.1 jonathan goto setmsg;
6989 1.1 jonathan
6990 1.141 ozaki /* Allocate regnode in advance, out of mutex */
6991 1.141 ozaki newreg = kmem_zalloc(sizeof(*newreg), KM_SLEEP);
6992 1.141 ozaki
6993 1.1 jonathan /* check whether existing or not */
6994 1.208 ozaki mutex_enter(&key_misc.lock);
6995 1.208 ozaki LIST_FOREACH(reg, &key_misc.reglist[mhp->msg->sadb_msg_satype], chain) {
6996 1.1 jonathan if (reg->so == so) {
6997 1.134 ozaki IPSECLOG(LOG_DEBUG, "socket exists already.\n");
6998 1.208 ozaki mutex_exit(&key_misc.lock);
6999 1.141 ozaki kmem_free(newreg, sizeof(*newreg));
7000 1.1 jonathan return key_senderror(so, m, EEXIST);
7001 1.1 jonathan }
7002 1.1 jonathan }
7003 1.1 jonathan
7004 1.1 jonathan newreg->so = so;
7005 1.1 jonathan ((struct keycb *)sotorawcb(so))->kp_registered++;
7006 1.1 jonathan
7007 1.208 ozaki /* add regnode to key_misc.reglist. */
7008 1.208 ozaki LIST_INSERT_HEAD(&key_misc.reglist[mhp->msg->sadb_msg_satype], newreg, chain);
7009 1.208 ozaki mutex_exit(&key_misc.lock);
7010 1.1 jonathan
7011 1.1 jonathan setmsg:
7012 1.1 jonathan {
7013 1.1 jonathan struct mbuf *n;
7014 1.1 jonathan struct sadb_supported *sup;
7015 1.1 jonathan u_int len, alen, elen;
7016 1.1 jonathan int off;
7017 1.1 jonathan int i;
7018 1.1 jonathan struct sadb_alg *alg;
7019 1.1 jonathan
7020 1.1 jonathan /* create new sadb_msg to reply. */
7021 1.1 jonathan alen = 0;
7022 1.1 jonathan for (i = 1; i <= SADB_AALG_MAX; i++) {
7023 1.1 jonathan if (ah_algorithm_lookup(i))
7024 1.1 jonathan alen += sizeof(struct sadb_alg);
7025 1.1 jonathan }
7026 1.1 jonathan if (alen)
7027 1.1 jonathan alen += sizeof(struct sadb_supported);
7028 1.1 jonathan elen = 0;
7029 1.1 jonathan for (i = 1; i <= SADB_EALG_MAX; i++) {
7030 1.1 jonathan if (esp_algorithm_lookup(i))
7031 1.1 jonathan elen += sizeof(struct sadb_alg);
7032 1.1 jonathan }
7033 1.1 jonathan if (elen)
7034 1.1 jonathan elen += sizeof(struct sadb_supported);
7035 1.1 jonathan
7036 1.1 jonathan len = sizeof(struct sadb_msg) + alen + elen;
7037 1.1 jonathan
7038 1.1 jonathan if (len > MCLBYTES)
7039 1.1 jonathan return key_senderror(so, m, ENOBUFS);
7040 1.1 jonathan
7041 1.239 ozaki n = key_alloc_mbuf_simple(len, M_WAITOK);
7042 1.1 jonathan n->m_pkthdr.len = n->m_len = len;
7043 1.1 jonathan n->m_next = NULL;
7044 1.1 jonathan off = 0;
7045 1.1 jonathan
7046 1.39 degroote m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, char *) + off);
7047 1.158 ozaki n = key_fill_replymsg(n, 0);
7048 1.158 ozaki if (n == NULL)
7049 1.158 ozaki return key_senderror(so, m, ENOBUFS);
7050 1.158 ozaki
7051 1.1 jonathan off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
7052 1.1 jonathan
7053 1.1 jonathan /* for authentication algorithm */
7054 1.1 jonathan if (alen) {
7055 1.39 degroote sup = (struct sadb_supported *)(mtod(n, char *) + off);
7056 1.1 jonathan sup->sadb_supported_len = PFKEY_UNIT64(alen);
7057 1.1 jonathan sup->sadb_supported_exttype = SADB_EXT_SUPPORTED_AUTH;
7058 1.1 jonathan off += PFKEY_ALIGN8(sizeof(*sup));
7059 1.1 jonathan
7060 1.1 jonathan for (i = 1; i <= SADB_AALG_MAX; i++) {
7061 1.65 drochner const struct auth_hash *aalgo;
7062 1.1 jonathan u_int16_t minkeysize, maxkeysize;
7063 1.1 jonathan
7064 1.1 jonathan aalgo = ah_algorithm_lookup(i);
7065 1.1 jonathan if (!aalgo)
7066 1.1 jonathan continue;
7067 1.39 degroote alg = (struct sadb_alg *)(mtod(n, char *) + off);
7068 1.1 jonathan alg->sadb_alg_id = i;
7069 1.1 jonathan alg->sadb_alg_ivlen = 0;
7070 1.1 jonathan key_getsizes_ah(aalgo, i, &minkeysize, &maxkeysize);
7071 1.1 jonathan alg->sadb_alg_minbits = _BITS(minkeysize);
7072 1.1 jonathan alg->sadb_alg_maxbits = _BITS(maxkeysize);
7073 1.1 jonathan off += PFKEY_ALIGN8(sizeof(*alg));
7074 1.1 jonathan }
7075 1.1 jonathan }
7076 1.1 jonathan
7077 1.1 jonathan /* for encryption algorithm */
7078 1.1 jonathan if (elen) {
7079 1.39 degroote sup = (struct sadb_supported *)(mtod(n, char *) + off);
7080 1.1 jonathan sup->sadb_supported_len = PFKEY_UNIT64(elen);
7081 1.1 jonathan sup->sadb_supported_exttype = SADB_EXT_SUPPORTED_ENCRYPT;
7082 1.1 jonathan off += PFKEY_ALIGN8(sizeof(*sup));
7083 1.1 jonathan
7084 1.1 jonathan for (i = 1; i <= SADB_EALG_MAX; i++) {
7085 1.65 drochner const struct enc_xform *ealgo;
7086 1.1 jonathan
7087 1.1 jonathan ealgo = esp_algorithm_lookup(i);
7088 1.1 jonathan if (!ealgo)
7089 1.1 jonathan continue;
7090 1.39 degroote alg = (struct sadb_alg *)(mtod(n, char *) + off);
7091 1.1 jonathan alg->sadb_alg_id = i;
7092 1.1 jonathan alg->sadb_alg_ivlen = ealgo->blocksize;
7093 1.1 jonathan alg->sadb_alg_minbits = _BITS(ealgo->minkey);
7094 1.1 jonathan alg->sadb_alg_maxbits = _BITS(ealgo->maxkey);
7095 1.1 jonathan off += PFKEY_ALIGN8(sizeof(struct sadb_alg));
7096 1.1 jonathan }
7097 1.1 jonathan }
7098 1.1 jonathan
7099 1.110 ozaki KASSERTMSG(off == len, "length inconsistency");
7100 1.1 jonathan
7101 1.1 jonathan m_freem(m);
7102 1.1 jonathan return key_sendup_mbuf(so, n, KEY_SENDUP_REGISTERED);
7103 1.1 jonathan }
7104 1.1 jonathan }
7105 1.1 jonathan
7106 1.1 jonathan /*
7107 1.1 jonathan * free secreg entry registered.
7108 1.1 jonathan * XXX: I want to do free a socket marked done SADB_RESIGER to socket.
7109 1.1 jonathan */
7110 1.1 jonathan void
7111 1.49 degroote key_freereg(struct socket *so)
7112 1.1 jonathan {
7113 1.1 jonathan struct secreg *reg;
7114 1.1 jonathan int i;
7115 1.1 jonathan
7116 1.127 ozaki KASSERT(!cpu_softintr_p());
7117 1.112 ozaki KASSERT(so != NULL);
7118 1.1 jonathan
7119 1.1 jonathan /*
7120 1.1 jonathan * check whether existing or not.
7121 1.1 jonathan * check all type of SA, because there is a potential that
7122 1.1 jonathan * one socket is registered to multiple type of SA.
7123 1.1 jonathan */
7124 1.1 jonathan for (i = 0; i <= SADB_SATYPE_MAX; i++) {
7125 1.208 ozaki mutex_enter(&key_misc.lock);
7126 1.208 ozaki LIST_FOREACH(reg, &key_misc.reglist[i], chain) {
7127 1.138 ozaki if (reg->so == so) {
7128 1.1 jonathan LIST_REMOVE(reg, chain);
7129 1.1 jonathan break;
7130 1.1 jonathan }
7131 1.1 jonathan }
7132 1.208 ozaki mutex_exit(&key_misc.lock);
7133 1.141 ozaki if (reg != NULL)
7134 1.141 ozaki kmem_free(reg, sizeof(*reg));
7135 1.1 jonathan }
7136 1.22 perry
7137 1.1 jonathan return;
7138 1.1 jonathan }
7139 1.1 jonathan
7140 1.1 jonathan /*
7141 1.1 jonathan * SADB_EXPIRE processing
7142 1.1 jonathan * send
7143 1.1 jonathan * <base, SA, SA2, lifetime(C and one of HS), address(SD)>
7144 1.1 jonathan * to KMD by PF_KEY.
7145 1.1 jonathan * NOTE: We send only soft lifetime extension.
7146 1.1 jonathan *
7147 1.1 jonathan * OUT: 0 : succeed
7148 1.1 jonathan * others : error number
7149 1.1 jonathan */
7150 1.1 jonathan static int
7151 1.49 degroote key_expire(struct secasvar *sav)
7152 1.1 jonathan {
7153 1.1 jonathan int s;
7154 1.1 jonathan int satype;
7155 1.1 jonathan struct mbuf *result = NULL, *m;
7156 1.1 jonathan int len;
7157 1.1 jonathan int error = -1;
7158 1.1 jonathan struct sadb_lifetime *lt;
7159 1.1 jonathan
7160 1.1 jonathan /* XXX: Why do we lock ? */
7161 1.1 jonathan s = splsoftnet(); /*called from softclock()*/
7162 1.1 jonathan
7163 1.112 ozaki KASSERT(sav != NULL);
7164 1.112 ozaki
7165 1.112 ozaki satype = key_proto2satype(sav->sah->saidx.proto);
7166 1.112 ozaki KASSERTMSG(satype != 0, "invalid proto is passed");
7167 1.1 jonathan
7168 1.1 jonathan /* set msg header */
7169 1.239 ozaki m = key_setsadbmsg(SADB_EXPIRE, 0, satype, sav->seq, 0, key_sa_refcnt(sav),
7170 1.239 ozaki M_WAITOK);
7171 1.1 jonathan result = m;
7172 1.1 jonathan
7173 1.1 jonathan /* create SA extension */
7174 1.1 jonathan m = key_setsadbsa(sav);
7175 1.1 jonathan m_cat(result, m);
7176 1.1 jonathan
7177 1.1 jonathan /* create SA extension */
7178 1.1 jonathan m = key_setsadbxsa2(sav->sah->saidx.mode,
7179 1.137 ozaki sav->replay ? sav->replay->count : 0, sav->sah->saidx.reqid);
7180 1.1 jonathan m_cat(result, m);
7181 1.1 jonathan
7182 1.1 jonathan /* create lifetime extension (current and soft) */
7183 1.1 jonathan len = PFKEY_ALIGN8(sizeof(*lt)) * 2;
7184 1.239 ozaki m = key_alloc_mbuf(len, M_WAITOK);
7185 1.240 ozaki KASSERT(m->m_next == NULL);
7186 1.240 ozaki
7187 1.49 degroote memset(mtod(m, void *), 0, len);
7188 1.1 jonathan lt = mtod(m, struct sadb_lifetime *);
7189 1.1 jonathan lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
7190 1.1 jonathan lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
7191 1.1 jonathan lt->sadb_lifetime_allocations = sav->lft_c->sadb_lifetime_allocations;
7192 1.1 jonathan lt->sadb_lifetime_bytes = sav->lft_c->sadb_lifetime_bytes;
7193 1.137 ozaki lt->sadb_lifetime_addtime =
7194 1.137 ozaki time_mono_to_wall(sav->lft_c->sadb_lifetime_addtime);
7195 1.137 ozaki lt->sadb_lifetime_usetime =
7196 1.137 ozaki time_mono_to_wall(sav->lft_c->sadb_lifetime_usetime);
7197 1.39 degroote lt = (struct sadb_lifetime *)(mtod(m, char *) + len / 2);
7198 1.49 degroote memcpy(lt, sav->lft_s, sizeof(*lt));
7199 1.1 jonathan m_cat(result, m);
7200 1.1 jonathan
7201 1.1 jonathan /* set sadb_address for source */
7202 1.137 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC, &sav->sah->saidx.src.sa,
7203 1.239 ozaki FULLMASK, IPSEC_ULPROTO_ANY, M_WAITOK);
7204 1.1 jonathan m_cat(result, m);
7205 1.1 jonathan
7206 1.1 jonathan /* set sadb_address for destination */
7207 1.137 ozaki m = key_setsadbaddr(SADB_EXT_ADDRESS_DST, &sav->sah->saidx.dst.sa,
7208 1.239 ozaki FULLMASK, IPSEC_ULPROTO_ANY, M_WAITOK);
7209 1.1 jonathan m_cat(result, m);
7210 1.1 jonathan
7211 1.1 jonathan if ((result->m_flags & M_PKTHDR) == 0) {
7212 1.1 jonathan error = EINVAL;
7213 1.1 jonathan goto fail;
7214 1.1 jonathan }
7215 1.1 jonathan
7216 1.1 jonathan if (result->m_len < sizeof(struct sadb_msg)) {
7217 1.1 jonathan result = m_pullup(result, sizeof(struct sadb_msg));
7218 1.1 jonathan if (result == NULL) {
7219 1.1 jonathan error = ENOBUFS;
7220 1.1 jonathan goto fail;
7221 1.1 jonathan }
7222 1.1 jonathan }
7223 1.1 jonathan
7224 1.1 jonathan result->m_pkthdr.len = 0;
7225 1.1 jonathan for (m = result; m; m = m->m_next)
7226 1.1 jonathan result->m_pkthdr.len += m->m_len;
7227 1.1 jonathan
7228 1.1 jonathan mtod(result, struct sadb_msg *)->sadb_msg_len =
7229 1.1 jonathan PFKEY_UNIT64(result->m_pkthdr.len);
7230 1.1 jonathan
7231 1.1 jonathan splx(s);
7232 1.1 jonathan return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
7233 1.1 jonathan
7234 1.1 jonathan fail:
7235 1.1 jonathan if (result)
7236 1.1 jonathan m_freem(result);
7237 1.1 jonathan splx(s);
7238 1.1 jonathan return error;
7239 1.1 jonathan }
7240 1.1 jonathan
7241 1.1 jonathan /*
7242 1.1 jonathan * SADB_FLUSH processing
7243 1.1 jonathan * receive
7244 1.1 jonathan * <base>
7245 1.1 jonathan * from the ikmpd, and free all entries in secastree.
7246 1.1 jonathan * and send,
7247 1.1 jonathan * <base>
7248 1.1 jonathan * to the ikmpd.
7249 1.1 jonathan * NOTE: to do is only marking SADB_SASTATE_DEAD.
7250 1.1 jonathan *
7251 1.1 jonathan * m will always be freed.
7252 1.1 jonathan */
7253 1.1 jonathan static int
7254 1.162 ozaki key_api_flush(struct socket *so, struct mbuf *m,
7255 1.49 degroote const struct sadb_msghdr *mhp)
7256 1.1 jonathan {
7257 1.1 jonathan struct sadb_msg *newmsg;
7258 1.119 ozaki struct secashead *sah;
7259 1.203 ozaki struct secasvar *sav;
7260 1.1 jonathan u_int16_t proto;
7261 1.1 jonathan u_int8_t state;
7262 1.216 ozaki int s;
7263 1.1 jonathan
7264 1.1 jonathan /* map satype to proto */
7265 1.137 ozaki proto = key_satype2proto(mhp->msg->sadb_msg_satype);
7266 1.137 ozaki if (proto == 0) {
7267 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
7268 1.1 jonathan return key_senderror(so, m, EINVAL);
7269 1.1 jonathan }
7270 1.1 jonathan
7271 1.1 jonathan /* no SATYPE specified, i.e. flushing all SA. */
7272 1.216 ozaki s = pserialize_read_enter();
7273 1.202 ozaki SAHLIST_READER_FOREACH(sah) {
7274 1.137 ozaki if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC &&
7275 1.137 ozaki proto != sah->saidx.proto)
7276 1.1 jonathan continue;
7277 1.1 jonathan
7278 1.216 ozaki key_sah_ref(sah);
7279 1.216 ozaki pserialize_read_exit(s);
7280 1.216 ozaki
7281 1.120 ozaki SASTATE_ALIVE_FOREACH(state) {
7282 1.203 ozaki restart:
7283 1.223 ozaki mutex_enter(&key_sad.lock);
7284 1.203 ozaki SAVLIST_WRITER_FOREACH(sav, sah, state) {
7285 1.223 ozaki sav->state = SADB_SASTATE_DEAD;
7286 1.223 ozaki key_unlink_sav(sav);
7287 1.223 ozaki mutex_exit(&key_sad.lock);
7288 1.223 ozaki key_destroy_sav(sav);
7289 1.203 ozaki goto restart;
7290 1.1 jonathan }
7291 1.223 ozaki mutex_exit(&key_sad.lock);
7292 1.1 jonathan }
7293 1.1 jonathan
7294 1.216 ozaki s = pserialize_read_enter();
7295 1.1 jonathan sah->state = SADB_SASTATE_DEAD;
7296 1.216 ozaki key_sah_unref(sah);
7297 1.1 jonathan }
7298 1.216 ozaki pserialize_read_exit(s);
7299 1.1 jonathan
7300 1.1 jonathan if (m->m_len < sizeof(struct sadb_msg) ||
7301 1.1 jonathan sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
7302 1.134 ozaki IPSECLOG(LOG_DEBUG, "No more memory.\n");
7303 1.1 jonathan return key_senderror(so, m, ENOBUFS);
7304 1.1 jonathan }
7305 1.1 jonathan
7306 1.1 jonathan if (m->m_next)
7307 1.1 jonathan m_freem(m->m_next);
7308 1.1 jonathan m->m_next = NULL;
7309 1.1 jonathan m->m_pkthdr.len = m->m_len = sizeof(struct sadb_msg);
7310 1.1 jonathan newmsg = mtod(m, struct sadb_msg *);
7311 1.1 jonathan newmsg->sadb_msg_errno = 0;
7312 1.1 jonathan newmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
7313 1.1 jonathan
7314 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
7315 1.1 jonathan }
7316 1.1 jonathan
7317 1.19 jonathan
7318 1.19 jonathan static struct mbuf *
7319 1.20 jonathan key_setdump_chain(u_int8_t req_satype, int *errorp, int *lenp, pid_t pid)
7320 1.1 jonathan {
7321 1.1 jonathan struct secashead *sah;
7322 1.1 jonathan struct secasvar *sav;
7323 1.1 jonathan u_int16_t proto;
7324 1.1 jonathan u_int8_t satype;
7325 1.1 jonathan u_int8_t state;
7326 1.1 jonathan int cnt;
7327 1.19 jonathan struct mbuf *m, *n, *prev;
7328 1.1 jonathan
7329 1.208 ozaki KASSERT(mutex_owned(&key_sad.lock));
7330 1.205 ozaki
7331 1.19 jonathan *lenp = 0;
7332 1.1 jonathan
7333 1.1 jonathan /* map satype to proto */
7334 1.137 ozaki proto = key_satype2proto(req_satype);
7335 1.137 ozaki if (proto == 0) {
7336 1.19 jonathan *errorp = EINVAL;
7337 1.19 jonathan return (NULL);
7338 1.1 jonathan }
7339 1.1 jonathan
7340 1.19 jonathan /* count sav entries to be sent to userland. */
7341 1.1 jonathan cnt = 0;
7342 1.205 ozaki SAHLIST_WRITER_FOREACH(sah) {
7343 1.19 jonathan if (req_satype != SADB_SATYPE_UNSPEC &&
7344 1.19 jonathan proto != sah->saidx.proto)
7345 1.1 jonathan continue;
7346 1.1 jonathan
7347 1.120 ozaki SASTATE_ANY_FOREACH(state) {
7348 1.205 ozaki SAVLIST_WRITER_FOREACH(sav, sah, state) {
7349 1.1 jonathan cnt++;
7350 1.1 jonathan }
7351 1.1 jonathan }
7352 1.1 jonathan }
7353 1.1 jonathan
7354 1.19 jonathan if (cnt == 0) {
7355 1.19 jonathan *errorp = ENOENT;
7356 1.19 jonathan return (NULL);
7357 1.19 jonathan }
7358 1.1 jonathan
7359 1.1 jonathan /* send this to the userland, one at a time. */
7360 1.19 jonathan m = NULL;
7361 1.19 jonathan prev = m;
7362 1.205 ozaki SAHLIST_WRITER_FOREACH(sah) {
7363 1.19 jonathan if (req_satype != SADB_SATYPE_UNSPEC &&
7364 1.19 jonathan proto != sah->saidx.proto)
7365 1.1 jonathan continue;
7366 1.1 jonathan
7367 1.1 jonathan /* map proto to satype */
7368 1.137 ozaki satype = key_proto2satype(sah->saidx.proto);
7369 1.137 ozaki if (satype == 0) {
7370 1.19 jonathan m_freem(m);
7371 1.19 jonathan *errorp = EINVAL;
7372 1.19 jonathan return (NULL);
7373 1.1 jonathan }
7374 1.1 jonathan
7375 1.120 ozaki SASTATE_ANY_FOREACH(state) {
7376 1.205 ozaki SAVLIST_WRITER_FOREACH(sav, sah, state) {
7377 1.1 jonathan n = key_setdumpsa(sav, SADB_DUMP, satype,
7378 1.20 jonathan --cnt, pid);
7379 1.19 jonathan if (!n) {
7380 1.19 jonathan m_freem(m);
7381 1.19 jonathan *errorp = ENOBUFS;
7382 1.19 jonathan return (NULL);
7383 1.19 jonathan }
7384 1.1 jonathan
7385 1.19 jonathan if (!m)
7386 1.19 jonathan m = n;
7387 1.19 jonathan else
7388 1.19 jonathan prev->m_nextpkt = n;
7389 1.19 jonathan prev = n;
7390 1.1 jonathan }
7391 1.1 jonathan }
7392 1.1 jonathan }
7393 1.1 jonathan
7394 1.19 jonathan if (!m) {
7395 1.19 jonathan *errorp = EINVAL;
7396 1.19 jonathan return (NULL);
7397 1.19 jonathan }
7398 1.19 jonathan
7399 1.19 jonathan if ((m->m_flags & M_PKTHDR) != 0) {
7400 1.19 jonathan m->m_pkthdr.len = 0;
7401 1.19 jonathan for (n = m; n; n = n->m_next)
7402 1.19 jonathan m->m_pkthdr.len += n->m_len;
7403 1.19 jonathan }
7404 1.19 jonathan
7405 1.19 jonathan *errorp = 0;
7406 1.19 jonathan return (m);
7407 1.19 jonathan }
7408 1.19 jonathan
7409 1.19 jonathan /*
7410 1.19 jonathan * SADB_DUMP processing
7411 1.19 jonathan * dump all entries including status of DEAD in SAD.
7412 1.19 jonathan * receive
7413 1.19 jonathan * <base>
7414 1.19 jonathan * from the ikmpd, and dump all secasvar leaves
7415 1.19 jonathan * and send,
7416 1.19 jonathan * <base> .....
7417 1.19 jonathan * to the ikmpd.
7418 1.19 jonathan *
7419 1.19 jonathan * m will always be freed.
7420 1.19 jonathan */
7421 1.19 jonathan static int
7422 1.162 ozaki key_api_dump(struct socket *so, struct mbuf *m0,
7423 1.49 degroote const struct sadb_msghdr *mhp)
7424 1.19 jonathan {
7425 1.19 jonathan u_int16_t proto;
7426 1.19 jonathan u_int8_t satype;
7427 1.19 jonathan struct mbuf *n;
7428 1.19 jonathan int error, len, ok;
7429 1.19 jonathan
7430 1.19 jonathan /* map satype to proto */
7431 1.19 jonathan satype = mhp->msg->sadb_msg_satype;
7432 1.137 ozaki proto = key_satype2proto(satype);
7433 1.137 ozaki if (proto == 0) {
7434 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid satype is passed.\n");
7435 1.19 jonathan return key_senderror(so, m0, EINVAL);
7436 1.19 jonathan }
7437 1.19 jonathan
7438 1.19 jonathan /*
7439 1.19 jonathan * If the requestor has insufficient socket-buffer space
7440 1.19 jonathan * for the entire chain, nobody gets any response to the DUMP.
7441 1.19 jonathan * XXX For now, only the requestor ever gets anything.
7442 1.19 jonathan * Moreover, if the requestor has any space at all, they receive
7443 1.19 jonathan * the entire chain, otherwise the request is refused with ENOBUFS.
7444 1.19 jonathan */
7445 1.19 jonathan if (sbspace(&so->so_rcv) <= 0) {
7446 1.19 jonathan return key_senderror(so, m0, ENOBUFS);
7447 1.19 jonathan }
7448 1.19 jonathan
7449 1.208 ozaki mutex_enter(&key_sad.lock);
7450 1.20 jonathan n = key_setdump_chain(satype, &error, &len, mhp->msg->sadb_msg_pid);
7451 1.208 ozaki mutex_exit(&key_sad.lock);
7452 1.19 jonathan
7453 1.19 jonathan if (n == NULL) {
7454 1.19 jonathan return key_senderror(so, m0, ENOENT);
7455 1.19 jonathan }
7456 1.52 thorpej {
7457 1.52 thorpej uint64_t *ps = PFKEY_STAT_GETREF();
7458 1.52 thorpej ps[PFKEY_STAT_IN_TOTAL]++;
7459 1.52 thorpej ps[PFKEY_STAT_IN_BYTES] += len;
7460 1.52 thorpej PFKEY_STAT_PUTREF();
7461 1.52 thorpej }
7462 1.19 jonathan
7463 1.19 jonathan /*
7464 1.19 jonathan * PF_KEY DUMP responses are no longer broadcast to all PF_KEY sockets.
7465 1.19 jonathan * The requestor receives either the entire chain, or an
7466 1.19 jonathan * error message with ENOBUFS.
7467 1.19 jonathan *
7468 1.19 jonathan * sbappendaddrchain() takes the chain of entries, one
7469 1.19 jonathan * packet-record per SPD entry, prepends the key_src sockaddr
7470 1.19 jonathan * to each packet-record, links the sockaddr mbufs into a new
7471 1.19 jonathan * list of records, then appends the entire resulting
7472 1.19 jonathan * list to the requesting socket.
7473 1.19 jonathan */
7474 1.137 ozaki ok = sbappendaddrchain(&so->so_rcv, (struct sockaddr *)&key_src, n,
7475 1.137 ozaki SB_PRIO_ONESHOT_OVERFLOW);
7476 1.19 jonathan
7477 1.19 jonathan if (!ok) {
7478 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_IN_NOMEM);
7479 1.19 jonathan m_freem(n);
7480 1.19 jonathan return key_senderror(so, m0, ENOBUFS);
7481 1.19 jonathan }
7482 1.19 jonathan
7483 1.19 jonathan m_freem(m0);
7484 1.1 jonathan return 0;
7485 1.1 jonathan }
7486 1.1 jonathan
7487 1.1 jonathan /*
7488 1.1 jonathan * SADB_X_PROMISC processing
7489 1.1 jonathan *
7490 1.1 jonathan * m will always be freed.
7491 1.1 jonathan */
7492 1.1 jonathan static int
7493 1.162 ozaki key_api_promisc(struct socket *so, struct mbuf *m,
7494 1.49 degroote const struct sadb_msghdr *mhp)
7495 1.1 jonathan {
7496 1.1 jonathan int olen;
7497 1.1 jonathan
7498 1.1 jonathan olen = PFKEY_UNUNIT64(mhp->msg->sadb_msg_len);
7499 1.1 jonathan
7500 1.1 jonathan if (olen < sizeof(struct sadb_msg)) {
7501 1.1 jonathan #if 1
7502 1.1 jonathan return key_senderror(so, m, EINVAL);
7503 1.1 jonathan #else
7504 1.1 jonathan m_freem(m);
7505 1.1 jonathan return 0;
7506 1.1 jonathan #endif
7507 1.1 jonathan } else if (olen == sizeof(struct sadb_msg)) {
7508 1.1 jonathan /* enable/disable promisc mode */
7509 1.137 ozaki struct keycb *kp = (struct keycb *)sotorawcb(so);
7510 1.137 ozaki if (kp == NULL)
7511 1.1 jonathan return key_senderror(so, m, EINVAL);
7512 1.1 jonathan mhp->msg->sadb_msg_errno = 0;
7513 1.1 jonathan switch (mhp->msg->sadb_msg_satype) {
7514 1.1 jonathan case 0:
7515 1.1 jonathan case 1:
7516 1.1 jonathan kp->kp_promisc = mhp->msg->sadb_msg_satype;
7517 1.1 jonathan break;
7518 1.1 jonathan default:
7519 1.1 jonathan return key_senderror(so, m, EINVAL);
7520 1.1 jonathan }
7521 1.1 jonathan
7522 1.1 jonathan /* send the original message back to everyone */
7523 1.1 jonathan mhp->msg->sadb_msg_errno = 0;
7524 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
7525 1.1 jonathan } else {
7526 1.1 jonathan /* send packet as is */
7527 1.1 jonathan
7528 1.1 jonathan m_adj(m, PFKEY_ALIGN8(sizeof(struct sadb_msg)));
7529 1.1 jonathan
7530 1.1 jonathan /* TODO: if sadb_msg_seq is specified, send to specific pid */
7531 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
7532 1.1 jonathan }
7533 1.1 jonathan }
7534 1.1 jonathan
7535 1.162 ozaki static int (*key_api_typesw[]) (struct socket *, struct mbuf *,
7536 1.49 degroote const struct sadb_msghdr *) = {
7537 1.162 ozaki NULL, /* SADB_RESERVED */
7538 1.162 ozaki key_api_getspi, /* SADB_GETSPI */
7539 1.162 ozaki key_api_update, /* SADB_UPDATE */
7540 1.162 ozaki key_api_add, /* SADB_ADD */
7541 1.162 ozaki key_api_delete, /* SADB_DELETE */
7542 1.162 ozaki key_api_get, /* SADB_GET */
7543 1.162 ozaki key_api_acquire, /* SADB_ACQUIRE */
7544 1.162 ozaki key_api_register, /* SADB_REGISTER */
7545 1.162 ozaki NULL, /* SADB_EXPIRE */
7546 1.162 ozaki key_api_flush, /* SADB_FLUSH */
7547 1.162 ozaki key_api_dump, /* SADB_DUMP */
7548 1.162 ozaki key_api_promisc, /* SADB_X_PROMISC */
7549 1.162 ozaki NULL, /* SADB_X_PCHANGE */
7550 1.162 ozaki key_api_spdadd, /* SADB_X_SPDUPDATE */
7551 1.162 ozaki key_api_spdadd, /* SADB_X_SPDADD */
7552 1.162 ozaki key_api_spddelete, /* SADB_X_SPDDELETE */
7553 1.162 ozaki key_api_spdget, /* SADB_X_SPDGET */
7554 1.162 ozaki NULL, /* SADB_X_SPDACQUIRE */
7555 1.162 ozaki key_api_spddump, /* SADB_X_SPDDUMP */
7556 1.162 ozaki key_api_spdflush, /* SADB_X_SPDFLUSH */
7557 1.162 ozaki key_api_spdadd, /* SADB_X_SPDSETIDX */
7558 1.162 ozaki NULL, /* SADB_X_SPDEXPIRE */
7559 1.162 ozaki key_api_spddelete2, /* SADB_X_SPDDELETE2 */
7560 1.162 ozaki key_api_nat_map, /* SADB_X_NAT_T_NEW_MAPPING */
7561 1.1 jonathan };
7562 1.1 jonathan
7563 1.1 jonathan /*
7564 1.1 jonathan * parse sadb_msg buffer to process PFKEYv2,
7565 1.1 jonathan * and create a data to response if needed.
7566 1.1 jonathan * I think to be dealed with mbuf directly.
7567 1.1 jonathan * IN:
7568 1.1 jonathan * msgp : pointer to pointer to a received buffer pulluped.
7569 1.1 jonathan * This is rewrited to response.
7570 1.1 jonathan * so : pointer to socket.
7571 1.1 jonathan * OUT:
7572 1.1 jonathan * length for buffer to send to user process.
7573 1.1 jonathan */
7574 1.1 jonathan int
7575 1.49 degroote key_parse(struct mbuf *m, struct socket *so)
7576 1.1 jonathan {
7577 1.1 jonathan struct sadb_msg *msg;
7578 1.1 jonathan struct sadb_msghdr mh;
7579 1.97 christos u_int orglen;
7580 1.1 jonathan int error;
7581 1.1 jonathan
7582 1.112 ozaki KASSERT(m != NULL);
7583 1.112 ozaki KASSERT(so != NULL);
7584 1.1 jonathan
7585 1.1 jonathan #if 0 /*kdebug_sadb assumes msg in linear buffer*/
7586 1.111 ozaki if (KEYDEBUG_ON(KEYDEBUG_KEY_DUMP)) {
7587 1.228 christos kdebug_sadb("passed sadb_msg", msg);
7588 1.111 ozaki }
7589 1.1 jonathan #endif
7590 1.1 jonathan
7591 1.1 jonathan if (m->m_len < sizeof(struct sadb_msg)) {
7592 1.1 jonathan m = m_pullup(m, sizeof(struct sadb_msg));
7593 1.1 jonathan if (!m)
7594 1.1 jonathan return ENOBUFS;
7595 1.1 jonathan }
7596 1.1 jonathan msg = mtod(m, struct sadb_msg *);
7597 1.97 christos orglen = PFKEY_UNUNIT64(msg->sadb_msg_len);
7598 1.1 jonathan
7599 1.1 jonathan if ((m->m_flags & M_PKTHDR) == 0 ||
7600 1.97 christos m->m_pkthdr.len != orglen) {
7601 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid message length.\n");
7602 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVLEN);
7603 1.1 jonathan error = EINVAL;
7604 1.1 jonathan goto senderror;
7605 1.1 jonathan }
7606 1.1 jonathan
7607 1.1 jonathan if (msg->sadb_msg_version != PF_KEY_V2) {
7608 1.134 ozaki IPSECLOG(LOG_DEBUG, "PF_KEY version %u is mismatched.\n",
7609 1.134 ozaki msg->sadb_msg_version);
7610 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVVER);
7611 1.1 jonathan error = EINVAL;
7612 1.1 jonathan goto senderror;
7613 1.1 jonathan }
7614 1.1 jonathan
7615 1.1 jonathan if (msg->sadb_msg_type > SADB_MAX) {
7616 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid type %u is passed.\n",
7617 1.134 ozaki msg->sadb_msg_type);
7618 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVMSGTYPE);
7619 1.1 jonathan error = EINVAL;
7620 1.1 jonathan goto senderror;
7621 1.1 jonathan }
7622 1.1 jonathan
7623 1.1 jonathan /* for old-fashioned code - should be nuked */
7624 1.1 jonathan if (m->m_pkthdr.len > MCLBYTES) {
7625 1.1 jonathan m_freem(m);
7626 1.1 jonathan return ENOBUFS;
7627 1.1 jonathan }
7628 1.1 jonathan if (m->m_next) {
7629 1.1 jonathan struct mbuf *n;
7630 1.1 jonathan
7631 1.239 ozaki n = key_alloc_mbuf_simple(m->m_pkthdr.len, M_WAITOK);
7632 1.240 ozaki
7633 1.38 christos m_copydata(m, 0, m->m_pkthdr.len, mtod(n, void *));
7634 1.1 jonathan n->m_pkthdr.len = n->m_len = m->m_pkthdr.len;
7635 1.1 jonathan n->m_next = NULL;
7636 1.1 jonathan m_freem(m);
7637 1.1 jonathan m = n;
7638 1.1 jonathan }
7639 1.1 jonathan
7640 1.1 jonathan /* align the mbuf chain so that extensions are in contiguous region. */
7641 1.1 jonathan error = key_align(m, &mh);
7642 1.1 jonathan if (error)
7643 1.1 jonathan return error;
7644 1.1 jonathan
7645 1.1 jonathan if (m->m_next) { /*XXX*/
7646 1.1 jonathan m_freem(m);
7647 1.1 jonathan return ENOBUFS;
7648 1.1 jonathan }
7649 1.1 jonathan
7650 1.1 jonathan msg = mh.msg;
7651 1.1 jonathan
7652 1.1 jonathan /* check SA type */
7653 1.1 jonathan switch (msg->sadb_msg_satype) {
7654 1.1 jonathan case SADB_SATYPE_UNSPEC:
7655 1.1 jonathan switch (msg->sadb_msg_type) {
7656 1.1 jonathan case SADB_GETSPI:
7657 1.1 jonathan case SADB_UPDATE:
7658 1.1 jonathan case SADB_ADD:
7659 1.1 jonathan case SADB_DELETE:
7660 1.1 jonathan case SADB_GET:
7661 1.1 jonathan case SADB_ACQUIRE:
7662 1.1 jonathan case SADB_EXPIRE:
7663 1.134 ozaki IPSECLOG(LOG_DEBUG,
7664 1.134 ozaki "must specify satype when msg type=%u.\n",
7665 1.134 ozaki msg->sadb_msg_type);
7666 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVSATYPE);
7667 1.1 jonathan error = EINVAL;
7668 1.1 jonathan goto senderror;
7669 1.1 jonathan }
7670 1.1 jonathan break;
7671 1.1 jonathan case SADB_SATYPE_AH:
7672 1.1 jonathan case SADB_SATYPE_ESP:
7673 1.1 jonathan case SADB_X_SATYPE_IPCOMP:
7674 1.12 jonathan case SADB_X_SATYPE_TCPSIGNATURE:
7675 1.1 jonathan switch (msg->sadb_msg_type) {
7676 1.1 jonathan case SADB_X_SPDADD:
7677 1.1 jonathan case SADB_X_SPDDELETE:
7678 1.1 jonathan case SADB_X_SPDGET:
7679 1.1 jonathan case SADB_X_SPDDUMP:
7680 1.1 jonathan case SADB_X_SPDFLUSH:
7681 1.1 jonathan case SADB_X_SPDSETIDX:
7682 1.1 jonathan case SADB_X_SPDUPDATE:
7683 1.1 jonathan case SADB_X_SPDDELETE2:
7684 1.134 ozaki IPSECLOG(LOG_DEBUG, "illegal satype=%u\n",
7685 1.134 ozaki msg->sadb_msg_type);
7686 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVSATYPE);
7687 1.1 jonathan error = EINVAL;
7688 1.1 jonathan goto senderror;
7689 1.1 jonathan }
7690 1.1 jonathan break;
7691 1.1 jonathan case SADB_SATYPE_RSVP:
7692 1.1 jonathan case SADB_SATYPE_OSPFV2:
7693 1.1 jonathan case SADB_SATYPE_RIPV2:
7694 1.1 jonathan case SADB_SATYPE_MIP:
7695 1.134 ozaki IPSECLOG(LOG_DEBUG, "type %u isn't supported.\n",
7696 1.134 ozaki msg->sadb_msg_satype);
7697 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVSATYPE);
7698 1.1 jonathan error = EOPNOTSUPP;
7699 1.1 jonathan goto senderror;
7700 1.1 jonathan case 1: /* XXX: What does it do? */
7701 1.1 jonathan if (msg->sadb_msg_type == SADB_X_PROMISC)
7702 1.1 jonathan break;
7703 1.1 jonathan /*FALLTHROUGH*/
7704 1.1 jonathan default:
7705 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid type %u is passed.\n",
7706 1.134 ozaki msg->sadb_msg_satype);
7707 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVSATYPE);
7708 1.1 jonathan error = EINVAL;
7709 1.1 jonathan goto senderror;
7710 1.1 jonathan }
7711 1.1 jonathan
7712 1.1 jonathan /* check field of upper layer protocol and address family */
7713 1.137 ozaki if (mh.ext[SADB_EXT_ADDRESS_SRC] != NULL &&
7714 1.137 ozaki mh.ext[SADB_EXT_ADDRESS_DST] != NULL) {
7715 1.230 christos const struct sadb_address *src0, *dst0;
7716 1.230 christos const struct sockaddr *sa0, *da0;
7717 1.1 jonathan u_int plen;
7718 1.1 jonathan
7719 1.230 christos src0 = mh.ext[SADB_EXT_ADDRESS_SRC];
7720 1.230 christos dst0 = mh.ext[SADB_EXT_ADDRESS_DST];
7721 1.230 christos sa0 = key_msghdr_get_sockaddr(&mh, SADB_EXT_ADDRESS_SRC);
7722 1.230 christos da0 = key_msghdr_get_sockaddr(&mh, SADB_EXT_ADDRESS_DST);
7723 1.1 jonathan
7724 1.1 jonathan /* check upper layer protocol */
7725 1.1 jonathan if (src0->sadb_address_proto != dst0->sadb_address_proto) {
7726 1.230 christos IPSECLOG(LOG_DEBUG,
7727 1.230 christos "upper layer protocol mismatched.\n");
7728 1.230 christos goto invaddr;
7729 1.1 jonathan }
7730 1.1 jonathan
7731 1.1 jonathan /* check family */
7732 1.230 christos if (sa0->sa_family != da0->sa_family) {
7733 1.134 ozaki IPSECLOG(LOG_DEBUG, "address family mismatched.\n");
7734 1.230 christos goto invaddr;
7735 1.1 jonathan }
7736 1.230 christos if (sa0->sa_len != da0->sa_len) {
7737 1.134 ozaki IPSECLOG(LOG_DEBUG,
7738 1.134 ozaki "address struct size mismatched.\n");
7739 1.230 christos goto invaddr;
7740 1.1 jonathan }
7741 1.1 jonathan
7742 1.230 christos switch (sa0->sa_family) {
7743 1.1 jonathan case AF_INET:
7744 1.230 christos if (sa0->sa_len != sizeof(struct sockaddr_in))
7745 1.230 christos goto invaddr;
7746 1.1 jonathan break;
7747 1.1 jonathan case AF_INET6:
7748 1.230 christos if (sa0->sa_len != sizeof(struct sockaddr_in6))
7749 1.230 christos goto invaddr;
7750 1.1 jonathan break;
7751 1.1 jonathan default:
7752 1.134 ozaki IPSECLOG(LOG_DEBUG, "unsupported address family.\n");
7753 1.1 jonathan error = EAFNOSUPPORT;
7754 1.1 jonathan goto senderror;
7755 1.1 jonathan }
7756 1.1 jonathan
7757 1.230 christos switch (sa0->sa_family) {
7758 1.1 jonathan case AF_INET:
7759 1.1 jonathan plen = sizeof(struct in_addr) << 3;
7760 1.1 jonathan break;
7761 1.1 jonathan case AF_INET6:
7762 1.1 jonathan plen = sizeof(struct in6_addr) << 3;
7763 1.1 jonathan break;
7764 1.1 jonathan default:
7765 1.1 jonathan plen = 0; /*fool gcc*/
7766 1.1 jonathan break;
7767 1.1 jonathan }
7768 1.1 jonathan
7769 1.1 jonathan /* check max prefix length */
7770 1.1 jonathan if (src0->sadb_address_prefixlen > plen ||
7771 1.1 jonathan dst0->sadb_address_prefixlen > plen) {
7772 1.134 ozaki IPSECLOG(LOG_DEBUG, "illegal prefixlen.\n");
7773 1.230 christos goto invaddr;
7774 1.1 jonathan }
7775 1.1 jonathan
7776 1.1 jonathan /*
7777 1.1 jonathan * prefixlen == 0 is valid because there can be a case when
7778 1.1 jonathan * all addresses are matched.
7779 1.1 jonathan */
7780 1.1 jonathan }
7781 1.1 jonathan
7782 1.162 ozaki if (msg->sadb_msg_type >= __arraycount(key_api_typesw) ||
7783 1.162 ozaki key_api_typesw[msg->sadb_msg_type] == NULL) {
7784 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVMSGTYPE);
7785 1.1 jonathan error = EINVAL;
7786 1.1 jonathan goto senderror;
7787 1.1 jonathan }
7788 1.1 jonathan
7789 1.162 ozaki return (*key_api_typesw[msg->sadb_msg_type])(so, m, &mh);
7790 1.1 jonathan
7791 1.230 christos invaddr:
7792 1.230 christos error = EINVAL;
7793 1.1 jonathan senderror:
7794 1.230 christos PFKEY_STATINC(PFKEY_STAT_OUT_INVADDR);
7795 1.150 ozaki return key_senderror(so, m, error);
7796 1.1 jonathan }
7797 1.1 jonathan
7798 1.1 jonathan static int
7799 1.49 degroote key_senderror(struct socket *so, struct mbuf *m, int code)
7800 1.1 jonathan {
7801 1.1 jonathan struct sadb_msg *msg;
7802 1.1 jonathan
7803 1.112 ozaki KASSERT(m->m_len >= sizeof(struct sadb_msg));
7804 1.1 jonathan
7805 1.1 jonathan msg = mtod(m, struct sadb_msg *);
7806 1.1 jonathan msg->sadb_msg_errno = code;
7807 1.1 jonathan return key_sendup_mbuf(so, m, KEY_SENDUP_ONE);
7808 1.1 jonathan }
7809 1.1 jonathan
7810 1.1 jonathan /*
7811 1.1 jonathan * set the pointer to each header into message buffer.
7812 1.1 jonathan * m will be freed on error.
7813 1.1 jonathan * XXX larger-than-MCLBYTES extension?
7814 1.1 jonathan */
7815 1.1 jonathan static int
7816 1.49 degroote key_align(struct mbuf *m, struct sadb_msghdr *mhp)
7817 1.1 jonathan {
7818 1.1 jonathan struct mbuf *n;
7819 1.1 jonathan struct sadb_ext *ext;
7820 1.1 jonathan size_t off, end;
7821 1.1 jonathan int extlen;
7822 1.1 jonathan int toff;
7823 1.1 jonathan
7824 1.112 ozaki KASSERT(m != NULL);
7825 1.112 ozaki KASSERT(mhp != NULL);
7826 1.112 ozaki KASSERT(m->m_len >= sizeof(struct sadb_msg));
7827 1.1 jonathan
7828 1.1 jonathan /* initialize */
7829 1.49 degroote memset(mhp, 0, sizeof(*mhp));
7830 1.1 jonathan
7831 1.1 jonathan mhp->msg = mtod(m, struct sadb_msg *);
7832 1.230 christos mhp->ext[0] = mhp->msg; /*XXX backward compat */
7833 1.1 jonathan
7834 1.1 jonathan end = PFKEY_UNUNIT64(mhp->msg->sadb_msg_len);
7835 1.1 jonathan extlen = end; /*just in case extlen is not updated*/
7836 1.1 jonathan for (off = sizeof(struct sadb_msg); off < end; off += extlen) {
7837 1.1 jonathan n = m_pulldown(m, off, sizeof(struct sadb_ext), &toff);
7838 1.1 jonathan if (!n) {
7839 1.1 jonathan /* m is already freed */
7840 1.1 jonathan return ENOBUFS;
7841 1.1 jonathan }
7842 1.39 degroote ext = (struct sadb_ext *)(mtod(n, char *) + toff);
7843 1.1 jonathan
7844 1.1 jonathan /* set pointer */
7845 1.1 jonathan switch (ext->sadb_ext_type) {
7846 1.1 jonathan case SADB_EXT_SA:
7847 1.1 jonathan case SADB_EXT_ADDRESS_SRC:
7848 1.1 jonathan case SADB_EXT_ADDRESS_DST:
7849 1.1 jonathan case SADB_EXT_ADDRESS_PROXY:
7850 1.1 jonathan case SADB_EXT_LIFETIME_CURRENT:
7851 1.1 jonathan case SADB_EXT_LIFETIME_HARD:
7852 1.1 jonathan case SADB_EXT_LIFETIME_SOFT:
7853 1.1 jonathan case SADB_EXT_KEY_AUTH:
7854 1.1 jonathan case SADB_EXT_KEY_ENCRYPT:
7855 1.1 jonathan case SADB_EXT_IDENTITY_SRC:
7856 1.1 jonathan case SADB_EXT_IDENTITY_DST:
7857 1.1 jonathan case SADB_EXT_SENSITIVITY:
7858 1.1 jonathan case SADB_EXT_PROPOSAL:
7859 1.1 jonathan case SADB_EXT_SUPPORTED_AUTH:
7860 1.1 jonathan case SADB_EXT_SUPPORTED_ENCRYPT:
7861 1.1 jonathan case SADB_EXT_SPIRANGE:
7862 1.1 jonathan case SADB_X_EXT_POLICY:
7863 1.1 jonathan case SADB_X_EXT_SA2:
7864 1.48 degroote case SADB_X_EXT_NAT_T_TYPE:
7865 1.48 degroote case SADB_X_EXT_NAT_T_SPORT:
7866 1.48 degroote case SADB_X_EXT_NAT_T_DPORT:
7867 1.64 spz case SADB_X_EXT_NAT_T_OAI:
7868 1.64 spz case SADB_X_EXT_NAT_T_OAR:
7869 1.48 degroote case SADB_X_EXT_NAT_T_FRAG:
7870 1.1 jonathan /* duplicate check */
7871 1.1 jonathan /*
7872 1.1 jonathan * XXX Are there duplication payloads of either
7873 1.1 jonathan * KEY_AUTH or KEY_ENCRYPT ?
7874 1.1 jonathan */
7875 1.1 jonathan if (mhp->ext[ext->sadb_ext_type] != NULL) {
7876 1.134 ozaki IPSECLOG(LOG_DEBUG,
7877 1.134 ozaki "duplicate ext_type %u is passed.\n",
7878 1.134 ozaki ext->sadb_ext_type);
7879 1.1 jonathan m_freem(m);
7880 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_DUPEXT);
7881 1.1 jonathan return EINVAL;
7882 1.1 jonathan }
7883 1.1 jonathan break;
7884 1.1 jonathan default:
7885 1.134 ozaki IPSECLOG(LOG_DEBUG, "invalid ext_type %u is passed.\n",
7886 1.134 ozaki ext->sadb_ext_type);
7887 1.1 jonathan m_freem(m);
7888 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVEXTTYPE);
7889 1.1 jonathan return EINVAL;
7890 1.1 jonathan }
7891 1.1 jonathan
7892 1.1 jonathan extlen = PFKEY_UNUNIT64(ext->sadb_ext_len);
7893 1.1 jonathan
7894 1.1 jonathan if (key_validate_ext(ext, extlen)) {
7895 1.1 jonathan m_freem(m);
7896 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVLEN);
7897 1.1 jonathan return EINVAL;
7898 1.1 jonathan }
7899 1.1 jonathan
7900 1.1 jonathan n = m_pulldown(m, off, extlen, &toff);
7901 1.1 jonathan if (!n) {
7902 1.1 jonathan /* m is already freed */
7903 1.1 jonathan return ENOBUFS;
7904 1.1 jonathan }
7905 1.39 degroote ext = (struct sadb_ext *)(mtod(n, char *) + toff);
7906 1.1 jonathan
7907 1.1 jonathan mhp->ext[ext->sadb_ext_type] = ext;
7908 1.1 jonathan mhp->extoff[ext->sadb_ext_type] = off;
7909 1.1 jonathan mhp->extlen[ext->sadb_ext_type] = extlen;
7910 1.1 jonathan }
7911 1.1 jonathan
7912 1.1 jonathan if (off != end) {
7913 1.1 jonathan m_freem(m);
7914 1.52 thorpej PFKEY_STATINC(PFKEY_STAT_OUT_INVLEN);
7915 1.1 jonathan return EINVAL;
7916 1.1 jonathan }
7917 1.1 jonathan
7918 1.1 jonathan return 0;
7919 1.1 jonathan }
7920 1.1 jonathan
7921 1.1 jonathan static int
7922 1.49 degroote key_validate_ext(const struct sadb_ext *ext, int len)
7923 1.1 jonathan {
7924 1.1 jonathan const struct sockaddr *sa;
7925 1.1 jonathan enum { NONE, ADDR } checktype = NONE;
7926 1.1 jonathan int baselen = 0;
7927 1.1 jonathan const int sal = offsetof(struct sockaddr, sa_len) + sizeof(sa->sa_len);
7928 1.1 jonathan
7929 1.1 jonathan if (len != PFKEY_UNUNIT64(ext->sadb_ext_len))
7930 1.1 jonathan return EINVAL;
7931 1.1 jonathan
7932 1.1 jonathan /* if it does not match minimum/maximum length, bail */
7933 1.140 ozaki if (ext->sadb_ext_type >= __arraycount(minsize) ||
7934 1.140 ozaki ext->sadb_ext_type >= __arraycount(maxsize))
7935 1.1 jonathan return EINVAL;
7936 1.1 jonathan if (!minsize[ext->sadb_ext_type] || len < minsize[ext->sadb_ext_type])
7937 1.1 jonathan return EINVAL;
7938 1.1 jonathan if (maxsize[ext->sadb_ext_type] && len > maxsize[ext->sadb_ext_type])
7939 1.1 jonathan return EINVAL;
7940 1.1 jonathan
7941 1.1 jonathan /* more checks based on sadb_ext_type XXX need more */
7942 1.1 jonathan switch (ext->sadb_ext_type) {
7943 1.1 jonathan case SADB_EXT_ADDRESS_SRC:
7944 1.1 jonathan case SADB_EXT_ADDRESS_DST:
7945 1.1 jonathan case SADB_EXT_ADDRESS_PROXY:
7946 1.1 jonathan baselen = PFKEY_ALIGN8(sizeof(struct sadb_address));
7947 1.1 jonathan checktype = ADDR;
7948 1.1 jonathan break;
7949 1.1 jonathan case SADB_EXT_IDENTITY_SRC:
7950 1.1 jonathan case SADB_EXT_IDENTITY_DST:
7951 1.1 jonathan if (((const struct sadb_ident *)ext)->sadb_ident_type ==
7952 1.1 jonathan SADB_X_IDENTTYPE_ADDR) {
7953 1.1 jonathan baselen = PFKEY_ALIGN8(sizeof(struct sadb_ident));
7954 1.1 jonathan checktype = ADDR;
7955 1.1 jonathan } else
7956 1.1 jonathan checktype = NONE;
7957 1.1 jonathan break;
7958 1.1 jonathan default:
7959 1.1 jonathan checktype = NONE;
7960 1.1 jonathan break;
7961 1.1 jonathan }
7962 1.1 jonathan
7963 1.1 jonathan switch (checktype) {
7964 1.1 jonathan case NONE:
7965 1.1 jonathan break;
7966 1.1 jonathan case ADDR:
7967 1.1 jonathan sa = (const struct sockaddr *)(((const u_int8_t*)ext)+baselen);
7968 1.1 jonathan if (len < baselen + sal)
7969 1.1 jonathan return EINVAL;
7970 1.1 jonathan if (baselen + PFKEY_ALIGN8(sa->sa_len) != len)
7971 1.1 jonathan return EINVAL;
7972 1.1 jonathan break;
7973 1.1 jonathan }
7974 1.1 jonathan
7975 1.1 jonathan return 0;
7976 1.1 jonathan }
7977 1.1 jonathan
7978 1.52 thorpej static int
7979 1.52 thorpej key_do_init(void)
7980 1.1 jonathan {
7981 1.126 ozaki int i, error;
7982 1.1 jonathan
7983 1.208 ozaki mutex_init(&key_misc.lock, MUTEX_DEFAULT, IPL_NONE);
7984 1.226 ozaki
7985 1.208 ozaki mutex_init(&key_spd.lock, MUTEX_DEFAULT, IPL_NONE);
7986 1.226 ozaki cv_init(&key_spd.cv_lc, "key_sp_lc");
7987 1.226 ozaki key_spd.psz = pserialize_create();
7988 1.226 ozaki cv_init(&key_spd.cv_psz, "key_sp_psz");
7989 1.226 ozaki key_spd.psz_performing = false;
7990 1.226 ozaki
7991 1.208 ozaki mutex_init(&key_sad.lock, MUTEX_DEFAULT, IPL_NONE);
7992 1.226 ozaki cv_init(&key_sad.cv_lc, "key_sa_lc");
7993 1.226 ozaki key_sad.psz = pserialize_create();
7994 1.226 ozaki cv_init(&key_sad.cv_psz, "key_sa_psz");
7995 1.226 ozaki key_sad.psz_performing = false;
7996 1.141 ozaki
7997 1.52 thorpej pfkeystat_percpu = percpu_alloc(sizeof(uint64_t) * PFKEY_NSTATS);
7998 1.52 thorpej
7999 1.235 ozaki callout_init(&key_timehandler_ch, CALLOUT_MPSAFE);
8000 1.126 ozaki error = workqueue_create(&key_timehandler_wq, "key_timehandler",
8001 1.126 ozaki key_timehandler_work, NULL, PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
8002 1.126 ozaki if (error != 0)
8003 1.126 ozaki panic("%s: workqueue_create failed (%d)\n", __func__, error);
8004 1.1 jonathan
8005 1.1 jonathan for (i = 0; i < IPSEC_DIR_MAX; i++) {
8006 1.208 ozaki PSLIST_INIT(&key_spd.splist[i]);
8007 1.1 jonathan }
8008 1.1 jonathan
8009 1.208 ozaki PSLIST_INIT(&key_spd.socksplist);
8010 1.197 ozaki
8011 1.208 ozaki PSLIST_INIT(&key_sad.sahlist);
8012 1.1 jonathan
8013 1.1 jonathan for (i = 0; i <= SADB_SATYPE_MAX; i++) {
8014 1.208 ozaki LIST_INIT(&key_misc.reglist[i]);
8015 1.1 jonathan }
8016 1.1 jonathan
8017 1.1 jonathan #ifndef IPSEC_NONBLOCK_ACQUIRE
8018 1.208 ozaki LIST_INIT(&key_misc.acqlist);
8019 1.1 jonathan #endif
8020 1.139 ozaki #ifdef notyet
8021 1.208 ozaki LIST_INIT(&key_misc.spacqlist);
8022 1.139 ozaki #endif
8023 1.1 jonathan
8024 1.1 jonathan /* system default */
8025 1.1 jonathan ip4_def_policy.policy = IPSEC_POLICY_NONE;
8026 1.197 ozaki ip4_def_policy.state = IPSEC_SPSTATE_ALIVE;
8027 1.197 ozaki localcount_init(&ip4_def_policy.localcount);
8028 1.1 jonathan
8029 1.47 degroote #ifdef INET6
8030 1.47 degroote ip6_def_policy.policy = IPSEC_POLICY_NONE;
8031 1.197 ozaki ip6_def_policy.state = IPSEC_SPSTATE_ALIVE;
8032 1.197 ozaki localcount_init(&ip6_def_policy.localcount);
8033 1.47 degroote #endif
8034 1.47 degroote
8035 1.40 degroote callout_reset(&key_timehandler_ch, hz, key_timehandler, NULL);
8036 1.1 jonathan
8037 1.1 jonathan /* initialize key statistics */
8038 1.1 jonathan keystat.getspi_count = 1;
8039 1.1 jonathan
8040 1.63 hubertf aprint_verbose("IPsec: Initialized Security Association Processing.\n");
8041 1.1 jonathan
8042 1.52 thorpej return (0);
8043 1.52 thorpej }
8044 1.52 thorpej
8045 1.52 thorpej void
8046 1.52 thorpej key_init(void)
8047 1.52 thorpej {
8048 1.52 thorpej static ONCE_DECL(key_init_once);
8049 1.52 thorpej
8050 1.104 ozaki sysctl_net_keyv2_setup(NULL);
8051 1.104 ozaki sysctl_net_key_compat_setup(NULL);
8052 1.104 ozaki
8053 1.52 thorpej RUN_ONCE(&key_init_once, key_do_init);
8054 1.196 ozaki
8055 1.196 ozaki key_init_so();
8056 1.1 jonathan }
8057 1.1 jonathan
8058 1.1 jonathan /*
8059 1.1 jonathan * XXX: maybe This function is called after INBOUND IPsec processing.
8060 1.1 jonathan *
8061 1.1 jonathan * Special check for tunnel-mode packets.
8062 1.1 jonathan * We must make some checks for consistency between inner and outer IP header.
8063 1.1 jonathan *
8064 1.1 jonathan * xxx more checks to be provided
8065 1.1 jonathan */
8066 1.1 jonathan int
8067 1.29 christos key_checktunnelsanity(
8068 1.29 christos struct secasvar *sav,
8069 1.30 christos u_int family,
8070 1.38 christos void *src,
8071 1.38 christos void *dst
8072 1.29 christos )
8073 1.1 jonathan {
8074 1.112 ozaki
8075 1.1 jonathan /* XXX: check inner IP header */
8076 1.1 jonathan
8077 1.1 jonathan return 1;
8078 1.1 jonathan }
8079 1.1 jonathan
8080 1.1 jonathan #if 0
8081 1.1 jonathan #define hostnamelen strlen(hostname)
8082 1.1 jonathan
8083 1.1 jonathan /*
8084 1.1 jonathan * Get FQDN for the host.
8085 1.1 jonathan * If the administrator configured hostname (by hostname(1)) without
8086 1.1 jonathan * domain name, returns nothing.
8087 1.1 jonathan */
8088 1.1 jonathan static const char *
8089 1.61 cegger key_getfqdn(void)
8090 1.1 jonathan {
8091 1.1 jonathan int i;
8092 1.1 jonathan int hasdot;
8093 1.1 jonathan static char fqdn[MAXHOSTNAMELEN + 1];
8094 1.1 jonathan
8095 1.1 jonathan if (!hostnamelen)
8096 1.1 jonathan return NULL;
8097 1.1 jonathan
8098 1.1 jonathan /* check if it comes with domain name. */
8099 1.1 jonathan hasdot = 0;
8100 1.1 jonathan for (i = 0; i < hostnamelen; i++) {
8101 1.1 jonathan if (hostname[i] == '.')
8102 1.1 jonathan hasdot++;
8103 1.1 jonathan }
8104 1.1 jonathan if (!hasdot)
8105 1.1 jonathan return NULL;
8106 1.1 jonathan
8107 1.1 jonathan /* NOTE: hostname may not be NUL-terminated. */
8108 1.49 degroote memset(fqdn, 0, sizeof(fqdn));
8109 1.49 degroote memcpy(fqdn, hostname, hostnamelen);
8110 1.1 jonathan fqdn[hostnamelen] = '\0';
8111 1.1 jonathan return fqdn;
8112 1.1 jonathan }
8113 1.1 jonathan
8114 1.1 jonathan /*
8115 1.1 jonathan * get username@FQDN for the host/user.
8116 1.1 jonathan */
8117 1.1 jonathan static const char *
8118 1.61 cegger key_getuserfqdn(void)
8119 1.1 jonathan {
8120 1.1 jonathan const char *host;
8121 1.1 jonathan static char userfqdn[MAXHOSTNAMELEN + MAXLOGNAME + 2];
8122 1.1 jonathan struct proc *p = curproc;
8123 1.1 jonathan char *q;
8124 1.1 jonathan
8125 1.1 jonathan if (!p || !p->p_pgrp || !p->p_pgrp->pg_session)
8126 1.1 jonathan return NULL;
8127 1.1 jonathan if (!(host = key_getfqdn()))
8128 1.1 jonathan return NULL;
8129 1.1 jonathan
8130 1.1 jonathan /* NOTE: s_login may not be-NUL terminated. */
8131 1.49 degroote memset(userfqdn, 0, sizeof(userfqdn));
8132 1.49 degroote memcpy(userfqdn, Mp->p_pgrp->pg_session->s_login, AXLOGNAME);
8133 1.1 jonathan userfqdn[MAXLOGNAME] = '\0'; /* safeguard */
8134 1.1 jonathan q = userfqdn + strlen(userfqdn);
8135 1.1 jonathan *q++ = '@';
8136 1.49 degroote memcpy(q, host, strlen(host));
8137 1.1 jonathan q += strlen(host);
8138 1.1 jonathan *q++ = '\0';
8139 1.1 jonathan
8140 1.1 jonathan return userfqdn;
8141 1.1 jonathan }
8142 1.1 jonathan #endif
8143 1.1 jonathan
8144 1.1 jonathan /* record data transfer on SA, and update timestamps */
8145 1.1 jonathan void
8146 1.49 degroote key_sa_recordxfer(struct secasvar *sav, struct mbuf *m)
8147 1.1 jonathan {
8148 1.108 ozaki
8149 1.108 ozaki KASSERT(sav != NULL);
8150 1.178 ozaki KASSERT(sav->lft_c != NULL);
8151 1.108 ozaki KASSERT(m != NULL);
8152 1.1 jonathan
8153 1.1 jonathan /*
8154 1.1 jonathan * XXX Currently, there is a difference of bytes size
8155 1.1 jonathan * between inbound and outbound processing.
8156 1.1 jonathan */
8157 1.1 jonathan sav->lft_c->sadb_lifetime_bytes += m->m_pkthdr.len;
8158 1.1 jonathan /* to check bytes lifetime is done in key_timehandler(). */
8159 1.1 jonathan
8160 1.1 jonathan /*
8161 1.1 jonathan * We use the number of packets as the unit of
8162 1.1 jonathan * sadb_lifetime_allocations. We increment the variable
8163 1.1 jonathan * whenever {esp,ah}_{in,out}put is called.
8164 1.1 jonathan */
8165 1.1 jonathan sav->lft_c->sadb_lifetime_allocations++;
8166 1.1 jonathan /* XXX check for expires? */
8167 1.1 jonathan
8168 1.1 jonathan /*
8169 1.1 jonathan * NOTE: We record CURRENT sadb_lifetime_usetime by using wall clock,
8170 1.1 jonathan * in seconds. HARD and SOFT lifetime are measured by the time
8171 1.1 jonathan * difference (again in seconds) from sadb_lifetime_usetime.
8172 1.1 jonathan *
8173 1.1 jonathan * usetime
8174 1.1 jonathan * v expire expire
8175 1.1 jonathan * -----+-----+--------+---> t
8176 1.1 jonathan * <--------------> HARD
8177 1.1 jonathan * <-----> SOFT
8178 1.1 jonathan */
8179 1.69 drochner sav->lft_c->sadb_lifetime_usetime = time_uptime;
8180 1.1 jonathan /* XXX check for expires? */
8181 1.1 jonathan
8182 1.1 jonathan return;
8183 1.1 jonathan }
8184 1.1 jonathan
8185 1.1 jonathan /* dumb version */
8186 1.1 jonathan void
8187 1.49 degroote key_sa_routechange(struct sockaddr *dst)
8188 1.1 jonathan {
8189 1.1 jonathan struct secashead *sah;
8190 1.216 ozaki int s;
8191 1.1 jonathan
8192 1.216 ozaki s = pserialize_read_enter();
8193 1.202 ozaki SAHLIST_READER_FOREACH(sah) {
8194 1.216 ozaki struct route *ro;
8195 1.216 ozaki const struct sockaddr *sa;
8196 1.216 ozaki
8197 1.216 ozaki key_sah_ref(sah);
8198 1.216 ozaki pserialize_read_exit(s);
8199 1.216 ozaki
8200 1.1 jonathan ro = &sah->sa_route;
8201 1.56 mlelstv sa = rtcache_getdst(ro);
8202 1.56 mlelstv if (sa != NULL && dst->sa_len == sa->sa_len &&
8203 1.56 mlelstv memcmp(dst, sa, dst->sa_len) == 0)
8204 1.32 joerg rtcache_free(ro);
8205 1.216 ozaki
8206 1.216 ozaki s = pserialize_read_enter();
8207 1.216 ozaki key_sah_unref(sah);
8208 1.1 jonathan }
8209 1.216 ozaki pserialize_read_exit(s);
8210 1.1 jonathan
8211 1.1 jonathan return;
8212 1.1 jonathan }
8213 1.1 jonathan
8214 1.1 jonathan static void
8215 1.49 degroote key_sa_chgstate(struct secasvar *sav, u_int8_t state)
8216 1.1 jonathan {
8217 1.187 ozaki struct secasvar *_sav;
8218 1.112 ozaki
8219 1.223 ozaki ASSERT_SLEEPABLE();
8220 1.223 ozaki KASSERT(mutex_owned(&key_sad.lock));
8221 1.1 jonathan
8222 1.1 jonathan if (sav->state == state)
8223 1.1 jonathan return;
8224 1.1 jonathan
8225 1.223 ozaki key_unlink_sav(sav);
8226 1.225 knakahar localcount_fini(&sav->localcount);
8227 1.203 ozaki SAVLIST_ENTRY_DESTROY(sav);
8228 1.223 ozaki key_init_sav(sav);
8229 1.1 jonathan
8230 1.1 jonathan sav->state = state;
8231 1.187 ozaki if (!SADB_SASTATE_USABLE_P(sav)) {
8232 1.187 ozaki /* We don't need to care about the order */
8233 1.203 ozaki SAVLIST_WRITER_INSERT_HEAD(sav->sah, state, sav);
8234 1.187 ozaki return;
8235 1.187 ozaki }
8236 1.187 ozaki /*
8237 1.187 ozaki * Sort the list by lft_c->sadb_lifetime_addtime
8238 1.187 ozaki * in ascending order.
8239 1.187 ozaki */
8240 1.203 ozaki SAVLIST_READER_FOREACH(_sav, sav->sah, state) {
8241 1.187 ozaki if (_sav->lft_c->sadb_lifetime_addtime >
8242 1.187 ozaki sav->lft_c->sadb_lifetime_addtime) {
8243 1.203 ozaki SAVLIST_WRITER_INSERT_BEFORE(_sav, sav);
8244 1.187 ozaki break;
8245 1.187 ozaki }
8246 1.187 ozaki }
8247 1.187 ozaki if (_sav == NULL) {
8248 1.203 ozaki SAVLIST_WRITER_INSERT_TAIL(sav->sah, state, sav);
8249 1.187 ozaki }
8250 1.187 ozaki key_validate_savlist(sav->sah, state);
8251 1.1 jonathan }
8252 1.1 jonathan
8253 1.1 jonathan /* XXX too much? */
8254 1.1 jonathan static struct mbuf *
8255 1.239 ozaki key_alloc_mbuf(int l, int mflag)
8256 1.1 jonathan {
8257 1.1 jonathan struct mbuf *m = NULL, *n;
8258 1.1 jonathan int len, t;
8259 1.1 jonathan
8260 1.239 ozaki KASSERT(mflag == M_NOWAIT || (mflag == M_WAITOK && !cpu_softintr_p()));
8261 1.239 ozaki
8262 1.1 jonathan len = l;
8263 1.1 jonathan while (len > 0) {
8264 1.239 ozaki MGET(n, mflag, MT_DATA);
8265 1.237 ozaki if (n && len > MLEN) {
8266 1.239 ozaki MCLGET(n, mflag);
8267 1.237 ozaki if ((n->m_flags & M_EXT) == 0) {
8268 1.237 ozaki m_freem(n);
8269 1.237 ozaki n = NULL;
8270 1.237 ozaki }
8271 1.237 ozaki }
8272 1.1 jonathan if (!n) {
8273 1.1 jonathan m_freem(m);
8274 1.1 jonathan return NULL;
8275 1.1 jonathan }
8276 1.1 jonathan
8277 1.1 jonathan n->m_next = NULL;
8278 1.1 jonathan n->m_len = 0;
8279 1.1 jonathan n->m_len = M_TRAILINGSPACE(n);
8280 1.1 jonathan /* use the bottom of mbuf, hoping we can prepend afterwards */
8281 1.1 jonathan if (n->m_len > len) {
8282 1.1 jonathan t = (n->m_len - len) & ~(sizeof(long) - 1);
8283 1.1 jonathan n->m_data += t;
8284 1.1 jonathan n->m_len = len;
8285 1.1 jonathan }
8286 1.1 jonathan
8287 1.1 jonathan len -= n->m_len;
8288 1.1 jonathan
8289 1.1 jonathan if (m)
8290 1.1 jonathan m_cat(m, n);
8291 1.1 jonathan else
8292 1.1 jonathan m = n;
8293 1.1 jonathan }
8294 1.1 jonathan
8295 1.1 jonathan return m;
8296 1.1 jonathan }
8297 1.1 jonathan
8298 1.5 scw static struct mbuf *
8299 1.20 jonathan key_setdump(u_int8_t req_satype, int *errorp, uint32_t pid)
8300 1.5 scw {
8301 1.5 scw struct secashead *sah;
8302 1.5 scw struct secasvar *sav;
8303 1.5 scw u_int16_t proto;
8304 1.5 scw u_int8_t satype;
8305 1.5 scw u_int8_t state;
8306 1.5 scw int cnt;
8307 1.5 scw struct mbuf *m, *n;
8308 1.5 scw
8309 1.208 ozaki KASSERT(mutex_owned(&key_sad.lock));
8310 1.205 ozaki
8311 1.5 scw /* map satype to proto */
8312 1.137 ozaki proto = key_satype2proto(req_satype);
8313 1.137 ozaki if (proto == 0) {
8314 1.5 scw *errorp = EINVAL;
8315 1.5 scw return (NULL);
8316 1.5 scw }
8317 1.5 scw
8318 1.5 scw /* count sav entries to be sent to the userland. */
8319 1.5 scw cnt = 0;
8320 1.205 ozaki SAHLIST_WRITER_FOREACH(sah) {
8321 1.5 scw if (req_satype != SADB_SATYPE_UNSPEC &&
8322 1.5 scw proto != sah->saidx.proto)
8323 1.5 scw continue;
8324 1.5 scw
8325 1.120 ozaki SASTATE_ANY_FOREACH(state) {
8326 1.205 ozaki SAVLIST_WRITER_FOREACH(sav, sah, state) {
8327 1.5 scw cnt++;
8328 1.5 scw }
8329 1.5 scw }
8330 1.5 scw }
8331 1.5 scw
8332 1.5 scw if (cnt == 0) {
8333 1.5 scw *errorp = ENOENT;
8334 1.5 scw return (NULL);
8335 1.5 scw }
8336 1.5 scw
8337 1.5 scw /* send this to the userland, one at a time. */
8338 1.5 scw m = NULL;
8339 1.205 ozaki SAHLIST_WRITER_FOREACH(sah) {
8340 1.5 scw if (req_satype != SADB_SATYPE_UNSPEC &&
8341 1.5 scw proto != sah->saidx.proto)
8342 1.5 scw continue;
8343 1.5 scw
8344 1.5 scw /* map proto to satype */
8345 1.137 ozaki satype = key_proto2satype(sah->saidx.proto);
8346 1.137 ozaki if (satype == 0) {
8347 1.5 scw m_freem(m);
8348 1.5 scw *errorp = EINVAL;
8349 1.5 scw return (NULL);
8350 1.5 scw }
8351 1.5 scw
8352 1.120 ozaki SASTATE_ANY_FOREACH(state) {
8353 1.205 ozaki SAVLIST_WRITER_FOREACH(sav, sah, state) {
8354 1.5 scw n = key_setdumpsa(sav, SADB_DUMP, satype,
8355 1.20 jonathan --cnt, pid);
8356 1.5 scw if (!n) {
8357 1.5 scw m_freem(m);
8358 1.5 scw *errorp = ENOBUFS;
8359 1.5 scw return (NULL);
8360 1.5 scw }
8361 1.5 scw
8362 1.5 scw if (!m)
8363 1.5 scw m = n;
8364 1.5 scw else
8365 1.5 scw m_cat(m, n);
8366 1.5 scw }
8367 1.5 scw }
8368 1.5 scw }
8369 1.5 scw
8370 1.5 scw if (!m) {
8371 1.5 scw *errorp = EINVAL;
8372 1.5 scw return (NULL);
8373 1.5 scw }
8374 1.5 scw
8375 1.5 scw if ((m->m_flags & M_PKTHDR) != 0) {
8376 1.5 scw m->m_pkthdr.len = 0;
8377 1.5 scw for (n = m; n; n = n->m_next)
8378 1.5 scw m->m_pkthdr.len += n->m_len;
8379 1.5 scw }
8380 1.5 scw
8381 1.5 scw *errorp = 0;
8382 1.5 scw return (m);
8383 1.5 scw }
8384 1.5 scw
8385 1.5 scw static struct mbuf *
8386 1.20 jonathan key_setspddump(int *errorp, pid_t pid)
8387 1.5 scw {
8388 1.5 scw struct secpolicy *sp;
8389 1.5 scw int cnt;
8390 1.5 scw u_int dir;
8391 1.5 scw struct mbuf *m, *n;
8392 1.5 scw
8393 1.208 ozaki KASSERT(mutex_owned(&key_spd.lock));
8394 1.197 ozaki
8395 1.5 scw /* search SPD entry and get buffer size. */
8396 1.5 scw cnt = 0;
8397 1.5 scw for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
8398 1.197 ozaki SPLIST_WRITER_FOREACH(sp, dir) {
8399 1.5 scw cnt++;
8400 1.5 scw }
8401 1.5 scw }
8402 1.5 scw
8403 1.5 scw if (cnt == 0) {
8404 1.5 scw *errorp = ENOENT;
8405 1.5 scw return (NULL);
8406 1.5 scw }
8407 1.5 scw
8408 1.5 scw m = NULL;
8409 1.5 scw for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
8410 1.197 ozaki SPLIST_WRITER_FOREACH(sp, dir) {
8411 1.5 scw --cnt;
8412 1.20 jonathan n = key_setdumpsp(sp, SADB_X_SPDDUMP, cnt, pid);
8413 1.5 scw
8414 1.5 scw if (!n) {
8415 1.5 scw *errorp = ENOBUFS;
8416 1.5 scw m_freem(m);
8417 1.5 scw return (NULL);
8418 1.5 scw }
8419 1.5 scw if (!m)
8420 1.5 scw m = n;
8421 1.5 scw else {
8422 1.5 scw m->m_pkthdr.len += n->m_pkthdr.len;
8423 1.5 scw m_cat(m, n);
8424 1.5 scw }
8425 1.5 scw }
8426 1.5 scw }
8427 1.5 scw
8428 1.5 scw *errorp = 0;
8429 1.5 scw return (m);
8430 1.5 scw }
8431 1.5 scw
8432 1.88 christos int
8433 1.88 christos key_get_used(void) {
8434 1.194 ozaki return !SPLIST_READER_EMPTY(IPSEC_DIR_INBOUND) ||
8435 1.199 ozaki !SPLIST_READER_EMPTY(IPSEC_DIR_OUTBOUND) ||
8436 1.199 ozaki !SOCKSPLIST_READER_EMPTY();
8437 1.88 christos }
8438 1.88 christos
8439 1.88 christos void
8440 1.88 christos key_update_used(void)
8441 1.88 christos {
8442 1.88 christos switch (ipsec_enabled) {
8443 1.88 christos default:
8444 1.88 christos case 0:
8445 1.88 christos #ifdef notyet
8446 1.88 christos /* XXX: racy */
8447 1.88 christos ipsec_used = 0;
8448 1.88 christos #endif
8449 1.88 christos break;
8450 1.88 christos case 1:
8451 1.88 christos #ifndef notyet
8452 1.88 christos /* XXX: racy */
8453 1.88 christos if (!ipsec_used)
8454 1.88 christos #endif
8455 1.88 christos ipsec_used = key_get_used();
8456 1.88 christos break;
8457 1.88 christos case 2:
8458 1.88 christos ipsec_used = 1;
8459 1.88 christos break;
8460 1.88 christos }
8461 1.88 christos }
8462 1.88 christos
8463 1.5 scw static int
8464 1.5 scw sysctl_net_key_dumpsa(SYSCTLFN_ARGS)
8465 1.5 scw {
8466 1.5 scw struct mbuf *m, *n;
8467 1.5 scw int err2 = 0;
8468 1.5 scw char *p, *ep;
8469 1.5 scw size_t len;
8470 1.205 ozaki int error;
8471 1.5 scw
8472 1.5 scw if (newp)
8473 1.5 scw return (EPERM);
8474 1.5 scw if (namelen != 1)
8475 1.5 scw return (EINVAL);
8476 1.5 scw
8477 1.208 ozaki mutex_enter(&key_sad.lock);
8478 1.20 jonathan m = key_setdump(name[0], &error, l->l_proc->p_pid);
8479 1.208 ozaki mutex_exit(&key_sad.lock);
8480 1.5 scw if (!m)
8481 1.5 scw return (error);
8482 1.5 scw if (!oldp)
8483 1.5 scw *oldlenp = m->m_pkthdr.len;
8484 1.5 scw else {
8485 1.5 scw p = oldp;
8486 1.5 scw if (*oldlenp < m->m_pkthdr.len) {
8487 1.5 scw err2 = ENOMEM;
8488 1.5 scw ep = p + *oldlenp;
8489 1.5 scw } else {
8490 1.5 scw *oldlenp = m->m_pkthdr.len;
8491 1.5 scw ep = p + m->m_pkthdr.len;
8492 1.5 scw }
8493 1.5 scw for (n = m; n; n = n->m_next) {
8494 1.5 scw len = (ep - p < n->m_len) ?
8495 1.5 scw ep - p : n->m_len;
8496 1.5 scw error = copyout(mtod(n, const void *), p, len);
8497 1.5 scw p += len;
8498 1.5 scw if (error)
8499 1.5 scw break;
8500 1.5 scw }
8501 1.5 scw if (error == 0)
8502 1.5 scw error = err2;
8503 1.5 scw }
8504 1.5 scw m_freem(m);
8505 1.5 scw
8506 1.5 scw return (error);
8507 1.5 scw }
8508 1.5 scw
8509 1.5 scw static int
8510 1.5 scw sysctl_net_key_dumpsp(SYSCTLFN_ARGS)
8511 1.5 scw {
8512 1.5 scw struct mbuf *m, *n;
8513 1.5 scw int err2 = 0;
8514 1.5 scw char *p, *ep;
8515 1.5 scw size_t len;
8516 1.197 ozaki int error;
8517 1.5 scw
8518 1.5 scw if (newp)
8519 1.5 scw return (EPERM);
8520 1.5 scw if (namelen != 0)
8521 1.5 scw return (EINVAL);
8522 1.5 scw
8523 1.208 ozaki mutex_enter(&key_spd.lock);
8524 1.20 jonathan m = key_setspddump(&error, l->l_proc->p_pid);
8525 1.208 ozaki mutex_exit(&key_spd.lock);
8526 1.5 scw if (!m)
8527 1.5 scw return (error);
8528 1.5 scw if (!oldp)
8529 1.5 scw *oldlenp = m->m_pkthdr.len;
8530 1.5 scw else {
8531 1.5 scw p = oldp;
8532 1.5 scw if (*oldlenp < m->m_pkthdr.len) {
8533 1.5 scw err2 = ENOMEM;
8534 1.5 scw ep = p + *oldlenp;
8535 1.5 scw } else {
8536 1.5 scw *oldlenp = m->m_pkthdr.len;
8537 1.5 scw ep = p + m->m_pkthdr.len;
8538 1.5 scw }
8539 1.5 scw for (n = m; n; n = n->m_next) {
8540 1.137 ozaki len = (ep - p < n->m_len) ? ep - p : n->m_len;
8541 1.5 scw error = copyout(mtod(n, const void *), p, len);
8542 1.5 scw p += len;
8543 1.5 scw if (error)
8544 1.5 scw break;
8545 1.5 scw }
8546 1.5 scw if (error == 0)
8547 1.5 scw error = err2;
8548 1.5 scw }
8549 1.5 scw m_freem(m);
8550 1.5 scw
8551 1.5 scw return (error);
8552 1.5 scw }
8553 1.5 scw
8554 1.15 jonathan /*
8555 1.81 christos * Create sysctl tree for native IPSEC key knobs, originally
8556 1.15 jonathan * under name "net.keyv2" * with MIB number { CTL_NET, PF_KEY_V2. }.
8557 1.15 jonathan * However, sysctl(8) never checked for nodes under { CTL_NET, PF_KEY_V2 };
8558 1.15 jonathan * and in any case the part of our sysctl namespace used for dumping the
8559 1.15 jonathan * SPD and SA database *HAS* to be compatible with the KAME sysctl
8560 1.15 jonathan * namespace, for API reasons.
8561 1.15 jonathan *
8562 1.15 jonathan * Pending a consensus on the right way to fix this, add a level of
8563 1.81 christos * indirection in how we number the `native' IPSEC key nodes;
8564 1.15 jonathan * and (as requested by Andrew Brown) move registration of the
8565 1.15 jonathan * KAME-compatible names to a separate function.
8566 1.15 jonathan */
8567 1.15 jonathan #if 0
8568 1.81 christos # define IPSEC_PFKEY PF_KEY_V2
8569 1.81 christos # define IPSEC_PFKEY_NAME "keyv2"
8570 1.15 jonathan #else
8571 1.81 christos # define IPSEC_PFKEY PF_KEY
8572 1.81 christos # define IPSEC_PFKEY_NAME "key"
8573 1.15 jonathan #endif
8574 1.15 jonathan
8575 1.52 thorpej static int
8576 1.52 thorpej sysctl_net_key_stats(SYSCTLFN_ARGS)
8577 1.52 thorpej {
8578 1.52 thorpej
8579 1.55 thorpej return (NETSTAT_SYSCTL(pfkeystat_percpu, PFKEY_NSTATS));
8580 1.52 thorpej }
8581 1.52 thorpej
8582 1.104 ozaki static void
8583 1.104 ozaki sysctl_net_keyv2_setup(struct sysctllog **clog)
8584 1.4 atatat {
8585 1.4 atatat
8586 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8587 1.11 atatat CTLFLAG_PERMANENT,
8588 1.81 christos CTLTYPE_NODE, IPSEC_PFKEY_NAME, NULL,
8589 1.4 atatat NULL, 0, NULL, 0,
8590 1.81 christos CTL_NET, IPSEC_PFKEY, CTL_EOL);
8591 1.4 atatat
8592 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8593 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8594 1.4 atatat CTLTYPE_INT, "debug", NULL,
8595 1.4 atatat NULL, 0, &key_debug_level, 0,
8596 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_DEBUG_LEVEL, CTL_EOL);
8597 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8598 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8599 1.4 atatat CTLTYPE_INT, "spi_try", NULL,
8600 1.4 atatat NULL, 0, &key_spi_trycnt, 0,
8601 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_SPI_TRY, CTL_EOL);
8602 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8603 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8604 1.4 atatat CTLTYPE_INT, "spi_min_value", NULL,
8605 1.4 atatat NULL, 0, &key_spi_minval, 0,
8606 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_SPI_MIN_VALUE, CTL_EOL);
8607 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8608 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8609 1.4 atatat CTLTYPE_INT, "spi_max_value", NULL,
8610 1.4 atatat NULL, 0, &key_spi_maxval, 0,
8611 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_SPI_MAX_VALUE, CTL_EOL);
8612 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8613 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8614 1.4 atatat CTLTYPE_INT, "random_int", NULL,
8615 1.4 atatat NULL, 0, &key_int_random, 0,
8616 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_RANDOM_INT, CTL_EOL);
8617 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8618 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8619 1.4 atatat CTLTYPE_INT, "larval_lifetime", NULL,
8620 1.4 atatat NULL, 0, &key_larval_lifetime, 0,
8621 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_LARVAL_LIFETIME, CTL_EOL);
8622 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8623 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8624 1.4 atatat CTLTYPE_INT, "blockacq_count", NULL,
8625 1.4 atatat NULL, 0, &key_blockacq_count, 0,
8626 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_BLOCKACQ_COUNT, CTL_EOL);
8627 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8628 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8629 1.4 atatat CTLTYPE_INT, "blockacq_lifetime", NULL,
8630 1.4 atatat NULL, 0, &key_blockacq_lifetime, 0,
8631 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_BLOCKACQ_LIFETIME, CTL_EOL);
8632 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8633 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8634 1.4 atatat CTLTYPE_INT, "esp_keymin", NULL,
8635 1.4 atatat NULL, 0, &ipsec_esp_keymin, 0,
8636 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_ESP_KEYMIN, CTL_EOL);
8637 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8638 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8639 1.16 atatat CTLTYPE_INT, "prefered_oldsa", NULL,
8640 1.16 atatat NULL, 0, &key_prefered_oldsa, 0,
8641 1.16 atatat CTL_NET, PF_KEY, KEYCTL_PREFERED_OLDSA, CTL_EOL);
8642 1.16 atatat sysctl_createv(clog, 0, NULL, NULL,
8643 1.16 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8644 1.4 atatat CTLTYPE_INT, "esp_auth", NULL,
8645 1.4 atatat NULL, 0, &ipsec_esp_auth, 0,
8646 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_ESP_AUTH, CTL_EOL);
8647 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8648 1.11 atatat CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
8649 1.4 atatat CTLTYPE_INT, "ah_keymin", NULL,
8650 1.4 atatat NULL, 0, &ipsec_ah_keymin, 0,
8651 1.81 christos CTL_NET, IPSEC_PFKEY, KEYCTL_AH_KEYMIN, CTL_EOL);
8652 1.52 thorpej sysctl_createv(clog, 0, NULL, NULL,
8653 1.52 thorpej CTLFLAG_PERMANENT,
8654 1.52 thorpej CTLTYPE_STRUCT, "stats",
8655 1.52 thorpej SYSCTL_DESCR("PF_KEY statistics"),
8656 1.52 thorpej sysctl_net_key_stats, 0, NULL, 0,
8657 1.81 christos CTL_NET, IPSEC_PFKEY, CTL_CREATE, CTL_EOL);
8658 1.15 jonathan }
8659 1.15 jonathan
8660 1.15 jonathan /*
8661 1.15 jonathan * Register sysctl names used by setkey(8). For historical reasons,
8662 1.15 jonathan * and to share a single API, these names appear under { CTL_NET, PF_KEY }
8663 1.81 christos * for both IPSEC and KAME IPSEC.
8664 1.15 jonathan */
8665 1.104 ozaki static void
8666 1.104 ozaki sysctl_net_key_compat_setup(struct sysctllog **clog)
8667 1.15 jonathan {
8668 1.15 jonathan
8669 1.15 jonathan sysctl_createv(clog, 0, NULL, NULL,
8670 1.15 jonathan CTLFLAG_PERMANENT,
8671 1.15 jonathan CTLTYPE_NODE, "key", NULL,
8672 1.15 jonathan NULL, 0, NULL, 0,
8673 1.15 jonathan CTL_NET, PF_KEY, CTL_EOL);
8674 1.15 jonathan
8675 1.15 jonathan /* Register the net.key.dump{sa,sp} nodes used by setkey(8). */
8676 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8677 1.11 atatat CTLFLAG_PERMANENT,
8678 1.5 scw CTLTYPE_STRUCT, "dumpsa", NULL,
8679 1.5 scw sysctl_net_key_dumpsa, 0, NULL, 0,
8680 1.5 scw CTL_NET, PF_KEY, KEYCTL_DUMPSA, CTL_EOL);
8681 1.11 atatat sysctl_createv(clog, 0, NULL, NULL,
8682 1.11 atatat CTLFLAG_PERMANENT,
8683 1.5 scw CTLTYPE_STRUCT, "dumpsp", NULL,
8684 1.5 scw sysctl_net_key_dumpsp, 0, NULL, 0,
8685 1.5 scw CTL_NET, PF_KEY, KEYCTL_DUMPSP, CTL_EOL);
8686 1.1 jonathan }
8687