From: Rongguang Wei TUNATTACHFILTER copies only the sock_fprog header, so tun->fprog.filter points into the address space of the process that issued the ioctl, and tun_attach() reads it again whenever a queue is attached to a persistent device. That read can fail, and with the inverted check below the failure was not fatal either: the queue was attached without a filter, while a successful read returned early and left the queue unpublished. Keep the program on the device instead: TUNATTACHFILTER builds it once with bpf_prog_create_from_user() and stores it in tun->cbpf_prog, and tun_net_xmit() runs it from there. A per-queue flag records whether the queue was attached with IFF_NOFILTER, so a queue attached later does not depend on the caller's buffer at all. The inverted check was discovered by manual code inspection first. Fixes: 54f968d6efdb ("tuntap: move socket to tun_file") Suggested-by: Alexei Starovoitov Signed-off-by: Rongguang Wei --- drivers/net/tun.c | 93 ++++++++++++++++++++++------------------------- 1 file changed, 43 insertions(+), 50 deletions(-) diff --git a/drivers/net/tun.c b/drivers/net/tun.c index 86fd44e107550..b599a8932f027 100644 --- a/drivers/net/tun.c +++ b/drivers/net/tun.c @@ -135,6 +135,7 @@ struct tun_file { struct fasync_struct *fasync; /* only used for fasnyc */ unsigned int flags; + bool nofilter; /* attached with IFF_NOFILTER */ union { u16 queue_index; unsigned int ifindex; @@ -176,8 +177,8 @@ struct tun_prog { }; /* Since the socket were moved to tun_file, to preserve the behavior of persist - * device, socket filter, sndbuf and vnet header size were restore when the - * file were attached to a persist device. + * device, sndbuf and vnet header size were restore when the file were attached + * to a persist device. */ struct tun_struct { struct tun_file __rcu *tfiles[MAX_TAP_QUEUES]; @@ -196,9 +197,7 @@ struct tun_struct { int vnet_hdr_sz; int sndbuf; struct tap_filter txflt; - struct sock_fprog fprog; - /* protected by rtnl lock */ - bool filter_attached; + struct sock_fprog fprog; /* header, for TUNGETFILTER */ u32 msg_enable; spinlock_t lock; struct hlist_head flows[TUN_NUM_FLOW_ENTRIES]; @@ -213,6 +212,7 @@ struct tun_struct { struct bpf_prog __rcu *xdp_prog; struct tun_prog __rcu *steering_prog; struct tun_prog __rcu *filter_prog; + struct tun_prog __rcu *cbpf_prog; /* from TUNATTACHFILTER */ struct ethtool_link_ksettings link_ksettings; /* init args */ struct file *file; @@ -731,7 +731,7 @@ static void tun_force_wake_queue(struct tun_struct *tun, } static int tun_attach(struct tun_struct *tun, struct file *file, - bool skip_filter, bool napi, bool napi_frags, + bool nofilter, bool napi, bool napi_frags, bool publish_tun) { struct tun_file *tfile = file->private_data; @@ -757,15 +757,6 @@ static int tun_attach(struct tun_struct *tun, struct file *file, err = 0; - /* Re-attach the filter to persist device */ - if (!skip_filter && (tun->filter_attached == true)) { - lock_sock(tfile->socket.sk); - err = sk_attach_filter(&tun->fprog, tfile->socket.sk); - release_sock(tfile->socket.sk); - if (!err) - goto out; - } - if (!tfile->detached && ptr_ring_resize(&tfile->tx_ring, dev->tx_queue_len, GFP_KERNEL, tun_ptr_free)) { @@ -819,6 +810,7 @@ static int tun_attach(struct tun_struct *tun, struct file *file, * initialized tfile; otherwise we risk using half-initialized * object. */ + WRITE_ONCE(tfile->nofilter, nofilter); if (publish_tun) rcu_assign_pointer(tfile->tun, tun); rcu_assign_pointer(tun->tfiles[tun->numqueues], tfile); @@ -1071,6 +1063,7 @@ static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev) int txq = skb->queue_mapping; struct netdev_queue *queue; struct tun_file *tfile; + struct tun_prog *prog; int len = skb->len; int ret; @@ -1096,10 +1089,20 @@ static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev) goto drop; } - if (tfile->socket.sk->sk_filter) { - drop_reason = sk_filter_reason(tfile->socket.sk, skb); - if (drop_reason) + /* Classic filter set with TUNATTACHFILTER. A queue attached with + * IFF_NOFILTER does not run it. + */ + prog = rcu_dereference(tun->cbpf_prog); + if (prog && !READ_ONCE(tfile->nofilter)) { + /* A filter returning 0 drops the packet, any other value is + * the length to keep. pskb_trim() does nothing when that + * length is larger than the skb. + */ + len = bpf_prog_run_clear_cb(prog->prog, skb); + if (!len || pskb_trim(skb, len)) { + drop_reason = SKB_DROP_REASON_SOCKET_FILTER; goto drop; + } } len = run_ebpf_filter(tun, skb, len); @@ -2417,6 +2420,7 @@ static void tun_free_netdev(struct net_device *dev) security_tun_dev_free_security(tun->security); __tun_set_ebpf(tun, &tun->steering_prog, NULL); __tun_set_ebpf(tun, &tun->filter_prog, NULL); + __tun_set_ebpf(tun, &tun->cbpf_prog, NULL); } static void tun_setup(struct net_device *dev) @@ -2975,7 +2979,6 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr) tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr); tun->align = NET_SKB_PAD; - tun->filter_attached = false; tun->sndbuf = tfile->socket.sk->sk_sndbuf; tun->rx_batched = 0; RCU_INIT_POINTER(tun->steering_prog, NULL); @@ -3079,39 +3082,34 @@ static int set_offload(struct tun_struct *tun, unsigned long arg) return 0; } -static void tun_detach_filter(struct tun_struct *tun, int n) +static int tun_attach_filter(struct tun_struct *tun, void __user *data) { - int i; + struct sock_fprog fprog; struct tun_file *tfile; + struct bpf_prog *prog; + int i, ret; - for (i = 0; i < n; i++) { - tfile = rtnl_dereference(tun->tfiles[i]); - lock_sock(tfile->socket.sk); - sk_detach_filter(tfile->socket.sk); - release_sock(tfile->socket.sk); - } + if (copy_from_user(&fprog, data, sizeof(fprog))) + return -EFAULT; - tun->filter_attached = false; -} + ret = bpf_prog_create_from_user(&prog, &fprog, NULL, false); + if (ret) + return ret; -static int tun_attach_filter(struct tun_struct *tun) -{ - int i, ret = 0; - struct tun_file *tfile; + ret = __tun_set_ebpf(tun, &tun->cbpf_prog, prog); + if (ret) { + bpf_prog_destroy(prog); + return ret; + } for (i = 0; i < tun->numqueues; i++) { tfile = rtnl_dereference(tun->tfiles[i]); - lock_sock(tfile->socket.sk); - ret = sk_attach_filter(&tun->fprog, tfile->socket.sk); - release_sock(tfile->socket.sk); - if (ret) { - tun_detach_filter(tun, i); - return ret; - } + WRITE_ONCE(tfile->nofilter, false); } - tun->filter_attached = true; - return ret; + /* Only TUNGETFILTER reads it */ + tun->fprog = fprog; + return 0; } static void tun_set_sndbuf(struct tun_struct *tun) @@ -3307,7 +3305,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd, if (tfile->detached) ifr.ifr_flags |= IFF_DETACH_QUEUE; - if (!tfile->socket.sk->sk_filter) + if (tfile->nofilter || !rcu_access_pointer(tun->cbpf_prog)) ifr.ifr_flags |= IFF_NOFILTER; if (copy_to_user(argp, &ifr, ifreq_len)) @@ -3454,11 +3452,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd, ret = -EINVAL; if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP) break; - ret = -EFAULT; - if (copy_from_user(&tun->fprog, argp, sizeof(tun->fprog))) - break; - - ret = tun_attach_filter(tun); + ret = tun_attach_filter(tun, argp); break; case TUNDETACHFILTER: @@ -3466,8 +3460,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd, ret = -EINVAL; if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP) break; - ret = 0; - tun_detach_filter(tun, tun->numqueues); + ret = __tun_set_ebpf(tun, &tun->cbpf_prog, NULL); break; case TUNGETFILTER: -- 2.43.0 No virus found Checked by Hillstone Network AntiVirus From: Rongguang Wei Add tests for TUNATTACHFILTER and TUNDETACHFILTER: a queue re-attached after the buffer the program came from was made unreadable, a bad program and a bad length with queues attached and with none, a program configured before any queue, and the IFF_NOFILTER paths. Signed-off-by: Rongguang Wei --- tools/testing/selftests/net/tun.c | 358 ++++++++++++++++++++++++++++++ 1 file changed, 358 insertions(+) diff --git a/tools/testing/selftests/net/tun.c b/tools/testing/selftests/net/tun.c index 34de2580e32ec..ac326193867b0 100644 --- a/tools/testing/selftests/net/tun.c +++ b/tools/testing/selftests/net/tun.c @@ -9,9 +9,11 @@ #include #include #include +#include #include #include #include +#include #include #include "kselftest_harness.h" @@ -548,6 +550,362 @@ TEST_F(tun, reattach_close_delete) EXPECT_EQ(tun_delete(self->ifname), 0); } +/* accept: return skb->len. Three instructions on purpose, so that the + * length read back through TUNGETFILTER tells it apart from a rejected + * program that is shorter. + */ +static const struct sock_filter filter_accept[] = { + BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0), + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0), + BPF_STMT(BPF_RET | BPF_A, 0), +}; + +/* Put the instructions in an anonymous mapping, so that the test can make the + * address unreadable afterwards. + */ +static void *filter_alloc(const struct sock_filter *insns, unsigned int len) +{ + void *p; + + p = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if (p == MAP_FAILED) + return NULL; + + memcpy(p, insns, len * sizeof(*insns)); + + return p; +} + +static int filter_attach(int fd, const struct sock_filter *insns, unsigned int len) +{ + struct sock_fprog fp = { + .len = len, + .filter = (struct sock_filter *)insns, + }; + + return ioctl(fd, TUNATTACHFILTER, (void *)&fp); +} + +static int filter_get(int fd, struct sock_fprog *fp) +{ + return ioctl(fd, TUNGETFILTER, (void *)fp); +} + +static int tun_get_iff_flags(int fd) +{ + struct ifreq ifr = { 0 }; + + if (ioctl(fd, TUNGETIFF, (void *)&ifr) < 0) + return -1; + + return ifr.ifr_flags; +} + +/* + * The program is built when TUNATTACHFILTER is issued, so a queue attached + * later does not read the buffer it came from. Here the mapping is made + * unreadable before the queue is attached again, and another queue is then + * attached from a fresh socket, which starts without a filter of its own. + */ +TEST_F(tun, reattach_filter_without_user_buffer) +{ + struct sock_fprog gf = { 0 }; + struct ifreq ifr = { 0 }; + short flags = 0; + void *prog; + int fd, ret; + + prog = filter_alloc(filter_accept, ARRAY_SIZE(filter_accept)); + ASSERT_NE(prog, NULL); + ASSERT_EQ(filter_attach(self->fd, prog, ARRAY_SIZE(filter_accept)), 0); + + EXPECT_EQ(tun_detach(self->fd, self->ifname), 0); + + /* This memory is no longer readable */ + ASSERT_EQ(mprotect(prog, getpagesize(), PROT_NONE), 0); + + ret = tun_attach(self->fd, self->ifname); + EXPECT_EQ(ret, 0); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + /* The queue is attached again, not left disabled */ + EXPECT_EQ(flags & IFF_DETACH_QUEUE, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + /* The two checks below document the expected state, they cannot + * tell an installed filter from no filter: tun_detach() leaves the + * device program alone, and TUNGETFILTER only returns the header. + */ + EXPECT_EQ(filter_get(self->fd, &gf), 0); + EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept)); + + /* A new queue starts without a filter, so a clear IFF_NOFILTER shows + * that the filter configured on the device covers it as well. + */ + fd = open("/dev/net/tun", O_RDWR); + ASSERT_GE(fd, 0); + + strcpy(ifr.ifr_name, self->ifname); + ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE; + EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0); + + flags = tun_get_iff_flags(fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + close(fd); + + ASSERT_EQ(mprotect(prog, getpagesize(), PROT_READ | PROT_WRITE), 0); + ASSERT_EQ(munmap(prog, getpagesize()), 0); +} + +/* A new queue attached with IFF_NOFILTER must not get the filter that is + * configured on the device. + */ +TEST_F(tun, attach_filter_nofilter_flag) +{ + struct ifreq ifr = { 0 }; + short flags = 0; + int fd; + + ASSERT_EQ(filter_attach(self->fd, filter_accept, ARRAY_SIZE(filter_accept)), 0); + + fd = open("/dev/net/tun", O_RDWR); + ASSERT_GE(fd, 0); + + strcpy(ifr.ifr_name, self->ifname); + ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE | IFF_NOFILTER; + EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0); + + flags = tun_get_iff_flags(fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER); + + close(fd); +} + +/* A later TUNATTACHFILTER covers every queue of the device, including one that + * was attached with IFF_NOFILTER. + */ +TEST_F(tun, attach_filter_clears_nofilter_queue) +{ + struct ifreq ifr = { 0 }; + short flags = 0; + int fd; + + fd = open("/dev/net/tun", O_RDWR); + ASSERT_GE(fd, 0); + + strcpy(ifr.ifr_name, self->ifname); + ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE | IFF_NOFILTER; + ASSERT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0); + + flags = tun_get_iff_flags(fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER); + + ASSERT_EQ(filter_attach(self->fd, filter_accept, + ARRAY_SIZE(filter_accept)), 0); + + flags = tun_get_iff_flags(fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + close(fd); +} + +/* After TUNDETACHFILTER a later attach must not install the filter again */ +TEST_F(tun, detach_filter_clears_reattach) +{ + short flags = 0; + + ASSERT_EQ(filter_attach(self->fd, filter_accept, ARRAY_SIZE(filter_accept)), 0); + EXPECT_EQ(ioctl(self->fd, TUNDETACHFILTER, 0), 0); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER); + + EXPECT_EQ(tun_detach(self->fd, self->ifname), 0); + EXPECT_EQ(tun_attach(self->fd, self->ifname), 0); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER); +} + +/* TUNDETACHFILTER must clear the filter of a queue that was detached with + * IFF_DETACH_QUEUE as well, not only that of the active queues. + */ +TEST_F(tun, detach_filter_clears_detached_queue) +{ + short flags = 0; + + ASSERT_EQ(filter_attach(self->fd, filter_accept, + ARRAY_SIZE(filter_accept)), 0); + + EXPECT_EQ(tun_detach(self->fd, self->ifname), 0); + EXPECT_EQ(ioctl(self->fd, TUNDETACHFILTER, 0), 0); + EXPECT_EQ(tun_attach(self->fd, self->ifname), 0); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER); +} + +/* A TUNATTACHFILTER with a bad length must leave the installed program and the + * filter state that TUNGETIFF reports alone. + */ +TEST_F(tun, attach_filter_bad_len_keeps_program) +{ + struct sock_fprog gf = { 0 }; + struct ifreq ifr = { 0 }; + short flags = 0; + int fd; + + ASSERT_EQ(filter_attach(self->fd, filter_accept, ARRAY_SIZE(filter_accept)), 0); + + errno = 0; + EXPECT_EQ(filter_attach(self->fd, filter_accept, 0), -1); + EXPECT_EQ(errno, EINVAL); + + EXPECT_EQ(filter_get(self->fd, &gf), 0); + EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept)); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + /* A queue attached afterwards still gets the filter, so the rejected + * ioctl left the program on the device alone. + */ + fd = open("/dev/net/tun", O_RDWR); + ASSERT_GE(fd, 0); + + strcpy(ifr.ifr_name, self->ifname); + ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE; + EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0); + + flags = tun_get_iff_flags(fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + close(fd); +} + +/* A TUNATTACHFILTER with instructions that bpf_check_classic() rejects must + * be refused, and must leave the program that is installed in place. + */ +TEST_F(tun, attach_filter_bad_prog_keeps_program) +{ + struct sock_fprog gf = { 0 }; + struct sock_filter bad[] = { + BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0), + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), + }; + struct ifreq ifr = { 0 }; + short flags = 0; + int fd; + + ASSERT_EQ(filter_attach(self->fd, filter_accept, + ARRAY_SIZE(filter_accept)), 0); + + errno = 0; + EXPECT_EQ(filter_attach(self->fd, bad, ARRAY_SIZE(bad)), -1); + EXPECT_EQ(errno, EINVAL); + + /* the program attached before is untouched */ + EXPECT_EQ(filter_get(self->fd, &gf), 0); + EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept)); + + /* IFF_NOFILTER comes from the program kept on the device, not from + * the saved header, so a clear flag shows the filter is still there. + */ + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + /* A queue attached afterwards still gets the filter, so the rejected + * program never replaced the one on the device. + */ + fd = open("/dev/net/tun", O_RDWR); + ASSERT_GE(fd, 0); + + strcpy(ifr.ifr_name, self->ifname); + ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE; + EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0); + + flags = tun_get_iff_flags(fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); + + close(fd); +} + +/* The program is built by TUNATTACHFILTER itself, so a bad one has to be + * refused even when there is no queue attached. A program that is only + * refused when it is built would otherwise be saved and break every later + * attach. Detach all queues, check that a bad length and a bad program are + * still refused, and that a re-attached queue gets the program installed + * before. + */ +TEST_F(tun, attach_filter_bad_keeps_program_without_queues) +{ + struct sock_fprog gf = { 0 }; + struct sock_filter bad[] = { + BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0), + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0), + }; + short flags = 0; + + ASSERT_EQ(filter_attach(self->fd, filter_accept, + ARRAY_SIZE(filter_accept)), 0); + + EXPECT_EQ(tun_detach(self->fd, self->ifname), 0); + EXPECT_EQ(tun_detach(self->fd2, self->ifname), 0); + + errno = 0; + EXPECT_EQ(filter_attach(self->fd, filter_accept, 0), -1); + EXPECT_EQ(errno, EINVAL); + + errno = 0; + EXPECT_EQ(filter_attach(self->fd, bad, ARRAY_SIZE(bad)), -1); + EXPECT_EQ(errno, EINVAL); + + /* The rejected ioctls did not replace the program on the device */ + EXPECT_EQ(filter_get(self->fd, &gf), 0); + EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept)); + + /* The queue gets that program again, from the device */ + EXPECT_EQ(tun_attach(self->fd, self->ifname), 0); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); +} + +/* A program configured while no queue is attached must cover the queues that + * are attached afterwards. + */ +TEST_F(tun, attach_filter_without_queues_then_attach) +{ + short flags = 0; + + EXPECT_EQ(tun_detach(self->fd, self->ifname), 0); + EXPECT_EQ(tun_detach(self->fd2, self->ifname), 0); + + ASSERT_EQ(filter_attach(self->fd, filter_accept, + ARRAY_SIZE(filter_accept)), 0); + + EXPECT_EQ(tun_attach(self->fd, self->ifname), 0); + + flags = tun_get_iff_flags(self->fd); + EXPECT_GE(flags, 0); + EXPECT_EQ(flags & IFF_NOFILTER, 0); +} + FIXTURE(tun_vnet_gso) { char ifname[IFNAMSIZ]; -- 2.43.0 No virus found Checked by Hillstone Network AntiVirus