xfrm: Add compat layer
Subsystems (4)
v3 cover xfrm: Add compat layer
Changes since v2:
- added struct xfrm_translator as API to register xfrm_compat.ko with xfrm_state.ko. This allows compilation of translator as a loadable module
- fixed indention and collected reviewed-by (Johannes Berg)
- moved boilerplate from commit messages into cover-letter (Steffen Klassert)
- found on KASAN build and fixed non-initialised stack variable usage in the translator
The resulting v2/v3 diff can be found here:
https://gist.github.com/0x7f454c46/8f68311dfa1f240959fdbe7c77ed2259
Patches as a .git branch:
https://github.com/0x7f454c46/linux/tree/xfrm-compat-v3
Changes since v1:
- reworked patches set to use translator
- separated the compat layer into xfrm_compat.c, compiled under XFRM_USER_COMPAT config
- 32-bit messages now being sent in frag_list (like wext-core does)
- instead of __packed add compat_u64 members in compat structures
- selftest reworked to kselftest lib API
- added netlink dump testing to the selftest
XFRM is disabled for compatible users because of the UABI difference. The difference is in structures paddings and in the result the size of netlink messages differ.
Possibility for compatible application to manage xfrm tunnels was disabled by: the commmit 19d7df69fdb2 ("xfrm: Refuse to insert 32 bit userspace socket policies on 64 bit systems") and the commit 74005991b78a ("xfrm: Do not parse 32bits compiled xfrm netlink msg on 64bits host").
This is my second attempt to resolve the xfrm/compat problem by adding the 64=>32 and 32=>64 bit translators those non-visibly to a user provide translation between compatible user and kernel. Previous attempt was to interrupt the message ABI according to a syscall by xfrm_user, which resulted in over-complicated code [1].
Florian Westphal provided the idea of translator and some draft patches in the discussion. In these patches, his idea is reused and some of his initial code is also present.
There were a couple of attempts to solve xfrm compat problem:
https://lkml.org/lkml/2017/1/20/733
https://patchwork.ozlabs.org/patch/44600/
http://netdev.vger.kernel.narkive.com/2Gesykj6/patch-net-next-xfrm-correctly-parse-netlink-msg-from-32bits-ip-command-on-64bits-host
All the discussions end in the conclusion that xfrm should have a full compatible layer to correctly work with 32-bit applications on 64-bit kernels:
https://lkml.org/lkml/2017/1/23/413
https://patchwork.ozlabs.org/patch/433279/
In some recent lkml discussion, Linus said that it's worth to fix this problem and not giving people an excuse to stay on 32-bit kernel:
https://lkml.org/lkml/2018/2/13/752
There is also an selftest for ipsec tunnels.
It doesn't depend on any library and compat version can be easy build with: make CFLAGS=-m32 net/ipsec
[1]: https://lkml.kernel.org/r/[email protected]
Dmitry Safonov (7):
xfrm: Provide API to register translator module xfrm/compat: Add 64=>32-bit messages translator xfrm/compat: Attach xfrm dumps to 64=>32 bit translator netlink/compat: Append NLMSG_DONE/extack to frag_list xfrm/compat: Add 32=>64-bit messages translator xfrm/compat: Translate 32-bit user_policy from sockptr selftest/net/xfrm: Add test for ipsec tunnel
MAINTAINERS | 1 + include/net/xfrm.h | 33 + net/netlink/af_netlink.c | 47 +- net/xfrm/Kconfig | 11 + net/xfrm/Makefile | 1 + net/xfrm/xfrm_compat.c | 625 +++++++ net/xfrm/xfrm_state.c | 77 +- net/xfrm/xfrm_user.c | 110 +- tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/ipsec.c | 2195 ++++++++++++++++++++++++ 11 files changed, 3066 insertions(+), 36 deletions(-) create mode 100644 net/xfrm/xfrm_compat.c create mode 100644 tools/testing/selftests/net/ipsec.c
base-commit: ba4f184e126b751d1bffad5897f263108befc780
Signature · 1 line
2.28.0
PATCH v3 1/7 xfrm: Provide API to register translator module
Add a skeleton for xfrm_compat module and provide API to register it in xfrm_state.ko. struct xfrm_translator will have function pointers to translate messages received from 32-bit userspace or to be sent to it from 64-bit kernel.
module_get()/module_put() are used instead of rcu_read_lock() as the module will vmalloc() memory for translation.
The new API is registered with xfrm_state module, not with xfrm_user as the former needs translator for user_policy set by setsockopt() and xfrm_user already uses functions from xfrm_state.
--- include/net/xfrm.h | 19 +++++++++++++ net/xfrm/Kconfig | 10 +++++++ net/xfrm/Makefile | 1 + net/xfrm/xfrm_compat.c | 29 ++++++++++++++++++++ net/xfrm/xfrm_state.c | 60 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 119 insertions(+) create mode 100644 net/xfrm/xfrm_compat.c
include/net/xfrm.h +19 -0
@@ -2000,6 +2000,25 @@ static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,return 0 ; } +struct xfrm_translator { +struct module *owner; +}; + +#if IS_ENABLED (CONFIG_XFRM_USER_COMPAT ) +extern int xfrm_register_translator (struct xfrm_translator *xtr); +extern int xfrm_unregister_translator (struct xfrm_translator *xtr); +extern struct xfrm_translator *xfrm_get_translator (void ); +extern void xfrm_put_translator (struct xfrm_translator *xtr); +#else +static inline struct xfrm_translator *xfrm_get_translator (void ) +{ +return NULL ; +} +static inline void xfrm_put_translator (struct xfrm_translator *xtr) +{ +} +#endif +#if IS_ENABLED (CONFIG_IPV6 )static inline bool xfrm6_local_dontfrag (const struct sock *sk) {
net/xfrm/Kconfig +10 -0
@@ -28,6 +28,16 @@ config XFRM_USER If unsure, say Y. +config XFRM_USER_COMPAT + tristate "Compatible ABI support" + depends on XFRM_USER && COMPAT_FOR_U64_ALIGNMENT + select WANT_COMPAT_NETLINK_MESSAGES + help + Transformation(XFRM) user configuration interface like IPsec + used by compatible Linux applications. + + If unsure, say N. + config XFRM_INTERFACE tristate "Transformation virtual interface" depends on XFRM && IPV6
net/xfrm/Makefile +1 -0
@@ -9,6 +9,7 @@ obj-$(CONFIG_XFRM) := xfrm_policy.o xfrm_state.o xfrm_hash.o \ obj-$(CONFIG_XFRM_STATISTICS) += xfrm_proc.o obj-$(CONFIG_XFRM_ALGO) += xfrm_algo.o obj-$(CONFIG_XFRM_USER) += xfrm_user.o +obj-$(CONFIG_XFRM_USER_COMPAT) += xfrm_compat.o obj-$(CONFIG_XFRM_IPCOMP) += xfrm_ipcomp.o obj-$(CONFIG_XFRM_INTERFACE) += xfrm_interface.o obj-$(CONFIG_XFRM_ESPINTCP) += espintcp.o
net/xfrm/xfrm_compat.c new file +29 -0
@@ -0,0 +1,29 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* XFRM compat layer +* Author: Dmitry Safonov <[email protected]> +* Based on code and translator idea by: Florian Westphal <[email protected]> +*/ +#include <linux/compat.h> +#include <linux/xfrm.h> +#include <net/xfrm.h> + +static struct xfrm_translator xfrm_translator = { + .owner =THIS_MODULE , +}; + +static int __init xfrm_compat_init (void ) +{ +return xfrm_register_translator (&xfrm_translator); +} + +static void __exit xfrm_compat_exit(void) +{ +xfrm_unregister_translator (&xfrm_translator); +} + +module_init (xfrm_compat_init); +module_exit (xfrm_compat_exit); +MODULE_LICENSE ("GPL" ); +MODULE_AUTHOR ("Dmitry Safonov" ); +MODULE_DESCRIPTION ("XFRM 32-bit compatibility layer" );
net/xfrm/xfrm_state.c +60 -0
66 lines not on this page · raw message
Signature · 1 line
2.28.0
PATCH v3 2/7 xfrm/compat: Add 64=>32-bit messages translator
In reply to Dmitry SafonovProvide the kernel-to-user translator under XFRM_USER_COMPAT, that creates for 64-bit xfrm-user message a 32-bit translation and puts it in skb's frag_list. net/compat.c layer provides MSG_CMSG_COMPAT to decide if the message should be taken from skb or frag_list. (used by wext-core which has also an ABI difference)
Kernel sends 64-bit xfrm messages to the userspace for:
- multicast (monitor events)
- netlink dumps
Wire up the translator to xfrm_nlmsg_multicast().
--- include/net/xfrm.h | 5 + net/xfrm/xfrm_compat.c | 296 +++++++++++++++++++++++++++++++++++++++++ net/xfrm/xfrm_user.c | 15 ++- 3 files changed, 315 insertions(+), 1 deletion(-)
include/net/xfrm.h +5 -0
@@ -2000,7 +2000,12 @@ static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,return 0 ; } +extern const int xfrm_msg_min[XFRM_NR_MSGTYPES ]; +struct xfrm_translator { +/* Allocate frag_list and put compat translation there */ +int (*alloc_compat)(struct sk_buff *skb,const struct nlmsghdr *src); +struct module *owner; };
net/xfrm/xfrm_compat.c +296 -0
304 lines not on this page · raw message
net/xfrm/xfrm_user.c +14 -1
@@ -1083,12 +1083,24 @@ static inline int xfrm_nlmsg_multicast(struct net *net, struct sk_buff *skb, u32 pid, unsigned int group) {struct sock *nlsk =rcu_dereference (net->xfrm.nlsk); +struct xfrm_translator *xtr;if (!nlsk) {kfree_skb (skb);return -EPIPE ; } + xtr =xfrm_get_translator (); +if (xtr) { +int err = xtr->alloc_compat (skb,nlmsg_hdr (skb)); + +xfrm_put_translator (xtr); +if (err) { +kfree_skb (skb); +return err; + } + } +return nlmsg_multicast (nlsk, skb, pid, group,GFP_ATOMIC ); }
@@ -2533,7 +2545,7 @@ static int xfrm_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,#define XMSGSIZE (type) sizeof(struct type) -static const int xfrm_msg_min[XFRM_NR_MSGTYPES ] = { +const int xfrm_msg_min[XFRM_NR_MSGTYPES ] = { [XFRM_MSG_NEWSA -XFRM_MSG_BASE ] =XMSGSIZE (xfrm_usersa_info), [XFRM_MSG_DELSA -XFRM_MSG_BASE ] =XMSGSIZE (xfrm_usersa_id), [XFRM_MSG_GETSA -XFRM_MSG_BASE ] =XMSGSIZE (xfrm_usersa_id),
@@ -2556,6 +2568,7 @@ static const int xfrm_msg_min[XFRM_NR_MSGTYPES] = { [XFRM_MSG_NEWSPDINFO - XFRM_MSG_BASE] = sizeof(u32), [XFRM_MSG_GETSPDINFO -XFRM_MSG_BASE ] =sizeof (u32), }; +EXPORT_SYMBOL_GPL (xfrm_msg_min);#undef XMSGSIZE
Signature · 1 line
2.28.0
PATCH v3 3/7 xfrm/compat: Attach xfrm dumps to 64=>32 bit translator
In reply to Dmitry SafonovCurrently nlmsg_unicast() is used by functions that dump structures that can be different in size for compat tasks, see dump_one_state() and dump_one_policy().
The following nlmsg_unicast() users exist today in xfrm:
Function | Message can be different
| in size on compat
-------------------------------------------|------------------------------
xfrm_get_spdinfo() | N
xfrm_get_sadinfo() | N
xfrm_get_sa() | Y
xfrm_alloc_userspi() | Y
xfrm_get_policy() | Y
xfrm_get_ae() | NBesides, dump_one_state() and dump_one_policy() can be used by filtered netlink dump for XFRM_MSG_GETSA, XFRM_MSG_GETPOLICY.
Just as for xfrm multicast, allocate frag_list for compat skb journey down to recvmsg() which will give user the desired skb according to syscall bitness.
--- net/xfrm/xfrm_user.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+)
net/xfrm/xfrm_user.c +38 -0
@@ -975,6 +975,7 @@ static int dump_one_state(struct xfrm_state *x, int count, void *ptr)struct xfrm_dump_info *sp = ptr;struct sk_buff *in_skb = sp->in_skb;struct sk_buff *skb = sp->out_skb; +struct xfrm_translator *xtr;struct xfrm_usersa_info *p;struct nlmsghdr *nlh;int err;
@@ -992,6 +993,18 @@ static int dump_one_state(struct xfrm_state *x, int count, void *ptr)return err; }nlmsg_end (skb, nlh); + + xtr =xfrm_get_translator (); +if (xtr) { + err = xtr->alloc_compat (skb, nlh); + +xfrm_put_translator (xtr); +if (err) { +nlmsg_cancel (skb, nlh); +return err; + } + } +return 0 ; }
@@ -1320,6 +1333,7 @@ static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh,struct net *net =sock_net (skb->sk);struct xfrm_state *x;struct xfrm_userspi_info *p; +struct xfrm_translator *xtr;struct sk_buff *resp_skb;xfrm_address_t *daddr;int family;
@@ -1370,6 +1384,17 @@ static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh, goto out; } + xtr =xfrm_get_translator (); +if (xtr) { + err = xtr->alloc_compat (skb,nlmsg_hdr (skb)); + +xfrm_put_translator (xtr); +if (err) { +kfree_skb (resp_skb); + goto out; + } + } + err =nlmsg_unicast (net->xfrm.nlsk, resp_skb,NETLINK_CB (skb).portid); out:
@@ -1776,6 +1801,7 @@ static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptrstruct xfrm_userpolicy_info *p;struct sk_buff *in_skb = sp->in_skb;struct sk_buff *skb = sp->out_skb; +struct xfrm_translator *xtr;struct nlmsghdr *nlh;int err;
@@ -1800,6 +1826,18 @@ static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptrreturn err; }nlmsg_end (skb, nlh); + + xtr =xfrm_get_translator (); +if (xtr) { + err = xtr->alloc_compat (skb, nlh); + +xfrm_put_translator (xtr); +if (err) { +nlmsg_cancel (skb, nlh); +return err; + } + } +return 0 ; }
Signature · 1 line
2.28.0
PATCH v3 4/7 netlink/compat: Append NLMSG_DONE/extack to frag_list
In reply to Dmitry SafonovModules those use netlink may supply a 2nd skb, (via frag_list) that contains an alternative data set meant for applications using 32bit compatibility mode.
In such a case, netlink_recvmsg will use this 2nd skb instead of the original one.
Without this patch, such compat applications will retrieve all netlink dump data, but will then get an unexpected EOF.
--- net/netlink/af_netlink.c | 47 ++++++++++++++++++++++++++++------------ 1 file changed, 33 insertions(+), 14 deletions(-)
net/netlink/af_netlink.c +33 -14
@@ -2186,13 +2186,35 @@ EXPORT_SYMBOL(__nlmsg_put);* It would be better to create kernel thread. */ +static int netlink_dump_done (struct netlink_sock *nlk,struct sk_buff *skb, +struct netlink_callback *cb, +struct netlink_ext_ack *extack) +{ +struct nlmsghdr *nlh; + + nlh =nlmsg_put_answer (skb, cb,NLMSG_DONE ,sizeof (nlk->dump_done_errno), +NLM_F_MULTI | cb->answer_flags); +if (WARN_ON (!nlh)) +return -ENOBUFS ; + +nl_dump_check_consistent (cb, nlh); +memcpy (nlmsg_data (nlh), &nlk->dump_done_errno,sizeof (nlk->dump_done_errno)); + +if (extack->_msg && nlk->flags &NETLINK_F_EXT_ACK ) { + nlh->nlmsg_flags |=NLM_F_ACK_TLVS ; +if (!nla_put_string (skb,NLMSGERR_ATTR_MSG , extack->_msg)) +nlmsg_end (skb, nlh); + } + +return 0 ; +} +static int netlink_dump (struct sock *sk) {struct netlink_sock *nlk =nlk_sk (sk);struct netlink_ext_ack extack = {};struct netlink_callback *cb;struct sk_buff *skb =NULL ; -struct nlmsghdr *nlh;struct module *module;int err = -ENOBUFS ;int alloc_min_size;
@@ -2258,22 +2280,19 @@ static int netlink_dump(struct sock *sk)return 0 ; } - nlh =nlmsg_put_answer (skb, cb,NLMSG_DONE , -sizeof (nlk->dump_done_errno), -NLM_F_MULTI | cb->answer_flags); -if (WARN_ON (!nlh)) +if (netlink_dump_done (nlk, skb, cb, &extack)) goto errout_skb; -nl_dump_check_consistent (cb, nlh); - -memcpy (nlmsg_data (nlh), &nlk->dump_done_errno, -sizeof (nlk->dump_done_errno)); - -if (extack._msg && nlk->flags &NETLINK_F_EXT_ACK ) { - nlh->nlmsg_flags |=NLM_F_ACK_TLVS ; -if (!nla_put_string (skb,NLMSGERR_ATTR_MSG , extack._msg)) -nlmsg_end (skb, nlh); +#ifdef CONFIG_COMPAT_NETLINK_MESSAGES +/* frag_list skb's data is used for compat tasks +* and the regular skb's data for normal (non-compat) tasks. +* See netlink_recvmsg(). +*/ +if (unlikely (skb_shinfo (skb)->frag_list)) { +if (netlink_dump_done (nlk,skb_shinfo (skb)->frag_list, cb, &extack)) + goto errout_skb; } +#endif if (sk_filter (sk, skb))kfree_skb (skb);
Signature · 1 line
2.28.0
PATCH v3 5/7 xfrm/compat: Add 32=>64-bit messages translator
In reply to Dmitry SafonovProvide the user-to-kernel translator under XFRM_USER_COMPAT, that creates for 32-bit xfrm-user message a 64-bit translation. The translation is afterwards reused by xfrm_user code just as if userspace had sent 64-bit message.
--- include/net/xfrm.h | 6 + net/xfrm/Kconfig | 3 +- net/xfrm/xfrm_compat.c | 274 +++++++++++++++++++++++++++++++++++++++++ net/xfrm/xfrm_user.c | 57 ++++++--- 4 files changed, 321 insertions(+), 19 deletions(-)
include/net/xfrm.h +6 -0
@@ -2001,11 +2001,17 @@ static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x, }extern const int xfrm_msg_min[XFRM_NR_MSGTYPES ]; +extern const struct nla_policy xfrma_policy[XFRMA_MAX +1 ];struct xfrm_translator {/* Allocate frag_list and put compat translation there */ int (*alloc_compat)(struct sk_buff *skb,const struct nlmsghdr *src); +/* Allocate nlmsg with 64-bit translaton of received 32-bit message */ +struct nlmsghdr *(*rcv_msg_compat)(const struct nlmsghdr *nlh, +int maxtype,const struct nla_policy *policy, +struct netlink_ext_ack *extack); +struct module *owner; };
net/xfrm/Kconfig +2 -1
@@ -30,7 +30,8 @@ config XFRM_USER config XFRM_USER_COMPAT tristate "Compatible ABI support" - depends on XFRM_USER && COMPAT_FOR_U64_ALIGNMENT + depends on XFRM_USER && COMPAT_FOR_U64_ALIGNMENT && \ + HAVE_EFFICIENT_UNALIGNED_ACCESS select WANT_COMPAT_NETLINK_MESSAGES help Transformation(XFRM) user configuration interface like IPsec
net/xfrm/xfrm_compat.c +274 -0
289 lines not on this page · raw message
net/xfrm/xfrm_user.c +39 -18
102 lines not on this page · raw message
Signature · 1 line
2.28.0
PATCH v3 6/7 xfrm/compat: Translate 32-bit user_policy from sockptr
In reply to Dmitry SafonovProvide compat_xfrm_userpolicy_info translation for xfrm setsocketopt(). Reallocate buffer and put the missing padding for 64-bit message.
--- include/net/xfrm.h | 3 +++ net/xfrm/xfrm_compat.c | 26 ++++++++++++++++++++++++++ net/xfrm/xfrm_state.c | 17 ++++++++++++++--- 3 files changed, 43 insertions(+), 3 deletions(-)
include/net/xfrm.h +3 -0
@@ -2012,6 +2012,9 @@ struct xfrm_translator { int maxtype, const struct nla_policy *policy, struct netlink_ext_ack *extack); +/* Translate 32-bit user_policy from sockptr */ +int (*xlate_user_policy_sockptr)(u8 **pdata32,int optlen); +struct module *owner; };
net/xfrm/xfrm_compat.c +26 -0
@@ -576,10 +576,36 @@ static struct nlmsghdr *xfrm_user_rcv_msg_compat(const struct nlmsghdr *h32,return h64; } +static int xfrm_user_policy_compat (u8 **pdata32,int optlen) +{ +struct compat_xfrm_userpolicy_info *p = (void *)*pdata32; +u8 *src_templates, *dst_templates; +u8 *data64; + +if (optlen <sizeof (*p)) +return -EINVAL ; + + data64 =kmalloc_track_caller (optlen +4 ,GFP_USER | __GFP_NOWARN); +if (!data64) +return -ENOMEM ; + +memcpy (data64, *pdata32,sizeof (*p)); +memset (data64 +sizeof (*p),0 ,4 ); + + src_templates = *pdata32 +sizeof (*p); + dst_templates = data64 +sizeof (*p) +4 ; +memcpy (dst_templates, src_templates, optlen -sizeof (*p)); + +kfree (*pdata32); + *pdata32 = data64; +return 0 ; +} +static struct xfrm_translator xfrm_translator = { .owner =THIS_MODULE , .alloc_compat = xfrm_alloc_compat, .rcv_msg_compat = xfrm_user_rcv_msg_compat, + .xlate_user_policy_sockptr = xfrm_user_policy_compat, };static int __init xfrm_compat_init (void )
net/xfrm/xfrm_state.c +14 -3
@@ -2331,9 +2331,6 @@ int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval, int optlen)struct xfrm_mgr *km;struct xfrm_policy *pol =NULL ; -if (in_compat_syscall ()) -return -EOPNOTSUPP ; -if (sockptr_is_null (optval) && !optlen) {xfrm_sk_policy_insert (sk,XFRM_POLICY_IN ,NULL );xfrm_sk_policy_insert (sk,XFRM_POLICY_OUT ,NULL );
@@ -2348,6 +2345,20 @@ int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval, int optlen)if (IS_ERR (data))return PTR_ERR (data); +if (in_compat_syscall ()) { +struct xfrm_translator *xtr =xfrm_get_translator (); + +if (!xtr) +return -EOPNOTSUPP ; + + err = xtr->xlate_user_policy_sockptr (&data, optlen); +xfrm_put_translator (xtr); +if (err) { +kfree (data); +return err; + } + } + err = -EINVAL ;rcu_read_lock ();list_for_each_entry_rcu (km, &xfrm_km_list, list) {
Signature · 1 line
2.28.0
PATCH v3 7/7 selftest/net/xfrm: Add test for ipsec tunnel
In reply to Dmitry SafonovIt's an exhaustive testing for ipsec: covering all encryption/ authentication/compression algorithms. The tests are run in two network namespaces, connected by veth interfaces. To make exhaustive testing less time-consuming, the tests are run in parallel tasks, specified by parameter to the selftest.
As the patches set adds support for xfrm in compatible tasks, there are tests to check structures that differ in size between 64-bit and 32-bit applications.
The selftest doesn't use libnl so that it can be easily compiled as compatible application and don't require compatible .so.
Here is a diagram of the selftest:
---------------
| selftest |
| (parent) |
---------------
| |
| (pipe) |
----------
/ | | \
/------------- / \ -------------\
| /----- -----\ |
---------|----------|----------------|----------|---------
| --------- --------- --------- --------- |
| | child | | child | NS A | child | | child | |
| --------- --------- --------- --------- |
-------|------------|----------------|-------------|------
veth0 veth1 veth2 vethN
---------|------------|----------------|-------------|----------
| ------------ ------------ ------------ ------------ |
| | gr.child | | gr.child | NS B | gr.child | | gr.child | |
| ------------ ------------ ------------ ------------ |
----------------------------------------------------------------The parent sends the description of a test (xfrm parameters) to the child, the child and grand child setup a tunnel over veth interface and test it by sending udp packets.
--- MAINTAINERS | 1 + tools/testing/selftests/net/.gitignore | 1 + tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/ipsec.c | 2195 ++++++++++++++++++++++++ 4 files changed, 2198 insertions(+) create mode 100644 tools/testing/selftests/net/ipsec.c
MAINTAINERS +1 -0
@@ -12134,6 +12134,7 @@ F: net/ipv6/ipcomp6.c F: net/ipv6/xfrm* F: net/key/ F: net/xfrm/ +F: tools/testing/selftests/net/ipsec.c NETWORKING [IPv4/IPv6] M: "David S. Miller" <[email protected]>
tools/testing/selftests/net/.gitignore +1 -0
@@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only +ipsec msg_zerocopy socket psock_fanout
tools/testing/selftests/net/Makefile +1 -0
@@ -29,6 +29,7 @@ TEST_GEN_FILES += tcp_fastopen_backup_key TEST_GEN_FILES += fin_ack_lat TEST_GEN_FILES += reuseaddr_ports_exhausted TEST_GEN_FILES += hwtstamp_config rxtimestamp timestamping txtimestamp +TEST_GEN_FILES += ipsec TEST_GEN_PROGS = reuseport_bpf reuseport_bpf_cpu reuseport_bpf_numa TEST_GEN_PROGS += reuseport_dualstack reuseaddr_conflict tls
tools/testing/selftests/net/ipsec.c new file +2195 -0
2,195 lines not on this page · raw message
Signature · 1 line
2.28.0
Steffen Klassert
maintainerQuoted 75 lines · Dmitry Safonov
Changes since v2:
- added structxfrm_translatoras API to register xfrm_compat.ko with xfrm_state.ko. This allows compilation of translator as a loadable module
- fixed indention and collected reviewed-by (Johannes Berg)
- moved boilerplate from commit messages into cover-letter (Steffen Klassert)
- found on KASAN build and fixed non-initialised stack variable usage in the translatorThe resulting v2/v3 diff can be found here:
https://gist.github.com/0x7f454c46/8f68311dfa1f240959fdbe7c77ed2259Patches as a .git branch:
https://github.com/0x7f454c46/linux/tree/xfrm-compat-v3Changes since v1:
- reworked patches set to use translator
- separated the compat layer intoxfrm_compat.c, compiled underXFRM_USER_COMPATconfig
- 32-bit messages now being sent infrag_list(like wext-core does)
- instead of__packedaddcompat_u64members in compat structures
- selftest reworked to kselftest lib API
- added netlink dump testing to the selftestXFRM is disabled for compatible users because of the UABI difference. The difference is in structures paddings and in the result the size of netlink messages differ.
Possibility for compatible application to manage xfrm tunnels was disabled by: the commmit
19d7df69fdb2("xfrm: Refuse to insert 32 bit userspace socket policies on 64 bit systems") and the commit74005991b78a("xfrm: Do not parse 32bits compiled xfrm netlink msg on 64bits host").This is my second attempt to resolve the xfrm/compat problem by adding the 64=>32 and 32=>64 bit translators those non-visibly to a user provide translation between compatible user and kernel. Previous attempt was to interrupt the message ABI according to a syscall by
xfrm_user, which resulted in over-complicated code [1].Florian Westphal provided the idea of translator and some draft patches in the discussion. In these patches, his idea is reused and some of his initial code is also present.
There were a couple of attempts to solve xfrm compat problem:
https://lkml.org/lkml/2017/1/20/733
https://patchwork.ozlabs.org/patch/44600/
http://netdev.vger.kernel.narkive.com/2Gesykj6/patch-net-next-xfrm-correctly-parse-netlink-msg-from-32bits-ip-command-on-64bits-hostAll the discussions end in the conclusion that xfrm should have a full compatible layer to correctly work with 32-bit applications on 64-bit kernels:
https://lkml.org/lkml/2017/1/23/413
https://patchwork.ozlabs.org/patch/433279/In some recent lkml discussion, Linus said that it's worth to fix this problem and not giving people an excuse to stay on 32-bit kernel:
https://lkml.org/lkml/2018/2/13/752There is also an selftest for ipsec tunnels.
It doesn't depend on any library and compat version can be easy build with: make CFLAGS=-m32 net/ipsec[1]: https://lkml.kernel.org/r/[email protected]
Cc "David S. Miller" <[email protected]>Cc Florian Westphal <[email protected]>Cc Herbert Xu <[email protected]>Cc Jakub Kicinski <[email protected]>Cc Johannes Berg <[email protected]>Cc Steffen Klassert <[email protected]>Cc Stephen Suryaputra <[email protected]>Cc Dmitry Safonov <[email protected]>
Quoted 8 lines
Dmitry Safonov (7):
xfrm: Provide API to register translator module xfrm/compat: Add 64=>32-bit messages translator xfrm/compat: Attach xfrm dumps to 64=>32 bit translator netlink/compat: Append NLMSG_DONE/extack tofrag_listxfrm/compat: Add 32=>64-bit messages translator xfrm/compat: Translate 32-bituser_policyfrom sockptr selftest/net/xfrm: Add test for ipsec tunnel
Series applied to ipsec-next. Thanks a lot for your work Dmitry!