source: rtems-libbsd/freebsd/sys/net/if_ipsec.c @ 09bbedc

5-freebsd-12
Last change on this file since 09bbedc was 09bbedc, checked in by Christian Mauderer <christian.mauderer@…>, on May 3, 2018 at 11:31:25 AM

if_ipsec: Import from FreeBSD.

  • Property mode set to 100644
File size: 24.3 KB
Line 
1#include <machine/rtems-bsd-kernel-space.h>
2
3/*-
4 * Copyright (c) 2016 Yandex LLC
5 * Copyright (c) 2016 Andrey V. Elsukov <ae@FreeBSD.org>
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include <sys/cdefs.h>
31__FBSDID("$FreeBSD$");
32
33#include <rtems/bsd/local/opt_inet.h>
34#include <rtems/bsd/local/opt_inet6.h>
35
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/kernel.h>
39#include <sys/fnv_hash.h>
40#include <sys/jail.h>
41#include <sys/lock.h>
42#include <sys/malloc.h>
43#include <sys/mbuf.h>
44#include <sys/module.h>
45#include <sys/rmlock.h>
46#include <sys/socket.h>
47#include <sys/sockio.h>
48#include <sys/sx.h>
49#include <sys/errno.h>
50#include <sys/sysctl.h>
51#include <sys/priv.h>
52#include <sys/proc.h>
53#include <sys/conf.h>
54
55#include <net/if.h>
56#include <net/if_var.h>
57#include <net/if_clone.h>
58#include <net/if_types.h>
59#include <net/bpf.h>
60#include <net/route.h>
61#include <net/vnet.h>
62
63#include <netinet/in.h>
64#include <netinet/in_var.h>
65#include <netinet/ip.h>
66
67#include <netinet/ip6.h>
68#include <netinet6/in6_var.h>
69#include <netinet6/scope6_var.h>
70
71#include <netipsec/ipsec.h>
72#ifdef INET6
73#include <netipsec/ipsec6.h>
74#endif
75
76#include <net/if_ipsec.h>
77#include <netipsec/key.h>
78
79#include <security/mac/mac_framework.h>
80
81static MALLOC_DEFINE(M_IPSEC, "ipsec", "IPsec Virtual Tunnel Interface");
82static const char ipsecname[] = "ipsec";
83
84#if defined(INET) && defined(INET6)
85#define IPSEC_SPCOUNT           4
86#else
87#define IPSEC_SPCOUNT           2
88#endif
89
90struct ipsec_softc {
91        struct ifnet            *ifp;
92
93        struct rmlock           lock;
94        struct secpolicy        *sp[IPSEC_SPCOUNT];
95
96        uint32_t                reqid;
97        u_int                   family;
98        u_int                   fibnum;
99        LIST_ENTRY(ipsec_softc) chain;
100        LIST_ENTRY(ipsec_softc) hash;
101};
102
103#define IPSEC_LOCK_INIT(sc)     rm_init(&(sc)->lock, "if_ipsec softc")
104#define IPSEC_LOCK_DESTROY(sc)  rm_destroy(&(sc)->lock)
105#define IPSEC_RLOCK_TRACKER     struct rm_priotracker ipsec_tracker
106#define IPSEC_RLOCK(sc)         rm_rlock(&(sc)->lock, &ipsec_tracker)
107#define IPSEC_RUNLOCK(sc)       rm_runlock(&(sc)->lock, &ipsec_tracker)
108#define IPSEC_RLOCK_ASSERT(sc)  rm_assert(&(sc)->lock, RA_RLOCKED)
109#define IPSEC_WLOCK(sc)         rm_wlock(&(sc)->lock)
110#define IPSEC_WUNLOCK(sc)       rm_wunlock(&(sc)->lock)
111#define IPSEC_WLOCK_ASSERT(sc)  rm_assert(&(sc)->lock, RA_WLOCKED)
112
113static struct rmlock ipsec_sc_lock;
114RM_SYSINIT(ipsec_sc_lock, &ipsec_sc_lock, "if_ipsec softc list");
115
116#define IPSEC_SC_RLOCK_TRACKER  struct rm_priotracker ipsec_sc_tracker
117#define IPSEC_SC_RLOCK()        rm_rlock(&ipsec_sc_lock, &ipsec_sc_tracker)
118#define IPSEC_SC_RUNLOCK()      rm_runlock(&ipsec_sc_lock, &ipsec_sc_tracker)
119#define IPSEC_SC_RLOCK_ASSERT() rm_assert(&ipsec_sc_lock, RA_RLOCKED)
120#define IPSEC_SC_WLOCK()        rm_wlock(&ipsec_sc_lock)
121#define IPSEC_SC_WUNLOCK()      rm_wunlock(&ipsec_sc_lock)
122#define IPSEC_SC_WLOCK_ASSERT() rm_assert(&ipsec_sc_lock, RA_WLOCKED)
123
124LIST_HEAD(ipsec_iflist, ipsec_softc);
125static VNET_DEFINE(struct ipsec_iflist, ipsec_sc_list);
126static VNET_DEFINE(struct ipsec_iflist *, ipsec_sc_htbl);
127static VNET_DEFINE(u_long, ipsec_sc_hmask);
128#define V_ipsec_sc_list         VNET(ipsec_sc_list)
129#define V_ipsec_sc_htbl         VNET(ipsec_sc_htbl)
130#define V_ipsec_sc_hmask        VNET(ipsec_sc_hmask)
131
132static uint32_t
133ipsec_hash(uint32_t id)
134{
135
136        return (fnv_32_buf(&id, sizeof(id), FNV1_32_INIT));
137}
138
139#define SCHASH_NHASH_LOG2       5
140#define SCHASH_NHASH            (1 << SCHASH_NHASH_LOG2)
141#define SCHASH_HASHVAL(id)      (ipsec_hash((id)) & V_ipsec_sc_hmask)
142#define SCHASH_HASH(id)         &V_ipsec_sc_htbl[SCHASH_HASHVAL(id)]
143
144/*
145 * ipsec_ioctl_sx protects from concurrent ioctls.
146 */
147static struct sx ipsec_ioctl_sx;
148SX_SYSINIT(ipsec_ioctl_sx, &ipsec_ioctl_sx, "ipsec_ioctl");
149
150static int      ipsec_init_reqid(struct ipsec_softc *);
151static int      ipsec_set_tunnel(struct ipsec_softc *, struct sockaddr *,
152    struct sockaddr *, uint32_t);
153static void     ipsec_delete_tunnel(struct ifnet *, int);
154
155static int      ipsec_set_addresses(struct ifnet *, struct sockaddr *,
156    struct sockaddr *);
157static int      ipsec_set_reqid(struct ifnet *, uint32_t);
158
159static int      ipsec_ioctl(struct ifnet *, u_long, caddr_t);
160static int      ipsec_transmit(struct ifnet *, struct mbuf *);
161static int      ipsec_output(struct ifnet *, struct mbuf *,
162    const struct sockaddr *, struct route *);
163static void     ipsec_qflush(struct ifnet *);
164static int      ipsec_clone_create(struct if_clone *, int, caddr_t);
165static void     ipsec_clone_destroy(struct ifnet *);
166
167static VNET_DEFINE(struct if_clone *, ipsec_cloner);
168#define V_ipsec_cloner          VNET(ipsec_cloner)
169
170static int
171ipsec_clone_create(struct if_clone *ifc, int unit, caddr_t params)
172{
173        struct ipsec_softc *sc;
174        struct ifnet *ifp;
175
176        sc = malloc(sizeof(*sc), M_IPSEC, M_WAITOK | M_ZERO);
177        sc->fibnum = curthread->td_proc->p_fibnum;
178        sc->ifp = ifp = if_alloc(IFT_TUNNEL);
179        IPSEC_LOCK_INIT(sc);
180        ifp->if_softc = sc;
181        if_initname(ifp, ipsecname, unit);
182
183        ifp->if_addrlen = 0;
184        ifp->if_mtu = IPSEC_MTU;
185        ifp->if_flags  = IFF_POINTOPOINT | IFF_MULTICAST;
186        ifp->if_ioctl  = ipsec_ioctl;
187        ifp->if_transmit  = ipsec_transmit;
188        ifp->if_qflush  = ipsec_qflush;
189        ifp->if_output = ipsec_output;
190        if_attach(ifp);
191        bpfattach(ifp, DLT_NULL, sizeof(uint32_t));
192
193        IPSEC_SC_WLOCK();
194        LIST_INSERT_HEAD(&V_ipsec_sc_list, sc, chain);
195        IPSEC_SC_WUNLOCK();
196        return (0);
197}
198
199static void
200ipsec_clone_destroy(struct ifnet *ifp)
201{
202        struct ipsec_softc *sc;
203
204        sx_xlock(&ipsec_ioctl_sx);
205        sc = ifp->if_softc;
206
207        IPSEC_SC_WLOCK();
208        ipsec_delete_tunnel(ifp, 1);
209        LIST_REMOVE(sc, chain);
210        IPSEC_SC_WUNLOCK();
211
212        bpfdetach(ifp);
213        if_detach(ifp);
214        ifp->if_softc = NULL;
215        sx_xunlock(&ipsec_ioctl_sx);
216
217        if_free(ifp);
218        IPSEC_LOCK_DESTROY(sc);
219        free(sc, M_IPSEC);
220}
221
222static void
223vnet_ipsec_init(const void *unused __unused)
224{
225
226        LIST_INIT(&V_ipsec_sc_list);
227        V_ipsec_sc_htbl = hashinit(SCHASH_NHASH, M_IPSEC, &V_ipsec_sc_hmask);
228        V_ipsec_cloner = if_clone_simple(ipsecname, ipsec_clone_create,
229            ipsec_clone_destroy, 0);
230}
231VNET_SYSINIT(vnet_ipsec_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
232    vnet_ipsec_init, NULL);
233
234static void
235vnet_ipsec_uninit(const void *unused __unused)
236{
237
238        if_clone_detach(V_ipsec_cloner);
239        hashdestroy(V_ipsec_sc_htbl, M_IPSEC, V_ipsec_sc_hmask);
240}
241VNET_SYSUNINIT(vnet_ipsec_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
242    vnet_ipsec_uninit, NULL);
243
244static struct secpolicy *
245ipsec_getpolicy(struct ipsec_softc *sc, int dir, sa_family_t af)
246{
247
248        switch (af) {
249#ifdef INET
250        case AF_INET:
251                return (sc->sp[(dir == IPSEC_DIR_INBOUND ? 0: 1)]);
252#endif
253#ifdef INET6
254        case AF_INET6:
255                return (sc->sp[(dir == IPSEC_DIR_INBOUND ? 0: 1)
256#ifdef INET
257                        + 2
258#endif
259                ]);
260#endif
261        }
262        return (NULL);
263}
264
265static struct secasindex *
266ipsec_getsaidx(struct ipsec_softc *sc, int dir, sa_family_t af)
267{
268        struct secpolicy *sp;
269
270        sp = ipsec_getpolicy(sc, dir, af);
271        if (sp == NULL)
272                return (NULL);
273        return (&sp->req[0]->saidx);
274}
275
276static int
277ipsec_transmit(struct ifnet *ifp, struct mbuf *m)
278{
279        IPSEC_RLOCK_TRACKER;
280        struct ipsec_softc *sc;
281        struct secpolicy *sp;
282        struct ip *ip;
283        uint32_t af;
284        int error;
285
286#ifdef MAC
287        error = mac_ifnet_check_transmit(ifp, m);
288        if (error) {
289                m_freem(m);
290                goto err;
291        }
292#endif
293        error = ENETDOWN;
294        sc = ifp->if_softc;
295        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
296            (ifp->if_flags & IFF_MONITOR) != 0 ||
297            (ifp->if_flags & IFF_UP) == 0) {
298                m_freem(m);
299                goto err;
300        }
301
302        /* Determine address family to correctly handle packet in BPF */
303        ip = mtod(m, struct ip *);
304        switch (ip->ip_v) {
305#ifdef INET
306        case IPVERSION:
307                af = AF_INET;
308                break;
309#endif
310#ifdef INET6
311        case (IPV6_VERSION >> 4):
312                af = AF_INET6;
313                break;
314#endif
315        default:
316                error = EAFNOSUPPORT;
317                m_freem(m);
318                goto err;
319        }
320
321        /*
322         * Loop prevention.
323         * XXX: for now just check presence of IPSEC_OUT_DONE mbuf tag.
324         *      We can read full chain and compare destination address,
325         *      proto and mode from xform_history with values from softc.
326         */
327        if (m_tag_find(m, PACKET_TAG_IPSEC_OUT_DONE, NULL) != NULL) {
328                m_freem(m);
329                goto err;
330        }
331
332        IPSEC_RLOCK(sc);
333        if (sc->family == 0) {
334                IPSEC_RUNLOCK(sc);
335                m_freem(m);
336                goto err;
337        }
338        sp = ipsec_getpolicy(sc, IPSEC_DIR_OUTBOUND, af);
339        key_addref(sp);
340        M_SETFIB(m, sc->fibnum);
341        IPSEC_RUNLOCK(sc);
342
343        BPF_MTAP2(ifp, &af, sizeof(af), m);
344        if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
345        if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
346
347        switch (af) {
348#ifdef INET
349        case AF_INET:
350                error = ipsec4_process_packet(m, sp, NULL);
351                break;
352#endif
353#ifdef INET6
354        case AF_INET6:
355                error = ipsec6_process_packet(m, sp, NULL);
356                break;
357#endif
358        default:
359                panic("%s: unknown address family\n", __func__);
360        }
361err:
362        if (error != 0)
363                if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
364        return (error);
365}
366
367static void
368ipsec_qflush(struct ifnet *ifp __unused)
369{
370
371}
372
373static int
374ipsec_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
375        struct route *ro)
376{
377
378        return (ifp->if_transmit(ifp, m));
379}
380
381int
382ipsec_if_input(struct mbuf *m, struct secasvar *sav, uint32_t af)
383{
384        IPSEC_SC_RLOCK_TRACKER;
385        struct secasindex *saidx;
386        struct ipsec_softc *sc;
387        struct ifnet *ifp;
388
389        if (sav->state != SADB_SASTATE_MATURE &&
390            sav->state != SADB_SASTATE_DYING) {
391                m_freem(m);
392                return (ENETDOWN);
393        }
394
395        if (sav->sah->saidx.mode != IPSEC_MODE_TUNNEL ||
396            sav->sah->saidx.proto != IPPROTO_ESP)
397                return (0);
398
399        IPSEC_SC_RLOCK();
400        /*
401         * We only acquire SC_RLOCK() while we are doing search in
402         * ipsec_sc_htbl. It is safe, because removing softc or changing
403         * of reqid/addresses requires removing from hash table.
404         */
405        LIST_FOREACH(sc, SCHASH_HASH(sav->sah->saidx.reqid), hash) {
406                saidx = ipsec_getsaidx(sc, IPSEC_DIR_INBOUND,
407                    sav->sah->saidx.src.sa.sa_family);
408                /* SA's reqid should match reqid in SP */
409                if (saidx == NULL ||
410                    sav->sah->saidx.reqid != saidx->reqid)
411                        continue;
412                /* SAH's addresses should match tunnel endpoints. */
413                if (key_sockaddrcmp(&sav->sah->saidx.dst.sa,
414                    &saidx->dst.sa, 0) != 0)
415                        continue;
416                if (key_sockaddrcmp(&sav->sah->saidx.src.sa,
417                    &saidx->src.sa, 0) == 0)
418                        break;
419        }
420        if (sc == NULL) {
421                IPSEC_SC_RUNLOCK();
422                /* Tunnel was not found. Nothing to do. */
423                return (0);
424        }
425        ifp = sc->ifp;
426        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
427            (ifp->if_flags & IFF_UP) == 0) {
428                IPSEC_SC_RUNLOCK();
429                m_freem(m);
430                return (ENETDOWN);
431        }
432        /*
433         * We found matching and working tunnel.
434         * Set its ifnet as receiving interface.
435         */
436        m->m_pkthdr.rcvif = ifp;
437        IPSEC_SC_RUNLOCK();
438
439        /* m_clrprotoflags(m); */
440        M_SETFIB(m, ifp->if_fib);
441        BPF_MTAP2(ifp, &af, sizeof(af), m);
442        if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
443        if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len);
444        if ((ifp->if_flags & IFF_MONITOR) != 0) {
445                m_freem(m);
446                return (ENETDOWN);
447        }
448        return (0);
449}
450
451/* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
452int
453ipsec_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
454{
455        IPSEC_RLOCK_TRACKER;
456        struct ifreq *ifr = (struct ifreq*)data;
457        struct sockaddr *dst, *src;
458        struct ipsec_softc *sc;
459        struct secasindex *saidx;
460#ifdef INET
461        struct sockaddr_in *sin = NULL;
462#endif
463#ifdef INET6
464        struct sockaddr_in6 *sin6 = NULL;
465#endif
466        uint32_t reqid;
467        int error;
468
469        switch (cmd) {
470        case SIOCSIFADDR:
471                ifp->if_flags |= IFF_UP;
472        case SIOCADDMULTI:
473        case SIOCDELMULTI:
474        case SIOCGIFMTU:
475        case SIOCSIFFLAGS:
476                return (0);
477        case SIOCSIFMTU:
478                if (ifr->ifr_mtu < IPSEC_MTU_MIN ||
479                    ifr->ifr_mtu > IPSEC_MTU_MAX)
480                        return (EINVAL);
481                else
482                        ifp->if_mtu = ifr->ifr_mtu;
483                return (0);
484        }
485        sx_xlock(&ipsec_ioctl_sx);
486        sc = ifp->if_softc;
487        /* Check that softc is still here */
488        if (sc == NULL) {
489                error = ENXIO;
490                goto bad;
491        }
492        error = 0;
493        switch (cmd) {
494        case SIOCSIFPHYADDR:
495#ifdef INET6
496        case SIOCSIFPHYADDR_IN6:
497#endif
498                error = EINVAL;
499                switch (cmd) {
500#ifdef INET
501                case SIOCSIFPHYADDR:
502                        src = (struct sockaddr *)
503                                &(((struct in_aliasreq *)data)->ifra_addr);
504                        dst = (struct sockaddr *)
505                                &(((struct in_aliasreq *)data)->ifra_dstaddr);
506                        break;
507#endif
508#ifdef INET6
509                case SIOCSIFPHYADDR_IN6:
510                        src = (struct sockaddr *)
511                                &(((struct in6_aliasreq *)data)->ifra_addr);
512                        dst = (struct sockaddr *)
513                                &(((struct in6_aliasreq *)data)->ifra_dstaddr);
514                        break;
515#endif
516                default:
517                        goto bad;
518                }
519                /* sa_family must be equal */
520                if (src->sa_family != dst->sa_family ||
521                    src->sa_len != dst->sa_len)
522                        goto bad;
523
524                /* validate sa_len */
525                switch (src->sa_family) {
526#ifdef INET
527                case AF_INET:
528                        if (src->sa_len != sizeof(struct sockaddr_in))
529                                goto bad;
530                        break;
531#endif
532#ifdef INET6
533                case AF_INET6:
534                        if (src->sa_len != sizeof(struct sockaddr_in6))
535                                goto bad;
536                        break;
537#endif
538                default:
539                        error = EAFNOSUPPORT;
540                        goto bad;
541                }
542                /* check sa_family looks sane for the cmd */
543                error = EAFNOSUPPORT;
544                switch (cmd) {
545#ifdef INET
546                case SIOCSIFPHYADDR:
547                        if (src->sa_family == AF_INET)
548                                break;
549                        goto bad;
550#endif
551#ifdef INET6
552                case SIOCSIFPHYADDR_IN6:
553                        if (src->sa_family == AF_INET6)
554                                break;
555                        goto bad;
556#endif
557                }
558                error = EADDRNOTAVAIL;
559                switch (src->sa_family) {
560#ifdef INET
561                case AF_INET:
562                        if (satosin(src)->sin_addr.s_addr == INADDR_ANY ||
563                            satosin(dst)->sin_addr.s_addr == INADDR_ANY)
564                                goto bad;
565                        break;
566#endif
567#ifdef INET6
568                case AF_INET6:
569                        if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(src)->sin6_addr)
570                            ||
571                            IN6_IS_ADDR_UNSPECIFIED(&satosin6(dst)->sin6_addr))
572                                goto bad;
573                        /*
574                         * Check validity of the scope zone ID of the
575                         * addresses, and convert it into the kernel
576                         * internal form if necessary.
577                         */
578                        error = sa6_embedscope(satosin6(src), 0);
579                        if (error != 0)
580                                goto bad;
581                        error = sa6_embedscope(satosin6(dst), 0);
582                        if (error != 0)
583                                goto bad;
584#endif
585                };
586                error = ipsec_set_addresses(ifp, src, dst);
587                break;
588        case SIOCDIFPHYADDR:
589                ipsec_delete_tunnel(ifp, 0);
590                break;
591        case SIOCGIFPSRCADDR:
592        case SIOCGIFPDSTADDR:
593#ifdef INET6
594        case SIOCGIFPSRCADDR_IN6:
595        case SIOCGIFPDSTADDR_IN6:
596#endif
597                IPSEC_RLOCK(sc);
598                if (sc->family == 0) {
599                        IPSEC_RUNLOCK(sc);
600                        error = EADDRNOTAVAIL;
601                        break;
602                }
603                saidx = ipsec_getsaidx(sc, IPSEC_DIR_OUTBOUND, sc->family);
604                switch (cmd) {
605#ifdef INET
606                case SIOCGIFPSRCADDR:
607                case SIOCGIFPDSTADDR:
608                        if (saidx->src.sa.sa_family != AF_INET) {
609                                error = EADDRNOTAVAIL;
610                                break;
611                        }
612                        sin = (struct sockaddr_in *)&ifr->ifr_addr;
613                        memset(sin, 0, sizeof(*sin));
614                        sin->sin_family = AF_INET;
615                        sin->sin_len = sizeof(*sin);
616                        break;
617#endif
618#ifdef INET6
619                case SIOCGIFPSRCADDR_IN6:
620                case SIOCGIFPDSTADDR_IN6:
621                        if (saidx->src.sa.sa_family != AF_INET6) {
622                                error = EADDRNOTAVAIL;
623                                break;
624                        }
625                        sin6 = (struct sockaddr_in6 *)
626                                &(((struct in6_ifreq *)data)->ifr_addr);
627                        memset(sin6, 0, sizeof(*sin6));
628                        sin6->sin6_family = AF_INET6;
629                        sin6->sin6_len = sizeof(*sin6);
630                        break;
631#endif
632                default:
633                        error = EAFNOSUPPORT;
634                }
635                if (error == 0) {
636                        switch (cmd) {
637#ifdef INET
638                        case SIOCGIFPSRCADDR:
639                                sin->sin_addr = saidx->src.sin.sin_addr;
640                                break;
641                        case SIOCGIFPDSTADDR:
642                                sin->sin_addr = saidx->dst.sin.sin_addr;
643                                break;
644#endif
645#ifdef INET6
646                        case SIOCGIFPSRCADDR_IN6:
647                                sin6->sin6_addr = saidx->src.sin6.sin6_addr;
648                                break;
649                        case SIOCGIFPDSTADDR_IN6:
650                                sin6->sin6_addr = saidx->dst.sin6.sin6_addr;
651                                break;
652#endif
653                        }
654                }
655                IPSEC_RUNLOCK(sc);
656                if (error != 0)
657                        break;
658                switch (cmd) {
659#ifdef INET
660                case SIOCGIFPSRCADDR:
661                case SIOCGIFPDSTADDR:
662                        error = prison_if(curthread->td_ucred,
663                            (struct sockaddr *)sin);
664                        if (error != 0)
665                                memset(sin, 0, sizeof(*sin));
666                        break;
667#endif
668#ifdef INET6
669                case SIOCGIFPSRCADDR_IN6:
670                case SIOCGIFPDSTADDR_IN6:
671                        error = prison_if(curthread->td_ucred,
672                            (struct sockaddr *)sin6);
673                        if (error == 0)
674                                error = sa6_recoverscope(sin6);
675                        if (error != 0)
676                                memset(sin6, 0, sizeof(*sin6));
677#endif
678                }
679                break;
680        case SIOCGTUNFIB:
681                ifr->ifr_fib = sc->fibnum;
682                break;
683        case SIOCSTUNFIB:
684                if ((error = priv_check(curthread, PRIV_NET_SETIFFIB)) != 0)
685                        break;
686                if (ifr->ifr_fib >= rt_numfibs)
687                        error = EINVAL;
688                else
689                        sc->fibnum = ifr->ifr_fib;
690                break;
691        case IPSECGREQID:
692                reqid = sc->reqid;
693                error = copyout(&reqid, ifr->ifr_data, sizeof(reqid));
694                break;
695        case IPSECSREQID:
696                if ((error = priv_check(curthread, PRIV_NET_SETIFCAP)) != 0)
697                        break;
698                error = copyin(ifr->ifr_data, &reqid, sizeof(reqid));
699                if (error != 0)
700                        break;
701                error = ipsec_set_reqid(ifp, reqid);
702                break;
703        default:
704                error = EINVAL;
705                break;
706        }
707bad:
708        sx_xunlock(&ipsec_ioctl_sx);
709        return (error);
710}
711
712/*
713 * Allocate new private security policies for tunneling interface.
714 * Each tunneling interface has following security policies for
715 * both AF:
716 *   0.0.0.0/0[any] 0.0.0.0/0[any] -P in \
717 *      ipsec esp/tunnel/RemoteIP-LocalIP/unique:reqid
718 *   0.0.0.0/0[any] 0.0.0.0/0[any] -P out \
719 *      ipsec esp/tunnel/LocalIP-RemoteIP/unique:reqid
720 */
721static int
722ipsec_newpolicies(struct ipsec_softc *sc, struct secpolicy *sp[IPSEC_SPCOUNT],
723    const struct sockaddr *src, const struct sockaddr *dst, uint32_t reqid)
724{
725        struct ipsecrequest *isr;
726        int i;
727
728        memset(sp, 0, sizeof(struct secpolicy *) * IPSEC_SPCOUNT);
729        for (i = 0; i < IPSEC_SPCOUNT; i++) {
730                if ((sp[i] = key_newsp()) == NULL)
731                        goto fail;
732                if ((isr = ipsec_newisr()) == NULL)
733                        goto fail;
734
735                sp[i]->policy = IPSEC_POLICY_IPSEC;
736                sp[i]->state = IPSEC_SPSTATE_DEAD;
737                sp[i]->req[sp[i]->tcount++] = isr;
738                sp[i]->created = time_second;
739                /* Use priority field to store if_index */
740                sp[i]->priority = sc->ifp->if_index;
741                isr->level = IPSEC_LEVEL_UNIQUE;
742                isr->saidx.proto = IPPROTO_ESP;
743                isr->saidx.mode = IPSEC_MODE_TUNNEL;
744                isr->saidx.reqid = reqid;
745                if (i % 2 == 0) {
746                        sp[i]->spidx.dir = IPSEC_DIR_INBOUND;
747                        bcopy(src, &isr->saidx.dst, src->sa_len);
748                        bcopy(dst, &isr->saidx.src, dst->sa_len);
749                } else {
750                        sp[i]->spidx.dir = IPSEC_DIR_OUTBOUND;
751                        bcopy(src, &isr->saidx.src, src->sa_len);
752                        bcopy(dst, &isr->saidx.dst, dst->sa_len);
753                }
754                sp[i]->spidx.ul_proto = IPSEC_ULPROTO_ANY;
755#ifdef INET
756                if (i < 2) {
757                        sp[i]->spidx.src.sa.sa_family =
758                            sp[i]->spidx.dst.sa.sa_family = AF_INET;
759                        sp[i]->spidx.src.sa.sa_len =
760                            sp[i]->spidx.dst.sa.sa_len =
761                            sizeof(struct sockaddr_in);
762                        continue;
763                }
764#endif
765#ifdef INET6
766                sp[i]->spidx.src.sa.sa_family =
767                    sp[i]->spidx.dst.sa.sa_family = AF_INET6;
768                sp[i]->spidx.src.sa.sa_len =
769                    sp[i]->spidx.dst.sa.sa_len = sizeof(struct sockaddr_in6);
770#endif
771        }
772        return (0);
773fail:
774        for (i = 0; i < IPSEC_SPCOUNT; i++)
775                key_freesp(&sp[i]);
776        return (ENOMEM);
777}
778
779static int
780ipsec_check_reqid(uint32_t reqid)
781{
782        struct ipsec_softc *sc;
783
784        IPSEC_SC_RLOCK_ASSERT();
785        LIST_FOREACH(sc, &V_ipsec_sc_list, chain) {
786                if (sc->reqid == reqid)
787                        return (EEXIST);
788        }
789        return (0);
790}
791
792/*
793 * We use key_newreqid() to automatically obtain unique reqid.
794 * Then we check that given id is unique, i.e. it is not used by
795 * another if_ipsec(4) interface. This macro limits the number of
796 * tries to get unique id.
797 */
798#define IPSEC_REQID_TRYCNT      64
799static int
800ipsec_init_reqid(struct ipsec_softc *sc)
801{
802        uint32_t reqid;
803        int trycount;
804
805        IPSEC_SC_RLOCK_ASSERT();
806
807        if (sc->reqid != 0) /* already initialized */
808                return (0);
809
810        trycount = IPSEC_REQID_TRYCNT;
811        while (--trycount > 0) {
812                reqid = key_newreqid();
813                if (ipsec_check_reqid(reqid) == 0)
814                        break;
815        }
816        if (trycount == 0)
817                return (EEXIST);
818        sc->reqid = reqid;
819        return (0);
820}
821
822/*
823 * Set or update reqid for given tunneling interface.
824 * When specified reqid is zero, generate new one.
825 * We are protected by ioctl_sx lock from concurrent id generation.
826 * Also softc would not disappear while we hold ioctl_sx lock.
827 */
828static int
829ipsec_set_reqid(struct ifnet *ifp, uint32_t reqid)
830{
831        IPSEC_SC_RLOCK_TRACKER;
832        struct ipsec_softc *sc;
833        struct secasindex *saidx;
834
835        sx_assert(&ipsec_ioctl_sx, SA_XLOCKED);
836
837        sc = ifp->if_softc;
838        if (sc->reqid == reqid && reqid != 0)
839                return (0);
840
841        IPSEC_SC_RLOCK();
842        if (reqid != 0) {
843                /* Check that specified reqid doesn't exist */
844                if (ipsec_check_reqid(reqid) != 0) {
845                        IPSEC_SC_RUNLOCK();
846                        return (EEXIST);
847                }
848                sc->reqid = reqid;
849        } else {
850                /* Generate new reqid */
851                if (ipsec_init_reqid(sc) != 0) {
852                        IPSEC_SC_RUNLOCK();
853                        return (EEXIST);
854                }
855        }
856        IPSEC_SC_RUNLOCK();
857
858        /* Tunnel isn't fully configured, just return. */
859        if (sc->family == 0)
860                return (0);
861
862        saidx = ipsec_getsaidx(sc, IPSEC_DIR_OUTBOUND, sc->family);
863        KASSERT(saidx != NULL,
864            ("saidx is NULL, but family is %d", sc->family));
865        return (ipsec_set_tunnel(sc, &saidx->src.sa, &saidx->dst.sa,
866            sc->reqid));
867}
868
869/*
870 * Set tunnel endpoints addresses.
871 */
872static int
873ipsec_set_addresses(struct ifnet *ifp, struct sockaddr *src,
874    struct sockaddr *dst)
875{
876        IPSEC_SC_RLOCK_TRACKER;
877        struct ipsec_softc *sc, *tsc;
878        struct secasindex *saidx;
879
880        sx_assert(&ipsec_ioctl_sx, SA_XLOCKED);
881
882        sc = ifp->if_softc;
883        if (sc->family != 0) {
884                saidx = ipsec_getsaidx(sc, IPSEC_DIR_OUTBOUND,
885                    src->sa_family);
886                if (saidx != NULL && saidx->reqid == sc->reqid &&
887                    key_sockaddrcmp(&saidx->src.sa, src, 0) == 0 &&
888                    key_sockaddrcmp(&saidx->dst.sa, dst, 0) == 0)
889                        return (0); /* Nothing has been changed. */
890
891        }
892        /*
893         * We cannot service IPsec tunnel when source address is
894         * not our own.
895         */
896#ifdef INET
897        if (src->sa_family == AF_INET &&
898            in_localip(satosin(src)->sin_addr) == 0)
899                return (EADDRNOTAVAIL);
900#endif
901#ifdef INET6
902        /*
903         * NOTE: IPv6 addresses are in kernel internal form with
904         * embedded scope zone id.
905         */
906        if (src->sa_family == AF_INET6 &&
907            in6_localip(&satosin6(src)->sin6_addr) == 0)
908                return (EADDRNOTAVAIL);
909#endif
910        /* Check that given addresses aren't already configured */
911        IPSEC_SC_RLOCK();
912        LIST_FOREACH(tsc, &V_ipsec_sc_list, chain) {
913                if (tsc == sc || tsc->family != src->sa_family)
914                        continue;
915                saidx = ipsec_getsaidx(tsc, IPSEC_DIR_OUTBOUND, tsc->family);
916                if (key_sockaddrcmp(&saidx->src.sa, src, 0) == 0 &&
917                    key_sockaddrcmp(&saidx->dst.sa, dst, 0) == 0) {
918                        /* We already have tunnel with such addresses */
919                        IPSEC_SC_RUNLOCK();
920                        return (EADDRNOTAVAIL);
921                }
922        }
923        /* If reqid is not set, generate new one. */
924        if (ipsec_init_reqid(sc) != 0) {
925                IPSEC_SC_RUNLOCK();
926                return (EEXIST);
927        }
928        IPSEC_SC_RUNLOCK();
929        return (ipsec_set_tunnel(sc, src, dst, sc->reqid));
930}
931
932static int
933ipsec_set_tunnel(struct ipsec_softc *sc, struct sockaddr *src,
934    struct sockaddr *dst, uint32_t reqid)
935{
936        struct secpolicy *sp[IPSEC_SPCOUNT];
937        struct secpolicy *oldsp[IPSEC_SPCOUNT];
938        int i, f;
939
940        sx_assert(&ipsec_ioctl_sx, SA_XLOCKED);
941
942        /* Allocate SP with new addresses. */
943        if (ipsec_newpolicies(sc, sp, src, dst, reqid) == 0) {
944                /* Add new policies to SPDB */
945                if (key_register_ifnet(sp, IPSEC_SPCOUNT) != 0) {
946                        for (i = 0; i < IPSEC_SPCOUNT; i++)
947                                key_freesp(&sp[i]);
948                        return (EAGAIN);
949                }
950                IPSEC_SC_WLOCK();
951                if ((f = sc->family) != 0)
952                        LIST_REMOVE(sc, hash);
953                IPSEC_WLOCK(sc);
954                for (i = 0; i < IPSEC_SPCOUNT; i++) {
955                        oldsp[i] = sc->sp[i];
956                        sc->sp[i] = sp[i];
957                }
958                sc->family = src->sa_family;
959                IPSEC_WUNLOCK(sc);
960                LIST_INSERT_HEAD(SCHASH_HASH(sc->reqid), sc, hash);
961                IPSEC_SC_WUNLOCK();
962        } else {
963                sc->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
964                return (ENOMEM);
965        }
966
967        sc->ifp->if_drv_flags |= IFF_DRV_RUNNING;
968        if (f != 0) {
969                key_unregister_ifnet(oldsp, IPSEC_SPCOUNT);
970                for (i = 0; i < IPSEC_SPCOUNT; i++)
971                        key_freesp(&oldsp[i]);
972        }
973        return (0);
974}
975
976static void
977ipsec_delete_tunnel(struct ifnet *ifp, int locked)
978{
979        struct ipsec_softc *sc = ifp->if_softc;
980        struct secpolicy *oldsp[IPSEC_SPCOUNT];
981        int i;
982
983        sx_assert(&ipsec_ioctl_sx, SA_XLOCKED);
984
985        ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
986        if (sc->family != 0) {
987                if (!locked)
988                        IPSEC_SC_WLOCK();
989                /* Remove from hash table */
990                LIST_REMOVE(sc, hash);
991                IPSEC_WLOCK(sc);
992                for (i = 0; i < IPSEC_SPCOUNT; i++) {
993                        oldsp[i] = sc->sp[i];
994                        sc->sp[i] = NULL;
995                }
996                sc->family = 0;
997                IPSEC_WUNLOCK(sc);
998                if (!locked)
999                        IPSEC_SC_WUNLOCK();
1000                key_unregister_ifnet(oldsp, IPSEC_SPCOUNT);
1001                for (i = 0; i < IPSEC_SPCOUNT; i++)
1002                        key_freesp(&oldsp[i]);
1003        }
1004}
Note: See TracBrowser for help on using the repository browser.