mirror of
https://github.com/torvalds/linux.git
synced 2026-11-20 13:03:48 +00:00
Merge tag 'ipsec-2026-11-02' of git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec
Steffen Klassert says:
====================
pull request (net): ipsec 2026-11-02
1) xfrm: retry inexact policy lookup after node reinsertion
Detect a concurrent change of the inexact policy tree while it is
searched and retry the lookup, so an insertion can't make it return
the wrong policy.
2) xfrm: interface: validate the IP header on xmit
Validate the IP header in xfrmi_xmit() like the IP receive path
does, so packets injected into an xfrm interface can't reach the
output path with a malformed header.
3) xfrm: zero-initialise km_event in the replay-notify path
Zero-initialise the replay event so the netlink header of a
kernel-originated replay notification no longer carries
uninitialised stack values.
4) xfrm: espintcp: reorder operations within espintcp_init_sk
Publish the ESP-in-TCP context before installing the socket
callbacks, so an early callback can't dereference a context that
isn't set up yet.
5) xfrm: state: reject mark with bits outside its mask on add
Reject a mark with bits outside its mask on state insert instead
of silently truncating it, so a lookup can't be given a mark that
never matches.
6) xfrm: state: reject mark with bits outside its mask on ALLOCSPI
Apply the same mark validation to ALLOCSPI, keeping the state and
policy insert paths consistent.
7) xfrm: policy: reject mark with bits outside its mask on add
Apply the same mark validation to policy insert, so a policy can't
be stored with a mark that never matches.
8) xfrm: state: exact mark/mask match for SPI-keyed control-plane SA lookups
Match mark and mask exactly in the SPI-keyed netlink SA lookups, so
a catch-all SA can no longer shadow a more specific one.
9) xfrm: fix use-after-free of migrated state in xfrm_do_migrate_state()
Hold the cloned state for the whole migration, so a concurrent
delete can't free it while it is still in use.
10) xfrm: fix hw offload state leak on xfrm_do_migrate_state() error path
Remove the hardware offload of the cloned state on the migration
error path, so the offloaded SA entry isn't leaked.
11) xfrm: include mark in MIGRATE_STATE SA collision check
Include the mark in the SA collision check, so a migration that
only changes the mark can't install a duplicate SA tuple.
12) xfrm: pass extack through to xfrm_init_replay() from xfrm_init_state()
Pass the extack to xfrm_init_replay(), so replay window errors can
be reported to userspace.
13) docs: xfrm: include mark in XFRM_MSG_MIGRATE_STATE EEXIST tuple
Document the mark as part of the EEXIST tuple of the SA migration
request.
14) xfrm4: use a full socket for local errors
Resolve the socket owner with skb_to_full_sk() in the IPv4 local
error path, so a TCP request socket isn't used as a full socket.
Please pull or let me know if there are problems.
ipsec-2026-11-02
* tag 'ipsec-2026-11-02' of git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec:
xfrm4: use a full socket for local errors
docs: xfrm: include mark in XFRM_MSG_MIGRATE_STATE EEXIST tuple
xfrm: pass extack through to xfrm_init_replay() from xfrm_init_state()
xfrm: include mark in MIGRATE_STATE SA collision check
xfrm: fix hw offload state leak on xfrm_do_migrate_state() error path
xfrm: fix use-after-free of migrated state in xfrm_do_migrate_state()
xfrm: state: exact mark/mask match for SPI-keyed control-plane SA lookups
xfrm: policy: reject mark with bits outside its mask on add
xfrm: state: reject mark with bits outside its mask on ALLOCSPI
xfrm: state: reject mark with bits outside its mask on add
xfrm: espintcp: reorder operations within espintcp_init_sk
xfrm: zero-initialise km_event in the replay-notify path
xfrm: interface: validate the IP header on xmit
xfrm: retry inexact policy lookup after node reinsertion
====================
Link: https://patch.msgid.link/[email protected]
Signed-off-by: Paolo Abeni <[email protected]>
This commit is contained in:
@@ -27,15 +27,20 @@ SA Identification
|
||||
=================
|
||||
|
||||
The struct is defined in ``include/uapi/linux/xfrm.h``. The SA is looked
|
||||
up using ``xfrm_state_lookup()`` with ``id.spi``,
|
||||
``id.daddr``, ``id.proto``, ``id.family``, and
|
||||
``old_mark.v & old_mark.m`` as the mark key::
|
||||
up using ``xfrm_state_lookup_exact()`` with ``id.spi``, ``id.daddr``,
|
||||
``id.proto``, ``id.family``, and an exact match against ``old_mark.v``
|
||||
and ``old_mark.m``. Unlike the data path, which uses a masked
|
||||
comparison, this requires the SA's mark and mask to equal ``old_mark``
|
||||
exactly, so a broad-mask SA is never matched when a more specific one
|
||||
was intended. If no such SA exists, ``-ESRCH`` is returned.
|
||||
|
||||
The layout is::
|
||||
|
||||
struct xfrm_user_migrate_state {
|
||||
struct xfrm_usersa_id id; /* spi, daddr, proto, family */
|
||||
xfrm_address_t new_daddr;
|
||||
xfrm_address_t new_saddr;
|
||||
struct xfrm_mark old_mark; /* SA lookup: key = v & m */
|
||||
struct xfrm_mark old_mark; /* SA lookup key (exact v/m match) */
|
||||
struct xfrm_selector new_sel; /* new selector (see Flags) */
|
||||
__u32 new_reqid;
|
||||
__u32 flags; /* XFRM_MIGRATE_STATE_* */
|
||||
@@ -72,8 +77,8 @@ inherits the value from the existing SA (omit-to-inherit).
|
||||
- Description
|
||||
* - ``XFRMA_MARK``
|
||||
- Mark on the migrated SA (``struct xfrm_mark``). Absent inherits
|
||||
``old_mark``. To use no mark on the new SA, send ``XFRMA_MARK``
|
||||
with ``{0, 0}``.
|
||||
the mark of the existing SA. To use no mark on the new SA, send
|
||||
``XFRMA_MARK`` with ``{0, 0}``.
|
||||
* - ``XFRMA_ENCAP``
|
||||
- UDP encapsulation template; only ``UDP_ENCAP_ESPINUDP`` is supported.
|
||||
Set ``encap_type=0`` to remove encap.
|
||||
@@ -259,8 +264,12 @@ Attributes in the notification
|
||||
Error Handling
|
||||
==============
|
||||
|
||||
If the target SA tuple (new daddr, SPI, proto, new family) is already
|
||||
occupied, the operation returns ``-EEXIST`` before the migration begins.
|
||||
If the target SA tuple (new daddr, SPI, proto, new family, mark) is
|
||||
already occupied, the operation returns ``-EEXIST`` before the migration
|
||||
begins. "Occupied" includes wildcard shadowing: an existing SA with a
|
||||
broader mask (e.g. mark 0/0) claims every mark value, so it blocks
|
||||
migrating to any more specific mark at the same tuple, not just an
|
||||
exact mark/mask duplicate.
|
||||
The old SA remains intact and the operation is safe to retry after
|
||||
resolving the conflict.
|
||||
|
||||
|
||||
@@ -34,7 +34,8 @@ static inline struct espintcp_ctx *espintcp_getctx(const struct sock *sk)
|
||||
{
|
||||
const struct inet_connection_sock *icsk = inet_csk(sk);
|
||||
|
||||
/* RCU is only needed for diag */
|
||||
return (__force void *)icsk->icsk_ulp_data;
|
||||
/* pairs with smp_wmb() in espintcp_init_sk() */
|
||||
smp_rmb();
|
||||
return (__force void *)READ_ONCE(icsk->icsk_ulp_data);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1765,6 +1765,13 @@ struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
|
||||
const xfrm_address_t *saddr,
|
||||
u8 proto,
|
||||
unsigned short family);
|
||||
struct xfrm_state *xfrm_state_lookup_exact(struct net *net, const struct xfrm_mark *mark,
|
||||
const xfrm_address_t *daddr, __be32 spi,
|
||||
u8 proto, unsigned short family);
|
||||
bool xfrm_state_mark_collides(struct net *net, u32 mark,
|
||||
const xfrm_address_t *daddr, __be32 spi,
|
||||
u8 proto, unsigned short family,
|
||||
const struct xfrm_state *self);
|
||||
#ifdef CONFIG_XFRM_SUB_POLICY
|
||||
void xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
|
||||
unsigned short family);
|
||||
|
||||
@@ -38,9 +38,12 @@ int xfrm4_output(struct net *net, struct sock *sk, struct sk_buff *skb)
|
||||
|
||||
void xfrm4_local_error(struct sk_buff *skb, u32 mtu)
|
||||
{
|
||||
struct sock *sk = skb_to_full_sk(skb);
|
||||
struct iphdr *hdr;
|
||||
|
||||
if (!sk)
|
||||
return;
|
||||
|
||||
hdr = skb->encapsulation ? inner_ip_hdr(skb) : ip_hdr(skb);
|
||||
ip_local_error(skb->sk, EMSGSIZE, hdr->daddr,
|
||||
inet_sk(skb->sk)->inet_dport, mtu);
|
||||
ip_local_error(sk, EMSGSIZE, hdr->daddr, inet_sk(sk)->inet_dport, mtu);
|
||||
}
|
||||
|
||||
+26
-17
@@ -434,7 +434,9 @@ static void espintcp_destruct(struct sock *sk)
|
||||
|
||||
bool tcp_is_ulp_esp(struct sock *sk)
|
||||
{
|
||||
return sk->sk_prot == &espintcp_prot || sk->sk_prot == &espintcp6_prot;
|
||||
const struct proto *prot = READ_ONCE(sk->sk_prot);
|
||||
|
||||
return prot == &espintcp_prot || prot == &espintcp6_prot;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(tcp_is_ulp_esp);
|
||||
|
||||
@@ -466,34 +468,41 @@ static int espintcp_init_sk(struct sock *sk)
|
||||
|
||||
__sk_dst_reset(sk);
|
||||
|
||||
strp_check_rcv(&ctx->strp);
|
||||
skb_queue_head_init(&ctx->ike_queue);
|
||||
skb_queue_head_init(&ctx->out_queue);
|
||||
INIT_WORK(&ctx->work, espintcp_tx_work);
|
||||
|
||||
ctx->saved_data_ready = sk->sk_data_ready;
|
||||
ctx->saved_write_space = sk->sk_write_space;
|
||||
ctx->saved_destruct = sk->sk_destruct;
|
||||
|
||||
/* avoid using task_frag */
|
||||
sk->sk_allocation = GFP_ATOMIC;
|
||||
sk->sk_use_task_frag = false;
|
||||
|
||||
rcu_assign_pointer(icsk->icsk_ulp_data, ctx);
|
||||
|
||||
/* pairs with smp_rmb() in espintcp_getctx() */
|
||||
smp_wmb();
|
||||
|
||||
WRITE_ONCE(sk->sk_data_ready, espintcp_data_ready);
|
||||
WRITE_ONCE(sk->sk_write_space, espintcp_write_space);
|
||||
sk->sk_destruct = espintcp_destruct;
|
||||
|
||||
if (sk->sk_family == AF_INET) {
|
||||
sk->sk_prot = &espintcp_prot;
|
||||
sk->sk_socket->ops = &espintcp_ops;
|
||||
WRITE_ONCE(sk->sk_prot, &espintcp_prot);
|
||||
WRITE_ONCE(sk->sk_socket->ops, &espintcp_ops);
|
||||
} else {
|
||||
mutex_lock(&tcpv6_prot_mutex);
|
||||
if (!espintcp6_prot.recvmsg)
|
||||
build_protos(&espintcp6_prot, &espintcp6_ops, sk->sk_prot, sk->sk_socket->ops);
|
||||
mutex_unlock(&tcpv6_prot_mutex);
|
||||
|
||||
sk->sk_prot = &espintcp6_prot;
|
||||
sk->sk_socket->ops = &espintcp6_ops;
|
||||
WRITE_ONCE(sk->sk_prot, &espintcp6_prot);
|
||||
WRITE_ONCE(sk->sk_socket->ops, &espintcp6_ops);
|
||||
}
|
||||
ctx->saved_data_ready = sk->sk_data_ready;
|
||||
ctx->saved_write_space = sk->sk_write_space;
|
||||
ctx->saved_destruct = sk->sk_destruct;
|
||||
sk->sk_data_ready = espintcp_data_ready;
|
||||
sk->sk_write_space = espintcp_write_space;
|
||||
sk->sk_destruct = espintcp_destruct;
|
||||
rcu_assign_pointer(icsk->icsk_ulp_data, ctx);
|
||||
INIT_WORK(&ctx->work, espintcp_tx_work);
|
||||
|
||||
/* avoid using task_frag */
|
||||
sk->sk_allocation = GFP_ATOMIC;
|
||||
sk->sk_use_task_frag = false;
|
||||
strp_check_rcv(&ctx->strp);
|
||||
|
||||
return 0;
|
||||
|
||||
|
||||
@@ -531,8 +531,13 @@ static netdev_tx_t xfrmi_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
|
||||
memset(&fl, 0, sizeof(fl));
|
||||
|
||||
if (!pskb_inet_may_pull(skb))
|
||||
goto tx_err;
|
||||
|
||||
switch (skb->protocol) {
|
||||
case htons(ETH_P_IPV6):
|
||||
if (ipv6_hdr(skb)->version != 6)
|
||||
goto tx_err;
|
||||
memset(IP6CB(skb), 0, sizeof(*IP6CB(skb)));
|
||||
xfrm_decode_session(dev_net(dev), skb, &fl, AF_INET6);
|
||||
if (!dst) {
|
||||
@@ -548,6 +553,9 @@ static netdev_tx_t xfrmi_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
}
|
||||
break;
|
||||
case htons(ETH_P_IP):
|
||||
if (ip_hdr(skb)->version != 4 || ip_hdr(skb)->ihl < 5 ||
|
||||
!pskb_network_may_pull(skb, ip_hdr(skb)->ihl * 4))
|
||||
goto tx_err;
|
||||
memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
|
||||
xfrm_decode_session(dev_net(dev), skb, &fl, AF_INET);
|
||||
if (!dst) {
|
||||
|
||||
@@ -1575,9 +1575,6 @@ int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl)
|
||||
struct xfrm_policy *delpol;
|
||||
struct hlist_head *chain;
|
||||
|
||||
/* Sanitize mark before store */
|
||||
policy->mark.v &= policy->mark.m;
|
||||
|
||||
spin_lock_bh(&net->xfrm.xfrm_policy_lock);
|
||||
chain = policy_hash_bysel(net, &policy->selector, policy->family, dir);
|
||||
if (chain)
|
||||
@@ -2157,6 +2154,7 @@ static struct xfrm_policy *xfrm_policy_lookup_bytype(struct net *net, u8 type,
|
||||
struct xfrm_pol_inexact_bin *bin;
|
||||
struct xfrm_policy *pol, *ret;
|
||||
struct hlist_head *chain;
|
||||
unsigned int inexact_sequence;
|
||||
unsigned int sequence;
|
||||
int err;
|
||||
|
||||
@@ -2191,12 +2189,18 @@ static struct xfrm_policy *xfrm_policy_lookup_bytype(struct net *net, u8 type,
|
||||
goto skip_inexact;
|
||||
|
||||
bin = xfrm_policy_inexact_lookup_rcu(net, type, family, dir, if_id);
|
||||
if (!bin || !xfrm_policy_find_inexact_candidates(&cand, bin, saddr,
|
||||
daddr))
|
||||
if (!bin)
|
||||
goto skip_inexact;
|
||||
|
||||
inexact_sequence = read_seqcount_begin(&bin->count);
|
||||
if (!xfrm_policy_find_inexact_candidates(&cand, bin, saddr, daddr))
|
||||
goto skip_inexact;
|
||||
|
||||
pol = xfrm_policy_eval_candidates(&cand, ret, fl, type,
|
||||
family, if_id);
|
||||
if (read_seqcount_retry(&bin->count, inexact_sequence))
|
||||
goto retry;
|
||||
|
||||
if (pol) {
|
||||
ret = pol;
|
||||
if (IS_ERR(pol))
|
||||
|
||||
@@ -40,7 +40,7 @@ static void xfrm_replay_notify_esn(struct xfrm_state *x, int event);
|
||||
|
||||
void xfrm_replay_notify(struct xfrm_state *x, int event)
|
||||
{
|
||||
struct km_event c;
|
||||
struct km_event c = {};
|
||||
/* we send notify messages in case
|
||||
* 1. we updated on of the sequence numbers, and the seqno difference
|
||||
* is at least x->replay_maxdiff, in this case we also update the
|
||||
@@ -304,7 +304,7 @@ static void xfrm_replay_advance_bmp(struct xfrm_state *x, __be32 net_seq)
|
||||
|
||||
static void xfrm_replay_notify_bmp(struct xfrm_state *x, int event)
|
||||
{
|
||||
struct km_event c;
|
||||
struct km_event c = {};
|
||||
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
|
||||
struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
|
||||
|
||||
@@ -356,7 +356,7 @@ static void xfrm_replay_notify_bmp(struct xfrm_state *x, int event)
|
||||
static void xfrm_replay_notify_esn(struct xfrm_state *x, int event)
|
||||
{
|
||||
u32 seq_diff, oseq_diff;
|
||||
struct km_event c;
|
||||
struct km_event c = {};
|
||||
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
|
||||
struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
|
||||
|
||||
|
||||
+84
-17
@@ -1177,11 +1177,19 @@ static struct xfrm_state *__xfrm_state_lookup_all(const struct xfrm_hash_state_p
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct xfrm_state *__xfrm_state_lookup(const struct xfrm_hash_state_ptrs *state_ptrs,
|
||||
u32 mark,
|
||||
const xfrm_address_t *daddr,
|
||||
__be32 spi, u8 proto,
|
||||
unsigned short family)
|
||||
static bool xfrm_state_mark_matches(const struct xfrm_state *x, u32 mark, u32 mask, bool exact)
|
||||
{
|
||||
if (exact)
|
||||
return x->mark.v == mark && x->mark.m == mask;
|
||||
return (mark & x->mark.m) == x->mark.v;
|
||||
}
|
||||
|
||||
static struct xfrm_state *
|
||||
__xfrm_state_lookup(const struct xfrm_hash_state_ptrs *state_ptrs,
|
||||
u32 mark, u32 mask, bool exact,
|
||||
const xfrm_address_t *daddr,
|
||||
__be32 spi, u8 proto,
|
||||
unsigned short family)
|
||||
{
|
||||
unsigned int h = __xfrm_spi_hash(daddr, spi, proto, family, state_ptrs->hmask);
|
||||
struct xfrm_state *x;
|
||||
@@ -1193,7 +1201,7 @@ static struct xfrm_state *__xfrm_state_lookup(const struct xfrm_hash_state_ptrs
|
||||
!xfrm_addr_equal(&x->id.daddr, daddr, family))
|
||||
continue;
|
||||
|
||||
if ((mark & x->mark.m) != x->mark.v)
|
||||
if (!xfrm_state_mark_matches(x, mark, mask, exact))
|
||||
continue;
|
||||
if (!xfrm_state_hold_rcu(x))
|
||||
continue;
|
||||
@@ -1203,6 +1211,17 @@ static struct xfrm_state *__xfrm_state_lookup(const struct xfrm_hash_state_ptrs
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct xfrm_state *
|
||||
__xfrm_state_lookup_exact(const struct xfrm_hash_state_ptrs *state_ptrs,
|
||||
const struct xfrm_mark *mark,
|
||||
const xfrm_address_t *daddr,
|
||||
__be32 spi, u8 proto,
|
||||
unsigned short family)
|
||||
{
|
||||
return __xfrm_state_lookup(state_ptrs, mark->v, mark->m, true,
|
||||
daddr, spi, proto, family);
|
||||
}
|
||||
|
||||
struct xfrm_state *xfrm_input_state_lookup(struct net *net, u32 mark,
|
||||
const xfrm_address_t *daddr,
|
||||
__be32 spi, u8 proto,
|
||||
@@ -1233,7 +1252,7 @@ struct xfrm_state *xfrm_input_state_lookup(struct net *net, u32 mark,
|
||||
|
||||
xfrm_hash_ptrs_get(net, &state_ptrs);
|
||||
|
||||
x = __xfrm_state_lookup(&state_ptrs, mark, daddr, spi, proto, family);
|
||||
x = __xfrm_state_lookup(&state_ptrs, mark, 0, false, daddr, spi, proto, family);
|
||||
if (x) {
|
||||
spin_lock(&net->xfrm.xfrm_state_lock);
|
||||
if (x->km.state != XFRM_STATE_VALID) {
|
||||
@@ -1283,7 +1302,7 @@ static struct xfrm_state *__xfrm_state_lookup_byaddr(const struct xfrm_hash_stat
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline struct xfrm_state *
|
||||
static struct xfrm_state *
|
||||
__xfrm_state_locate(struct xfrm_state *x, int use_spi, int family)
|
||||
{
|
||||
struct xfrm_hash_state_ptrs state_ptrs;
|
||||
@@ -1293,7 +1312,7 @@ __xfrm_state_locate(struct xfrm_state *x, int use_spi, int family)
|
||||
xfrm_hash_ptrs_get(net, &state_ptrs);
|
||||
|
||||
if (use_spi)
|
||||
return __xfrm_state_lookup(&state_ptrs, mark, &x->id.daddr,
|
||||
return __xfrm_state_lookup(&state_ptrs, mark, 0, false, &x->id.daddr,
|
||||
x->id.spi, x->id.proto, family);
|
||||
else
|
||||
return __xfrm_state_lookup_byaddr(&state_ptrs, mark,
|
||||
@@ -1732,9 +1751,6 @@ static void __xfrm_state_insert(struct xfrm_state *x)
|
||||
|
||||
list_add(&x->km.all, &net->xfrm.state_all);
|
||||
|
||||
/* Sanitize mark before store */
|
||||
x->mark.v &= x->mark.m;
|
||||
|
||||
h = xfrm_dst_hash(net, &x->id.daddr, &x->props.saddr,
|
||||
x->props.reqid, x->props.family);
|
||||
XFRM_STATE_INSERT(bydst, &x->bydst,
|
||||
@@ -2186,10 +2202,12 @@ int xfrm_state_migrate_install(const struct xfrm_state *x,
|
||||
struct netlink_ext_ack *extack)
|
||||
{
|
||||
if (m->new_family == m->old_family &&
|
||||
xfrm_addr_equal(&x->id.daddr, &m->new_daddr, m->new_family)) {
|
||||
xfrm_addr_equal(&x->id.daddr, &m->new_daddr, m->new_family) &&
|
||||
xc->mark.v == x->mark.v && xc->mark.m == x->mark.m) {
|
||||
/*
|
||||
* Care is needed when the destination address of the state is
|
||||
* to be updated as it is a part of triplet.
|
||||
* Care is needed when the destination address or mark of the
|
||||
* state is to be updated, as they are part of the lookup
|
||||
* triplet.
|
||||
*/
|
||||
xfrm_state_insert(xc);
|
||||
} else {
|
||||
@@ -2383,7 +2401,7 @@ xfrm_state_lookup(struct net *net, u32 mark, const xfrm_address_t *daddr, __be32
|
||||
rcu_read_lock();
|
||||
xfrm_hash_ptrs_get(net, &state_ptrs);
|
||||
|
||||
x = __xfrm_state_lookup(&state_ptrs, mark, daddr, spi, proto, family);
|
||||
x = __xfrm_state_lookup(&state_ptrs, mark, 0, false, daddr, spi, proto, family);
|
||||
rcu_read_unlock();
|
||||
return x;
|
||||
}
|
||||
@@ -2407,6 +2425,55 @@ xfrm_state_lookup_byaddr(struct net *net, u32 mark,
|
||||
}
|
||||
EXPORT_SYMBOL(xfrm_state_lookup_byaddr);
|
||||
|
||||
struct xfrm_state *
|
||||
xfrm_state_lookup_exact(struct net *net, const struct xfrm_mark *mark,
|
||||
const xfrm_address_t *daddr, __be32 spi,
|
||||
u8 proto, unsigned short family)
|
||||
{
|
||||
struct xfrm_hash_state_ptrs state_ptrs;
|
||||
struct xfrm_state *x;
|
||||
|
||||
rcu_read_lock();
|
||||
xfrm_hash_ptrs_get(net, &state_ptrs);
|
||||
|
||||
x = __xfrm_state_lookup_exact(&state_ptrs, mark, daddr, spi, proto, family);
|
||||
rcu_read_unlock();
|
||||
return x;
|
||||
}
|
||||
EXPORT_SYMBOL(xfrm_state_lookup_exact);
|
||||
|
||||
/* True if some OTHER state at this tuple would wildcard-match "mark".
|
||||
* Used by MIGRATE_STATE, which must exclude the state being migrated.
|
||||
*/
|
||||
bool xfrm_state_mark_collides(struct net *net, u32 mark,
|
||||
const xfrm_address_t *daddr, __be32 spi,
|
||||
u8 proto, unsigned short family,
|
||||
const struct xfrm_state *self)
|
||||
{
|
||||
struct xfrm_hash_state_ptrs state_ptrs;
|
||||
unsigned int h;
|
||||
struct xfrm_state *x;
|
||||
bool collides = false;
|
||||
|
||||
rcu_read_lock();
|
||||
xfrm_hash_ptrs_get(net, &state_ptrs);
|
||||
h = __xfrm_spi_hash(daddr, spi, proto, family, state_ptrs.hmask);
|
||||
|
||||
hlist_for_each_entry_rcu(x, state_ptrs.byspi + h, byspi) {
|
||||
if (x != self && x->props.family == family &&
|
||||
x->id.spi == spi && x->id.proto == proto &&
|
||||
xfrm_addr_equal(&x->id.daddr, daddr, family) &&
|
||||
(mark & x->mark.m) == x->mark.v) {
|
||||
collides = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
||||
return collides;
|
||||
}
|
||||
EXPORT_SYMBOL(xfrm_state_mark_collides);
|
||||
|
||||
struct xfrm_state *
|
||||
xfrm_find_acq(struct net *net, const struct xfrm_mark *mark, u8 mode, u32 reqid,
|
||||
u32 if_id, u32 pcpu_num, u8 proto, const xfrm_address_t *daddr,
|
||||
@@ -3317,7 +3384,7 @@ int xfrm_init_state(struct xfrm_state *x, struct netlink_ext_ack *extack)
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = xfrm_init_replay(x, NULL);
|
||||
err = xfrm_init_replay(x, extack);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
|
||||
+57
-22
@@ -314,6 +314,22 @@ static int verify_selector_prefixlen(u16 family,
|
||||
}
|
||||
}
|
||||
|
||||
static int verify_mark(struct nlattr **attrs, struct netlink_ext_ack *extack)
|
||||
{
|
||||
const struct xfrm_mark *m;
|
||||
|
||||
if (!attrs[XFRMA_MARK])
|
||||
return 0;
|
||||
|
||||
m = nla_data(attrs[XFRMA_MARK]);
|
||||
if ((m->v & m->m) != m->v) {
|
||||
NL_SET_ERR_MSG(extack, "Invalid mark value/mask combination");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int verify_newsa_info(struct xfrm_usersa_info *p,
|
||||
struct nlattr **attrs,
|
||||
struct netlink_ext_ack *extack)
|
||||
@@ -333,6 +349,10 @@ static int verify_newsa_info(struct xfrm_usersa_info *p,
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
err = verify_mark(attrs, extack);
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
err = -EINVAL;
|
||||
switch (p->id.proto) {
|
||||
case IPPROTO_AH:
|
||||
@@ -1089,11 +1109,12 @@ static struct xfrm_state *xfrm_user_state_lookup(struct net *net,
|
||||
struct xfrm_state *x = NULL;
|
||||
struct xfrm_mark m;
|
||||
int err;
|
||||
u32 mark = xfrm_mark_get(attrs, &m);
|
||||
|
||||
xfrm_mark_get(attrs, &m);
|
||||
|
||||
if (xfrm_id_proto_match(p->proto, IPSEC_PROTO_ANY)) {
|
||||
err = -ESRCH;
|
||||
x = xfrm_state_lookup(net, mark, &p->daddr, p->spi, p->proto, p->family);
|
||||
x = xfrm_state_lookup_exact(net, &m, &p->daddr, p->spi, p->proto, p->family);
|
||||
} else {
|
||||
xfrm_address_t *saddr = NULL;
|
||||
|
||||
@@ -1104,7 +1125,7 @@ static struct xfrm_state *xfrm_user_state_lookup(struct net *net,
|
||||
}
|
||||
|
||||
err = -ESRCH;
|
||||
x = xfrm_state_lookup_byaddr(net, mark,
|
||||
x = xfrm_state_lookup_byaddr(net, m.v & m.m,
|
||||
&p->daddr, saddr,
|
||||
p->proto, p->family);
|
||||
}
|
||||
@@ -1896,6 +1917,9 @@ static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
|
||||
x = NULL;
|
||||
|
||||
err = verify_mark(attrs, extack);
|
||||
if (err)
|
||||
goto out_noput;
|
||||
mark = xfrm_mark_get(attrs, &m);
|
||||
|
||||
if (attrs[XFRMA_IF_ID])
|
||||
@@ -2284,6 +2308,9 @@ static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
if (err)
|
||||
return err;
|
||||
err = verify_sec_ctx_len(attrs, extack);
|
||||
if (err)
|
||||
return err;
|
||||
err = verify_mark(attrs, extack);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
@@ -2795,14 +2822,13 @@ static int xfrm_get_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
struct sk_buff *r_skb;
|
||||
int err;
|
||||
struct km_event c;
|
||||
u32 mark;
|
||||
struct xfrm_mark m;
|
||||
struct xfrm_aevent_id *p = nlmsg_data(nlh);
|
||||
struct xfrm_usersa_id *id = &p->sa_id;
|
||||
|
||||
mark = xfrm_mark_get(attrs, &m);
|
||||
xfrm_mark_get(attrs, &m);
|
||||
|
||||
x = xfrm_state_lookup(net, mark, &id->daddr, id->spi, id->proto, id->family);
|
||||
x = xfrm_state_lookup_exact(net, &m, &id->daddr, id->spi, id->proto, id->family);
|
||||
if (x == NULL)
|
||||
return -ESRCH;
|
||||
|
||||
@@ -2843,7 +2869,6 @@ static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
struct xfrm_state *x;
|
||||
struct km_event c;
|
||||
int err = -EINVAL;
|
||||
u32 mark = 0;
|
||||
struct xfrm_mark m;
|
||||
struct xfrm_aevent_id *p = nlmsg_data(nlh);
|
||||
struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
|
||||
@@ -2863,9 +2888,10 @@ static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
return err;
|
||||
}
|
||||
|
||||
mark = xfrm_mark_get(attrs, &m);
|
||||
xfrm_mark_get(attrs, &m);
|
||||
|
||||
x = xfrm_state_lookup(net, mark, &p->sa_id.daddr, p->sa_id.spi, p->sa_id.proto, p->sa_id.family);
|
||||
x = xfrm_state_lookup_exact(net, &m, &p->sa_id.daddr, p->sa_id.spi,
|
||||
p->sa_id.proto, p->sa_id.family);
|
||||
if (x == NULL)
|
||||
return -ESRCH;
|
||||
|
||||
@@ -2999,9 +3025,10 @@ static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
struct xfrm_user_expire *ue = nlmsg_data(nlh);
|
||||
struct xfrm_usersa_info *p = &ue->state;
|
||||
struct xfrm_mark m;
|
||||
u32 mark = xfrm_mark_get(attrs, &m);
|
||||
|
||||
x = xfrm_state_lookup(net, mark, &p->id.daddr, p->id.spi, p->id.proto, p->family);
|
||||
xfrm_mark_get(attrs, &m);
|
||||
|
||||
x = xfrm_state_lookup_exact(net, &m, &p->id.daddr, p->id.spi, p->id.proto, p->family);
|
||||
|
||||
err = -ENOENT;
|
||||
if (x == NULL)
|
||||
@@ -3370,11 +3397,15 @@ static int xfrm_do_migrate_state(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
return err;
|
||||
}
|
||||
|
||||
err = verify_mark(attrs, extack);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
copy_from_user_migrate_state(&m, um);
|
||||
|
||||
x = xfrm_state_lookup(net, m.old_mark.v & m.old_mark.m,
|
||||
&um->id.daddr, um->id.spi,
|
||||
um->id.proto, um->id.family);
|
||||
x = xfrm_state_lookup_exact(net, &m.old_mark,
|
||||
&um->id.daddr, um->id.spi,
|
||||
um->id.proto, um->id.family);
|
||||
if (!x) {
|
||||
NL_SET_ERR_MSG(extack, "Can not find state");
|
||||
return -ESRCH;
|
||||
@@ -3445,15 +3476,14 @@ static int xfrm_do_migrate_state(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
x->nat_keepalive_interval);
|
||||
|
||||
if (m.new_family != um->id.family ||
|
||||
!xfrm_addr_equal(&m.new_daddr, &um->id.daddr, um->id.family)) {
|
||||
u32 new_mark_key = m.new_mark ? m.new_mark->v & m.new_mark->m :
|
||||
m.old_mark.v & m.old_mark.m;
|
||||
struct xfrm_state *x_new;
|
||||
!xfrm_addr_equal(&m.new_daddr, &um->id.daddr, um->id.family) ||
|
||||
(m.new_mark && (m.new_mark->v != x->mark.v ||
|
||||
m.new_mark->m != x->mark.m))) {
|
||||
const struct xfrm_mark *new_mark = m.new_mark ? m.new_mark : &x->mark;
|
||||
|
||||
x_new = xfrm_state_lookup(net, new_mark_key, &m.new_daddr,
|
||||
um->id.spi, um->id.proto, m.new_family);
|
||||
if (x_new) {
|
||||
xfrm_state_put(x_new);
|
||||
if (xfrm_state_mark_collides(net, new_mark->v & new_mark->m,
|
||||
&m.new_daddr, um->id.spi,
|
||||
um->id.proto, m.new_family, x)) {
|
||||
NL_SET_ERR_MSG(extack, "New SA tuple already occupied");
|
||||
err = -EEXIST;
|
||||
goto out;
|
||||
@@ -3478,6 +3508,7 @@ static int xfrm_do_migrate_state(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
__xfrm_state_delete(x);
|
||||
spin_unlock_bh(&x->lock);
|
||||
|
||||
xfrm_state_hold(xc);
|
||||
err = xfrm_state_migrate_install(x, xc, &m, extack);
|
||||
if (err < 0) {
|
||||
/*
|
||||
@@ -3485,6 +3516,7 @@ static int xfrm_do_migrate_state(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
* free under xfrm_cfg_mutex. Both SAs are gone if it does;
|
||||
* restoring x would risk SN/IV reuse.
|
||||
*/
|
||||
xfrm_state_put(xc);
|
||||
goto out;
|
||||
}
|
||||
|
||||
@@ -3503,10 +3535,13 @@ static int xfrm_do_migrate_state(struct sk_buff *skb, struct nlmsghdr *nlh,
|
||||
err = 0;
|
||||
}
|
||||
|
||||
xfrm_state_put(xc);
|
||||
out:
|
||||
xfrm_state_put(x);
|
||||
return err;
|
||||
out_xc:
|
||||
if (m.xuo)
|
||||
xfrm_dev_state_delete(xc);
|
||||
xc->km.state = XFRM_STATE_DEAD;
|
||||
xfrm_state_put(xc);
|
||||
xfrm_state_put(x);
|
||||
|
||||
Reference in New Issue
Block a user