Introduce eBPF flow dissector
Subsystems (9)
v4 cover Introduce eBPF flow dissector
From: Petar Penkov <[email protected]>
This patch series hardens the RX stack by allowing flow dissection in BPF, as previously discussed [1]. Because of the rigorous checks of the BPF verifier, this provides significant security guarantees. In particular, the BPF flow dissector cannot get inside of an infinite loop, as with CVE-2013-4348, because BPF programs are guaranteed to terminate. It cannot read outside of packet bounds, because all memory accesses are checked. Also, with BPF the administrator can decide which protocols to support, reducing potential attack surface. Rarely encountered protocols can be excluded from dissection and the program can be updated without kernel recompile or reboot if a bug is discovered.
Patch 1 adds infrastructure to execute a BPF program in __skb_flow_dissect. This includes a new BPF program and attach type.
Patch 2 adds the new BPF flow dissector definitions to tools/uapi.
Patch 3 adds support for the new BPF program type to libbpf and bpftool.
Patch 4 adds a flow dissector program in BPF. This parses most protocols in __skb_flow_dissect in BPF for a subset of flow keys (basic, control, ports, and address types).
Patch 5 adds a selftest that attaches the BPF program to the flow dissector and sends traffic with different levels of encapsulation.
Performance Evaluation:
The in-kernel implementation was compared against the demo program from patch 4 using the test in patch 5 with IPv4/UDP traffic over 10 seconds.
$perf record -a -C 4 taskset -c 4 ./test_flow_dissector -i 4 -f 8 \ -t 10
In-kernel Dissector:
__skb_flow_dissect overhead: 2.12% Total Packets: 3,272,597 (from output of ./test_flow_dissector)
BPF Dissector:
__skb_flow_dissect overhead: 1.63% Total Packets: 3,232,356 (from output of ./test_flow_dissector)
No-op BPF Dissector:
__skb_flow_dissect overhead: 1.52% Total Packets: 3,330,635 (from output of ./test_flow_dissector)
Changes since v3:
1/ struct bpf_flow_keys reorganized to remove holes in patch 1 and patch 2.
Changes since v2:
1/ Changes to tools/include/uapi pulled into a separate patch 2 2/ Changes to tools/lib and tools/bpftool pulled into a separate patch 3 3/ Changed flow_keys in __sk_buff from __u32 to struct bpf_flow_keys * 4/ Added nhoff field in struct bpf_flow_keys to pass initial offset 5/ Saving all of the modified control block, rather than just the qdisc 6/ Sample BPF program in patch 4 modified to use the changes above
Changes since v1:
1/ LD_ABS instructions now disallowed for the new BPF prog type 2/ now checks if skb is NULL in __skb_flow_dissect()
3/ fixed incorrect accesses in flow_dissector_is_valid_access()
- writes to the flow_keys field now disallowed
- reads/writes to tc_classid and data_meta now disallowed
4/ headers pulled with bpf_skb_load_data if direct access fails
Changes since RFC:
1/ Flow dissector hook changed from global to per-netns
2/ Defined struct bpf_flow_keys to be used in BPF flow dissector programs instead of exposing the internal flow keys layout. Added a function to translate from bpf_flow_keys to the internal layout after BPF dissection is complete. The pointer to this struct is stored in qdisc_skb_cb rather than inside of the 20 byte control block which simplifies verification and allows access to all 20 bytes of the cb. 3/ Removed GUE parsing as it relied on a hardcoded port
4/ MPLS parsing now stops at the first label which is consistent with the in-kernel flow dissector
5/ Refactored to use direct packet access and to write out to struct bpf_flow_keys
[1] http://vger.kernel.org/netconf2017_files/rx_hardening_and_udp_gso.pdf
Petar Penkov (5):
flow_dissector: implements flow dissector BPF hook
bpf: sync bpf.h uapi with tools/
bpf: support flow dissector in libbpf and bpftool
flow_dissector: implements eBPF parser selftests/bpf: test bpf flow dissection
include/linux/bpf.h | 1 + include/linux/bpf_types.h | 1 + include/linux/skbuff.h | 7 + include/net/net_namespace.h | 3 + include/net/sch_generic.h | 12 +- include/uapi/linux/bpf.h | 26 + kernel/bpf/syscall.c | 8 + kernel/bpf/verifier.c | 32 + net/core/filter.c | 70 ++ net/core/flow_dissector.c | 134 +++ tools/bpf/bpftool/prog.c | 1 + tools/include/uapi/linux/bpf.h | 26 + tools/lib/bpf/libbpf.c | 2 + tools/testing/selftests/bpf/.gitignore | 2 + tools/testing/selftests/bpf/Makefile | 8 +- tools/testing/selftests/bpf/bpf_flow.c | 373 +++++++++ tools/testing/selftests/bpf/config | 1 + .../selftests/bpf/flow_dissector_load.c | 140 ++++ .../selftests/bpf/test_flow_dissector.c | 782 ++++++++++++++++++ .../selftests/bpf/test_flow_dissector.sh | 115 +++ tools/testing/selftests/bpf/with_addr.sh | 54 ++ tools/testing/selftests/bpf/with_tunnels.sh | 36 + 22 files changed, 1828 insertions(+), 6 deletions(-) create mode 100644 tools/testing/selftests/bpf/bpf_flow.c create mode 100644 tools/testing/selftests/bpf/flow_dissector_load.c create mode 100644 tools/testing/selftests/bpf/test_flow_dissector.c create mode 100755 tools/testing/selftests/bpf/test_flow_dissector.sh create mode 100755 tools/testing/selftests/bpf/with_addr.sh create mode 100755 tools/testing/selftests/bpf/with_tunnels.sh
Signature · 1 line
2.19.0.397.gdd90340f6a-goog
PATCH v4 1/5 flow_dissector: implements flow dissector BPF hook
From: Petar Penkov <[email protected]>
Adds a hook for programs of type BPF_PROG_TYPE_FLOW_DISSECTOR and attach type BPF_FLOW_DISSECTOR that is executed in the flow dissector path. The BPF program is per-network namespace.
--- include/linux/bpf.h | 1 + include/linux/bpf_types.h | 1 + include/linux/skbuff.h | 7 ++ include/net/net_namespace.h | 3 + include/net/sch_generic.h | 12 +++- include/uapi/linux/bpf.h | 26 +++++++ kernel/bpf/syscall.c | 8 +++ kernel/bpf/verifier.c | 32 +++++++++ net/core/filter.c | 70 +++++++++++++++++++ net/core/flow_dissector.c | 134 ++++++++++++++++++++++++++++++++++++ 10 files changed, 291 insertions(+), 3 deletions(-)
include/linux/bpf.h +1 -0
@@ -212,6 +212,7 @@ enum bpf_reg_type {PTR_TO_PACKET_META ,/* skb->data - meta_len */ PTR_TO_PACKET ,/* reg points to skb->data */ PTR_TO_PACKET_END ,/* skb->data + headlen */ + PTR_TO_FLOW_KEYS, /* reg points to bpf_flow_keys */ };/* The information passed from prog-specific *_is_valid_access
include/linux/bpf_types.h +1 -0
@@ -32,6 +32,7 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2)#ifdef CONFIG_INET BPF_PROG_TYPE(BPF_PROG_TYPE_SK_REUSEPORT, sk_reuseport)#endif +BPF_PROG_TYPE(BPF_PROG_TYPE_FLOW_DISSECTOR, flow_dissector) BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)BPF_MAP_TYPE (BPF_MAP_TYPE_PERCPU_ARRAY , percpu_array_map_ops)
include/linux/skbuff.h +7 -0
@@ -243,6 +243,8 @@ struct scatterlist;struct pipe_inode_info ;struct iov_iter ;struct napi_struct ; +struct bpf_prog ; +union bpf_attr ;#if defined(CONFIG_NF_CONNTRACK ) || defined(CONFIG_NF_CONNTRACK_MODULE ) struct nf_conntrack {
@@ -1192,6 +1194,11 @@ void skb_flow_dissector_init(struct flow_dissector *flow_dissector,const struct flow_dissector_key *key, unsigned int key_count); +int skb_flow_dissector_bpf_prog_attach (const union bpf_attr *attr, +struct bpf_prog *prog); + +int skb_flow_dissector_bpf_prog_detach (const union bpf_attr *attr); + bool __skb_flow_dissect(const struct sk_buff *skb, struct flow_dissector *flow_dissector, void *target_container,
include/net/net_namespace.h +3 -0
@@ -43,6 +43,7 @@ struct ctl_table_header;struct net_generic ;struct uevent_sock ;struct netns_ipvs ; +struct bpf_prog ;#define NETDEV_HASHBITS 8
@@ -145,6 +146,8 @@ struct net {#endif struct net_generic __rcu *gen; +struct bpf_prog __rcu *flow_dissector_prog; +/* Note : following structs are cache line aligned */ #ifdef CONFIG_XFRM struct netns_xfrm xfrm;
include/net/sch_generic.h +9 -3
@@ -19,6 +19,7 @@ struct Qdisc_ops;struct qdisc_walker ;struct tcf_walker ;struct module ; +struct bpf_flow_keys ;typedef int tc_setup_cb_t (enum tc_setup_type type,void *type_data,void *cb_priv);
@@ -307,9 +308,14 @@ struct tcf_proto { };struct qdisc_skb_cb { -unsigned int pkt_len; -u16 slave_dev_queue_mapping; -u16 tc_classid; +union { +struct { +unsigned int pkt_len; +u16 slave_dev_queue_mapping; +u16 tc_classid; + }; +struct bpf_flow_keys *flow_keys; + };#define QDISC_CB_PRIV_LEN 20unsigned char data[QDISC_CB_PRIV_LEN ]; };
include/uapi/linux/bpf.h +26 -0
@@ -152,6 +152,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_LWT_SEG6LOCAL ,BPF_PROG_TYPE_LIRC_MODE2 ,BPF_PROG_TYPE_SK_REUSEPORT , + BPF_PROG_TYPE_FLOW_DISSECTOR, }; enum bpf_attach_type {
@@ -172,6 +173,7 @@ enum bpf_attach_type {BPF_CGROUP_UDP4_SENDMSG ,BPF_CGROUP_UDP6_SENDMSG ,BPF_LIRC_MODE2 , +BPF_FLOW_DISSECTOR , __MAX_BPF_ATTACH_TYPE };
@@ -2333,6 +2335,7 @@ struct __sk_buff {/* ... here. */ __u32 data_meta; +struct bpf_flow_keys *flow_keys; };struct bpf_tunnel_key {
@@ -2778,4 +2781,27 @@ enum bpf_task_fd_type { BPF_FD_TYPE_URETPROBE, /* filename + offset */ }; +struct bpf_flow_keys { +__u16 nhoff; +__u16 thoff; +__u16 addr_proto;/* ETH_P_* of valid addrs */ +__u8 is_frag; +__u8 is_first_frag; +__u8 is_encap; +__u8 ip_proto; +__be16 n_proto; +__be16 sport; +__be16 dport; +union { +struct { +__be32 ipv4_src; +__be32 ipv4_dst; + }; +struct { +__u32 ipv6_src[4 ];/* in6_addr; network order */ +__u32 ipv6_dst[4 ];/* in6_addr; network order */ + }; + }; +}; +#endif /* _UAPI__LINUX_BPF_H__ */
kernel/bpf/syscall.c +8 -0
@@ -1615,6 +1615,9 @@ static int bpf_prog_attach(const union bpf_attr *attr)case BPF_LIRC_MODE2 : ptype =BPF_PROG_TYPE_LIRC_MODE2 ;break ; +case BPF_FLOW_DISSECTOR : + ptype =BPF_PROG_TYPE_FLOW_DISSECTOR ; +break ;default :return -EINVAL ; }
@@ -1636,6 +1639,9 @@ static int bpf_prog_attach(const union bpf_attr *attr)case BPF_PROG_TYPE_LIRC_MODE2 : ret =lirc_prog_attach (attr, prog);break ; +case BPF_PROG_TYPE_FLOW_DISSECTOR : + ret =skb_flow_dissector_bpf_prog_attach (attr, prog); +break ;default : ret =cgroup_bpf_prog_attach (attr, ptype, prog); }
@@ -1688,6 +1694,8 @@ static int bpf_prog_detach(const union bpf_attr *attr)return sockmap_get_from_fd (attr,BPF_PROG_TYPE_SK_SKB ,NULL );case BPF_LIRC_MODE2 :return lirc_prog_detach (attr); +case BPF_FLOW_DISSECTOR : +return skb_flow_dissector_bpf_prog_detach (attr);default :return -EINVAL ; }
kernel/bpf/verifier.c +32 -0
@@ -261,6 +261,7 @@ static const char * const reg_type_str[] = { [PTR_TO_PACKET] = "pkt", [PTR_TO_PACKET_META] = "pkt_meta", [PTR_TO_PACKET_END] = "pkt_end", + [PTR_TO_FLOW_KEYS] = "flow_keys", };static char slot_type_char[] = {
@@ -965,6 +966,7 @@ static bool is_spillable_regtype(enum bpf_reg_type type)case PTR_TO_PACKET :case PTR_TO_PACKET_META :case PTR_TO_PACKET_END : +case PTR_TO_FLOW_KEYS :case CONST_PTR_TO_MAP :return true;default :
@@ -1238,6 +1240,7 @@ static bool may_access_direct_pkt_data(struct bpf_verifier_env *env,case BPF_PROG_TYPE_LWT_XMIT :case BPF_PROG_TYPE_SK_SKB :case BPF_PROG_TYPE_SK_MSG : +case BPF_PROG_TYPE_FLOW_DISSECTOR :if (meta)return meta->pkt_access;
@@ -1321,6 +1324,18 @@ static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off,return -EACCES ; } +static int check_flow_keys_access (struct bpf_verifier_env *env,int off, +int size) +{ +if (size <0 || off <0 || + (u64 )off + size >sizeof (struct bpf_flow_keys )) { +verbose (env,"invalid access to flow keys off=%d size=%d\n" , + off, size); +return -EACCES ; + } +return 0 ; +} +static bool __is_pointer_value (bool allow_ptr_leaks,const struct bpf_reg_state *reg) {
@@ -1422,6 +1437,9 @@ static int check_ptr_alignment(struct bpf_verifier_env *env,* right in front, treat it the very same way. */ return check_pkt_ptr_alignment (env, reg, off, size, strict); +case PTR_TO_FLOW_KEYS : + pointer_desc ="flow keys " ; +break ;case PTR_TO_MAP_VALUE : pointer_desc ="value " ;break ;
@@ -1692,6 +1710,17 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn err =check_packet_access (env, regno, off, size, false);if (!err && t ==BPF_READ && value_regno >=0 )mark_reg_unknown (env, regs, value_regno); + }else if (reg->type ==PTR_TO_FLOW_KEYS ) { +if (t ==BPF_WRITE && value_regno >=0 && +is_pointer_value (env, value_regno)) { +verbose (env,"R%d leaks addr into flow keys\n" , + value_regno); +return -EACCES ; + } + + err =check_flow_keys_access (env, off, size); +if (!err && t ==BPF_READ && value_regno >=0 ) +mark_reg_unknown (env, regs, value_regno); }else {verbose (env,"R%d invalid mem access '%s'\n" , regno, reg_type_str[reg->type]);
@@ -1839,6 +1868,8 @@ static int check_helper_mem_access(struct bpf_verifier_env *env, int regno,case PTR_TO_PACKET_META :return check_packet_access (env, regno, reg->off, access_size, zero_size_allowed); +case PTR_TO_FLOW_KEYS : +return check_flow_keys_access (env, reg->off, access_size);case PTR_TO_MAP_VALUE :return check_map_access (env, regno, reg->off, access_size, zero_size_allowed);
@@ -4366,6 +4397,7 @@ static bool regsafe(struct bpf_reg_state *rold, struct bpf_reg_state *rcur,case PTR_TO_CTX :case CONST_PTR_TO_MAP :case PTR_TO_PACKET_END : +case PTR_TO_FLOW_KEYS :/* Only valid matches are exact, which memcmp() above * would have accepted */
net/core/filter.c +70 -0
124 lines not on this page · raw message
net/core/flow_dissector.c +134 -0
164 lines not on this page · raw message
Signature · 1 line
2.19.0.397.gdd90340f6a-goog
Re: [bpf-next, v4 1/5] flow_dissector: implements flow dissector BPF hook
Quoted 5 lines · Petar Penkov
From: Petar Penkov <[email protected]>
Adds a hook for programs of type
BPF_PROG_TYPE_FLOW_DISSECTORand attach typeBPF_FLOW_DISSECTORthat is executed in the flow dissector path. The BPF program is per-network namespace
...
net/core/flow_dissector.c bool __skb_flow_dissect(const struct sk_buff *skb, · line 759
Quoted 4 lines
net/core/flow_dissector.c +3
-0+rcu_read_lock (); + attached = skb ?rcu_dereference (dev_net (skb->dev)->flow_dissector_prog) + :NULL ;
Some skbs have a NULL skb->dev, so we are going to crash here.
(AF_UNIX generates skbs)
Quoted 6 lines
net/core/flow_dissector.c +6
-0+if (attached) { +/* Note that even though the const qualifier is discarded +* throughout the execution of the BPF program, all changes(the +* control block) are reverted after the BPF program returns. +* Therefore, __skb_flow_dissect does not alter the skb. +*/
Re: [bpf-next, v4 1/5] flow_dissector: implements flow dissector BPF hook
Quoted 13 lines · Eric Dumazet
Quoted 5 lines · Petar Penkov
From: Petar Penkov <[email protected]>
Adds a hook for programs of type
BPF_PROG_TYPE_FLOW_DISSECTORand attach typeBPF_FLOW_DISSECTORthat is executed in the flow dissector path. The BPF program is per-network namespace...
Quoted 1 line
Quoted 6 lines
net/core/flow_dissector.c bool __skb_flow_dissect(const struct sk_buff *skb, · line 759
Quoted 3 lines
net/core/flow_dissector.c +3
-0+rcu_read_lock (); + attached = skb ?rcu_dereference (dev_net (skb->dev)->flow_dissector_prog) + :NULL ;Some skbs have a NULL
skb->dev, so we are going to crash here.
Ai. Thanks, Eric.
For these cases, we can probably infer the netns from sk->sk_net. That is assuming that all skbs have at least one of skb->sk or skb->dev set.
PATCH v4 2/5 bpf: sync bpf.h uapi with tools/
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
This patch syncs tools/include/uapi/linux/bpf.h with the flow dissector definitions from include/uapi/linux/bpf.h
--- tools/include/uapi/linux/bpf.h | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
tools/include/uapi/linux/bpf.h +26 -0
@@ -152,6 +152,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_LWT_SEG6LOCAL ,BPF_PROG_TYPE_LIRC_MODE2 ,BPF_PROG_TYPE_SK_REUSEPORT , + BPF_PROG_TYPE_FLOW_DISSECTOR, }; enum bpf_attach_type {
@@ -172,6 +173,7 @@ enum bpf_attach_type {BPF_CGROUP_UDP4_SENDMSG ,BPF_CGROUP_UDP6_SENDMSG ,BPF_LIRC_MODE2 , +BPF_FLOW_DISSECTOR , __MAX_BPF_ATTACH_TYPE };
@@ -2333,6 +2335,7 @@ struct __sk_buff {/* ... here. */ __u32 data_meta; +struct bpf_flow_keys *flow_keys; };struct bpf_tunnel_key {
@@ -2778,4 +2781,27 @@ enum bpf_task_fd_type { BPF_FD_TYPE_URETPROBE, /* filename + offset */ }; +struct bpf_flow_keys { +__u16 nhoff; +__u16 thoff; +__u16 addr_proto;/* ETH_P_* of valid addrs */ +__u8 is_frag; +__u8 is_first_frag; +__u8 is_encap; +__u8 ip_proto; +__be16 n_proto; +__be16 sport; +__be16 dport; +union { +struct { +__be32 ipv4_src; +__be32 ipv4_dst; + }; +struct { +__u32 ipv6_src[4 ];/* in6_addr; network order */ +__u32 ipv6_dst[4 ];/* in6_addr; network order */ + }; + }; +}; +#endif /* _UAPI__LINUX_BPF_H__ */
Signature · 1 line
2.19.0.397.gdd90340f6a-goog
PATCH v4 3/5 bpf: support flow dissector in libbpf and bpftool
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
This patch extends libbpf and bpftool to work with programs of type BPF_PROG_TYPE_FLOW_DISSECTOR.
--- tools/bpf/bpftool/prog.c | 1 + tools/lib/bpf/libbpf.c | 2 ++ 2 files changed, 3 insertions(+)
tools/bpf/bpftool/prog.c +1 -0
@@ -74,6 +74,7 @@ static const char * const prog_type_name[] = { [BPF_PROG_TYPE_RAW_TRACEPOINT] = "raw_tracepoint", [BPF_PROG_TYPE_CGROUP_SOCK_ADDR] = "cgroup_sock_addr", [BPF_PROG_TYPE_LIRC_MODE2] = "lirc_mode2", + [BPF_PROG_TYPE_FLOW_DISSECTOR] = "flow_dissector", };static void print_boot_time (__u64 nsecs,char *buf,unsigned int size)
tools/lib/bpf/libbpf.c +2 -0
@@ -1502,6 +1502,7 @@ static bool bpf_prog_type__needs_kver(enum bpf_prog_type type)case BPF_PROG_TYPE_CGROUP_SOCK_ADDR :case BPF_PROG_TYPE_LIRC_MODE2 :case BPF_PROG_TYPE_SK_REUSEPORT : +case BPF_PROG_TYPE_FLOW_DISSECTOR :return false;case BPF_PROG_TYPE_UNSPEC :case BPF_PROG_TYPE_KPROBE :
@@ -2121,6 +2122,7 @@ static const struct {BPF_PROG_SEC ("sk_skb" ,BPF_PROG_TYPE_SK_SKB ),BPF_PROG_SEC ("sk_msg" ,BPF_PROG_TYPE_SK_MSG ),BPF_PROG_SEC ("lirc_mode2" ,BPF_PROG_TYPE_LIRC_MODE2 ), +BPF_PROG_SEC ("flow_dissector" ,BPF_PROG_TYPE_FLOW_DISSECTOR ),BPF_SA_PROG_SEC ("cgroup/bind4" ,BPF_CGROUP_INET4_BIND ),BPF_SA_PROG_SEC ("cgroup/bind6" ,BPF_CGROUP_INET6_BIND ), BPF_SA_PROG_SEC("cgroup/connect4", BPF_CGROUP_INET4_CONNECT),
Signature · 1 line
2.19.0.397.gdd90340f6a-goog
PATCH v4 4/5 flow_dissector: implements eBPF parser
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
This eBPF program extracts basic/control/ip address/ports keys from incoming packets. It supports recursive parsing for IP encapsulation, and VLAN, along with IPv4/IPv6 and extension headers. This program is meant to show how flow dissection and key extraction can be done in eBPF.
--- tools/testing/selftests/bpf/Makefile | 2 +- tools/testing/selftests/bpf/bpf_flow.c | 373 +++++++++++++++++++++++++ 2 files changed, 374 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/bpf/bpf_flow.c
tools/testing/selftests/bpf/Makefile +1 -1
@@ -35,7 +35,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test test_get_stack_rawtp.o test_sockmap_kern.o test_sockhash_kern.o \ test_lwt_seg6local.o sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \ get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o \ - test_skb_cgroup_id_kern.o + test_skb_cgroup_id_kern.o bpf_flow.o # Order correspond to 'make run_tests' order TEST_PROGS := test_kmod.sh \
tools/testing/selftests/bpf/bpf_flow.c new file +373 -0
373 lines not on this page · raw message
Signature · 1 line
2.19.0.397.gdd90340f6a-goog
PATCH v4 5/5 selftests/bpf: test bpf flow dissection
In reply to Petar PenkovFrom: Petar Penkov <[email protected]>
Adds a test that sends different types of packets over multiple tunnels and verifies that valid packets are dissected correctly. To do so, a tc-flower rule is added to drop packets on UDP src port 9, and packets are sent from ports 8, 9, and 10. Only the packets on port 9 should be dropped. Because tc-flower relies on the flow dissector to match flows, correct classification demonstrates correct dissection.
Also add support logic to load the BPF program and to inject the test packets.
--- tools/testing/selftests/bpf/.gitignore | 2 + tools/testing/selftests/bpf/Makefile | 6 +- tools/testing/selftests/bpf/config | 1 + .../selftests/bpf/flow_dissector_load.c | 140 ++++ .../selftests/bpf/test_flow_dissector.c | 782 ++++++++++++++++++ .../selftests/bpf/test_flow_dissector.sh | 115 +++ tools/testing/selftests/bpf/with_addr.sh | 54 ++ tools/testing/selftests/bpf/with_tunnels.sh | 36 + 8 files changed, 1134 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/bpf/flow_dissector_load.c create mode 100644 tools/testing/selftests/bpf/test_flow_dissector.c create mode 100755 tools/testing/selftests/bpf/test_flow_dissector.sh create mode 100755 tools/testing/selftests/bpf/with_addr.sh create mode 100755 tools/testing/selftests/bpf/with_tunnels.sh
tools/testing/selftests/bpf/.gitignore +2 -0
@@ -23,3 +23,5 @@ test_skb_cgroup_id_user test_socket_cookie test_cgroup_storage test_select_reuseport +test_flow_dissector +flow_dissector_load
tools/testing/selftests/bpf/Makefile +4 -2
@@ -47,10 +47,12 @@ TEST_PROGS := test_kmod.sh \ test_tunnel.sh \ test_lwt_seg6local.sh \ test_lirc_mode2.sh \ - test_skb_cgroup_id.sh + test_skb_cgroup_id.sh \ + test_flow_dissector.sh # Compile but not part of 'make run_tests' -TEST_GEN_PROGS_EXTENDED = test_libbpf_open test_sock_addr test_skb_cgroup_id_user +TEST_GEN_PROGS_EXTENDED = test_libbpf_open test_sock_addr test_skb_cgroup_id_user \ + flow_dissector_load test_flow_dissector include ../lib.mk
tools/testing/selftests/bpf/config +1 -0
@@ -18,3 +18,4 @@ CONFIG_CRYPTO_HMAC=m CONFIG_CRYPTO_SHA256=m CONFIG_VXLAN=y CONFIG_GENEVE=y +CONFIG_NET_CLS_FLOWER=m
tools/testing/selftests/bpf/flow_dissector_load.c new file +140 -0
140 lines not on this page · raw message
tools/testing/selftests/bpf/test_flow_dissector.c new file +782 -0
782 lines not on this page · raw message
tools/testing/selftests/bpf/test_flow_dissector.sh new file +115 -0
115 lines not on this page · raw message
tools/testing/selftests/bpf/with_addr.sh new file +54 -0
54 lines not on this page · raw message
tools/testing/selftests/bpf/with_tunnels.sh new file +36 -0
@@ -0,0 +1,36 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 +# +# setup tunnels for flow dissection test + +readonly SUFFIX="test_$(mktemp -u XXXX)" +CONFIG="remote 127.0.0.2 local 127.0.0.1 dev lo" + +setup() { + ip link add "ipip_${SUFFIX}" type ipip ${CONFIG} + ip link add "gre_${SUFFIX}" type gre ${CONFIG} + ip link add "sit_${SUFFIX}" type sit ${CONFIG} + + echo "tunnels before test:" + ip tunnel show + + ip link set "ipip_${SUFFIX}" up + ip link set "gre_${SUFFIX}" up + ip link set "sit_${SUFFIX}" up +} + + +cleanup() { + ip tunnel del "ipip_${SUFFIX}" + ip tunnel del "gre_${SUFFIX}" + ip tunnel del "sit_${SUFFIX}" + + echo "tunnels after test:" + ip tunnel show +} + +trap cleanup EXIT + +setup +"$@" +exit "$?"
Signature · 1 line
2.19.0.397.gdd90340f6a-goog
Quoted 24 lines · Petar Penkov
From: Petar Penkov <[email protected]>
This patch series hardens the RX stack by allowing flow dissection in BPF, as previously discussed [1]. Because of the rigorous checks of the BPF verifier, this provides significant security guarantees. In particular, the BPF flow dissector cannot get inside of an infinite loop, as with CVE-2013-4348, because BPF programs are guaranteed to terminate. It cannot read outside of packet bounds, because all memory accesses are checked. Also, with BPF the administrator can decide which protocols to support, reducing potential attack surface. Rarely encountered protocols can be excluded from dissection and the program can be updated without kernel recompile or reboot if a bug is discovered.
Patch 1 adds infrastructure to execute a BPF program in
__skb_flow_dissect. This includes a new BPF program and attach type.Patch 2 adds the new BPF flow dissector definitions to
tools/uapi.Patch 3 adds support for the new BPF program type to libbpf and bpftool.
Patch 4 adds a flow dissector program in BPF. This parses most protocols in
__skb_flow_dissectin BPF for a subset of flow keys (basic, control, ports, and address types).
Quoted 8 lines
Patch 5 adds a selftest that attaches the BPF program to the flow dissector and sends traffic with different levels of encapsulation.
Performance Evaluation:
The in-kernel implementation was compared against the demo program from patch 4 using the test in patch 5 with IPv4/UDP traffic over 10 seconds.$perf record -a -C 4 taskset -c 4 ./test_flow_dissector -i 4 -f 8 \ -t 10
Looks great. Applied to bpf-next with one extra patch:
SEC("dissect")
-int dissect(struct __sk_buff *skb)
+int _dissect(struct __sk_buff *skb)
otherwise the test doesn't build.
I'm not sure how it builds for you. Which llvm did you use?
Also above command works and ipv4 test in ./test_flow_dissector.sh is passing as well, but it still fails at the end for me:
./test_flow_dissector.sh
bpffs not mounted. Mounting...
0: IP
1: IPV6
2: IPV6OP
3: IPV6FR
4: MPLS
5: VLAN
Testing IPv4...
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=0
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
Testing IPIP...
tunnels before test:
tunl0: any/ip remote any local any ttl inherit nopmtudiscsit_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inheritipip_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
sit0: ipv6/ip remote any local any ttl 64 nopmtudiscgre_test_LV5N: gre/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
gre0: gre/ip remote any local any ttl inherit nopmtudisc inner.dest4: 192.168.0.1
inner.source4: 1.1.1.1
encap proto: 4
outer.dest4: 127.0.0.1
outer.source4: 127.0.0.2
pkts: tx=10 rx=0
tunnels after test:
tunl0: any/ip remote any local any ttl inherit nopmtudisc
sit0: ipv6/ip remote any local any ttl 64 nopmtudisc
gre0: gre/ip remote any local any ttl inherit nopmtudisc
selftests: test_flow_dissector [FAILED]
is it something in my setup or test is broken?
Quoted 40 lines · Alexei Starovoitov
Quoted 24 lines · Petar Penkov
From: Petar Penkov <[email protected]>
This patch series hardens the RX stack by allowing flow dissection in BPF, as previously discussed [1]. Because of the rigorous checks of the BPF verifier, this provides significant security guarantees. In particular, the BPF flow dissector cannot get inside of an infinite loop, as with CVE-2013-4348, because BPF programs are guaranteed to terminate. It cannot read outside of packet bounds, because all memory accesses are checked. Also, with BPF the administrator can decide which protocols to support, reducing potential attack surface. Rarely encountered protocols can be excluded from dissection and the program can be updated without kernel recompile or reboot if a bug is discovered.
Patch 1 adds infrastructure to execute a BPF program in
__skb_flow_dissect. This includes a new BPF program and attach type.Patch 2 adds the new BPF flow dissector definitions to
tools/uapi.Patch 3 adds support for the new BPF program type to libbpf and bpftool.
Patch 4 adds a flow dissector program in BPF. This parses most protocols in
__skb_flow_dissectin BPF for a subset of flow keys (basic, control, ports, and address types).Quoted 8 lines
Patch 5 adds a selftest that attaches the BPF program to the flow dissector and sends traffic with different levels of encapsulation.
Performance Evaluation:
The in-kernel implementation was compared against the demo program from patch 4 using the test in patch 5 with IPv4/UDP traffic over 10 seconds.$perf record -a -C 4 taskset -c 4 ./test_flow_dissector -i 4 -f 8 \ -t 10Looks great. Applied to bpf-next with one extra patch:
SEC("dissect")(quoted diff) +1
-1-int dissect(struct __sk_buff *skb) +int _dissect(struct __sk_buff *skb)
Quoted 2 lines
otherwise the test doesn't build.
I'm not sure how it builds for you. Which llvm did you use?
This is a known issue. IIRC, llvm <= 4 should be okay and llvm >= 5 would fail.
Quoted 43 lines
Also above command works and ipv4 test in ./test_flow_dissector.sh is passing as well, but it still fails at the end for me:
./test_flow_dissector.sh
bpffs not mounted. Mounting...
0: IP
1: IPV6
2: IPV6OP
3: IPV6FR
4: MPLS
5: VLAN
Testing IPv4...
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=0
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
Testing IPIP...
tunnels before test:
tunl0: any/ip remote any local any ttl inherit nopmtudiscsit_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inheritipip_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
sit0: ipv6/ip remote any local any ttl 64 nopmtudiscgre_test_LV5N: gre/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
gre0: gre/ip remote any local any ttl inherit nopmtudisc inner.dest4: 192.168.0.1
inner.source4: 1.1.1.1
encap proto: 4
outer.dest4: 127.0.0.1
outer.source4: 127.0.0.2
pkts: tx=10 rx=0
tunnels after test:
tunl0: any/ip remote any local any ttl inherit nopmtudisc
sit0: ipv6/ip remote any local any ttl 64 nopmtudisc
gre0: gre/ip remote any local any ttl inherit nopmtudisc
selftests:test_flow_dissector[FAILED]is it something in my setup or test is broken?
Quoted 42 lines · Y Song
Quoted 40 lines · Alexei Starovoitov
Quoted 24 lines · Petar Penkov
From: Petar Penkov <[email protected]>
This patch series hardens the RX stack by allowing flow dissection in BPF, as previously discussed [1]. Because of the rigorous checks of the BPF verifier, this provides significant security guarantees. In particular, the BPF flow dissector cannot get inside of an infinite loop, as with CVE-2013-4348, because BPF programs are guaranteed to terminate. It cannot read outside of packet bounds, because all memory accesses are checked. Also, with BPF the administrator can decide which protocols to support, reducing potential attack surface. Rarely encountered protocols can be excluded from dissection and the program can be updated without kernel recompile or reboot if a bug is discovered.
Patch 1 adds infrastructure to execute a BPF program in
__skb_flow_dissect. This includes a new BPF program and attach type.Patch 2 adds the new BPF flow dissector definitions to
tools/uapi.Patch 3 adds support for the new BPF program type to libbpf and bpftool.
Patch 4 adds a flow dissector program in BPF. This parses most protocols in
__skb_flow_dissectin BPF for a subset of flow keys (basic, control, ports, and address types).Quoted 8 lines
Patch 5 adds a selftest that attaches the BPF program to the flow dissector and sends traffic with different levels of encapsulation.
Performance Evaluation:
The in-kernel implementation was compared against the demo program from patch 4 using the test in patch 5 with IPv4/UDP traffic over 10 seconds.$perf record -a -C 4 taskset -c 4 ./test_flow_dissector -i 4 -f 8 \ -t 10Looks great. Applied to bpf-next with one extra patch:
SEC("dissect")(quoted diff) +1
-1-int dissect(struct __sk_buff *skb) +int _dissect(struct __sk_buff *skb)
Quoted 5 lines
Quoted 2 lines
otherwise the test doesn't build.
I'm not sure how it builds for you. Which llvm did you use?This is a known issue. IIRC, llvm <= 4 should be okay and llvm >= 5 would fail.
I was running a much older version of llvm so I imagine this was the issue. Thanks for the fix!
Quoted 41 lines
Quoted 41 lines
Also above command works and ipv4 test in ./test_flow_dissector.sh is passing as well, but it still fails at the end for me:
./test_flow_dissector.sh
bpffs not mounted. Mounting...
0: IP
1: IPV6
2: IPV6OP
3: IPV6FR
4: MPLS
5: VLAN
Testing IPv4...
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=0
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
Testing IPIP...
tunnels before test:
tunl0: any/ip remote any local any ttl inherit nopmtudiscsit_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inheritipip_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
sit0: ipv6/ip remote any local any ttl 64 nopmtudiscgre_test_LV5N: gre/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
gre0: gre/ip remote any local any ttl inherit nopmtudisc inner.dest4: 192.168.0.1
inner.source4: 1.1.1.1
encap proto: 4
outer.dest4: 127.0.0.1
outer.source4: 127.0.0.2
pkts: tx=10 rx=0
tunnels after test:
tunl0: any/ip remote any local any ttl inherit nopmtudisc
sit0: ipv6/ip remote any local any ttl 64 nopmtudisc
gre0: gre/ip remote any local any ttl inherit nopmtudisc
selftests:test_flow_dissector[FAILED]
Quoted 2 lines
Quoted 2 lines
is it something in my setup or test is broken?
I just reran the test and it is passing. We will investigate what could be causing the issue.
Quoted 92 lines · Petar Penkov
Quoted 42 lines · Y Song
Quoted 40 lines · Alexei Starovoitov
Quoted 24 lines · Petar Penkov
From: Petar Penkov <[email protected]>
This patch series hardens the RX stack by allowing flow dissection in BPF, as previously discussed [1]. Because of the rigorous checks of the BPF verifier, this provides significant security guarantees. In particular, the BPF flow dissector cannot get inside of an infinite loop, as with CVE-2013-4348, because BPF programs are guaranteed to terminate. It cannot read outside of packet bounds, because all memory accesses are checked. Also, with BPF the administrator can decide which protocols to support, reducing potential attack surface. Rarely encountered protocols can be excluded from dissection and the program can be updated without kernel recompile or reboot if a bug is discovered.
Patch 1 adds infrastructure to execute a BPF program in
__skb_flow_dissect. This includes a new BPF program and attach type.Patch 2 adds the new BPF flow dissector definitions to
tools/uapi.Patch 3 adds support for the new BPF program type to libbpf and bpftool.
Patch 4 adds a flow dissector program in BPF. This parses most protocols in
__skb_flow_dissectin BPF for a subset of flow keys (basic, control, ports, and address types).Quoted 8 lines
Patch 5 adds a selftest that attaches the BPF program to the flow dissector and sends traffic with different levels of encapsulation.
Performance Evaluation:
The in-kernel implementation was compared against the demo program from patch 4 using the test in patch 5 with IPv4/UDP traffic over 10 seconds.$perf record -a -C 4 taskset -c 4 ./test_flow_dissector -i 4 -f 8 \ -t 10Looks great. Applied to bpf-next with one extra patch:
SEC("dissect")(quoted diff) +1
-1-int dissect(struct __sk_buff *skb) +int _dissect(struct __sk_buff *skb)Quoted 5 lines
Quoted 2 lines
otherwise the test doesn't build.
I'm not sure how it builds for you. Which llvm did you use?This is a known issue. IIRC, llvm <= 4 should be okay and llvm >= 5 would fail.
I was running a much older version of llvm so I imagine this was the issue. Thanks for the fix!
Quoted 41 lines
Quoted 41 lines
Also above command works and ipv4 test in ./test_flow_dissector.sh is passing as well, but it still fails at the end for me:
./test_flow_dissector.sh
bpffs not mounted. Mounting...
0: IP
1: IPV6
2: IPV6OP
3: IPV6FR
4: MPLS
5: VLAN
Testing IPv4...
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=0
inner.dest4: 127.0.0.1
inner.source4: 127.0.0.3
pkts: tx=10 rx=10
Testing IPIP...
tunnels before test:
tunl0: any/ip remote any local any ttl inherit nopmtudiscsit_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inheritipip_test_LV5N: any/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
sit0: ipv6/ip remote any local any ttl 64 nopmtudiscgre_test_LV5N: gre/ip remote 127.0.0.2 local 127.0.0.1 dev lo ttl inherit
gre0: gre/ip remote any local any ttl inherit nopmtudisc inner.dest4: 192.168.0.1
inner.source4: 1.1.1.1
encap proto: 4
outer.dest4: 127.0.0.1
outer.source4: 127.0.0.2
pkts: tx=10 rx=0
tunnels after test:
tunl0: any/ip remote any local any ttl inherit nopmtudisc
sit0: ipv6/ip remote any local any ttl 64 nopmtudisc
gre0: gre/ip remote any local any ttl inherit nopmtudisc
selftests:test_flow_dissector[FAILED]
Quoted 4 lines
Quoted 2 lines
Quoted 2 lines
is it something in my setup or test is broken?
I just reran the test and it is passing. We will investigate what could be causing the issue.
I've tried, but I am still not able to reproduce this exact issue.
This may be due to how we split the compilation and execution
With
make defconfig &&
make kvmconfig &&
make kselftest-merge &&
make -j $N bzImage
and starting the result in qemu -kernel I miss a few built-ins. The test complains loudly if sch_ingress or ipip are missing. After updating to =y, the tests all pass for me.
The confounding part is that in the above output the test shows no error output and all tunnels are setup correctly.
For debugging purposes, I can update the script to run all tests instead of existing on the first failure and to output more state, including the address on the device and the state of the netns.