1/* SPDX-License-Identifier: GPL-2.0 */
  2// Copyright (c) 2018 Covalent IO, Inc. http://covalent.io
  3
  4#include <stddef.h>
  5#include <stdbool.h>
  6#include <string.h>
  7#include <linux/bpf.h>
  8#include <linux/if_ether.h>
  9#include <linux/in.h>
 10#include <linux/ip.h>
 11#include <linux/ipv6.h>
 12#include <linux/pkt_cls.h>
 13#include <linux/tcp.h>
 14#include <sys/socket.h>
 15#include <bpf/bpf_helpers.h>
 16#include <bpf/bpf_endian.h>
 17
 
 18char _license[] SEC("license") = "GPL";
 19
 20/* Fill 'tuple' with L3 info, and attempt to find L4. On fail, return NULL. */
 21static struct bpf_sock_tuple *get_tuple(void *data, __u64 nh_off,
 22					void *data_end, __u16 eth_proto,
 23					bool *ipv4)
 24{
 25	struct bpf_sock_tuple *result;
 26	__u64 ihl_len = 0;
 27	__u8 proto = 0;
 
 28
 29	if (eth_proto == bpf_htons(ETH_P_IP)) {
 30		struct iphdr *iph = (struct iphdr *)(data + nh_off);
 31
 32		if (iph + 1 > data_end)
 33			return NULL;
 34		ihl_len = iph->ihl * 4;
 35		proto = iph->protocol;
 36		*ipv4 = true;
 37		result = (struct bpf_sock_tuple *)&iph->saddr;
 38	} else if (eth_proto == bpf_htons(ETH_P_IPV6)) {
 39		struct ipv6hdr *ip6h = (struct ipv6hdr *)(data + nh_off);
 40
 41		if (ip6h + 1 > data_end)
 42			return NULL;
 43		ihl_len = sizeof(*ip6h);
 44		proto = ip6h->nexthdr;
 45		*ipv4 = true;
 46		result = (struct bpf_sock_tuple *)&ip6h->saddr;
 47	}
 48
 49	if (data + nh_off + ihl_len > data_end || proto != IPPROTO_TCP)
 50		return NULL;
 51
 52	return result;
 53}
 54
 55SEC("?tc")
 56int sk_lookup_success(struct __sk_buff *skb)
 57{
 58	void *data_end = (void *)(long)skb->data_end;
 59	void *data = (void *)(long)skb->data;
 60	struct ethhdr *eth = (struct ethhdr *)(data);
 61	struct bpf_sock_tuple *tuple;
 62	struct bpf_sock *sk;
 63	size_t tuple_len;
 64	bool ipv4;
 65
 66	if (eth + 1 > data_end)
 67		return TC_ACT_SHOT;
 68
 69	tuple = get_tuple(data, sizeof(*eth), data_end, eth->h_proto, &ipv4);
 70	if (!tuple || tuple + sizeof *tuple > data_end)
 71		return TC_ACT_SHOT;
 72
 73	tuple_len = ipv4 ? sizeof(tuple->ipv4) : sizeof(tuple->ipv6);
 74	sk = bpf_sk_lookup_tcp(skb, tuple, tuple_len, BPF_F_CURRENT_NETNS, 0);
 75	bpf_printk("sk=%d\n", sk ? 1 : 0);
 76	if (sk)
 77		bpf_sk_release(sk);
 78	return sk ? TC_ACT_OK : TC_ACT_UNSPEC;
 79}
 80
 81SEC("?tc")
 82int sk_lookup_success_simple(struct __sk_buff *skb)
 83{
 84	struct bpf_sock_tuple tuple = {};
 85	struct bpf_sock *sk;
 86
 87	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
 88	if (sk)
 89		bpf_sk_release(sk);
 90	return 0;
 91}
 92
 93SEC("?tc")
 94int err_use_after_free(struct __sk_buff *skb)
 95{
 96	struct bpf_sock_tuple tuple = {};
 97	struct bpf_sock *sk;
 98	__u32 family = 0;
 99
100	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
101	if (sk) {
102		bpf_sk_release(sk);
103		family = sk->family;
104	}
105	return family;
106}
107
108SEC("?tc")
109int err_modify_sk_pointer(struct __sk_buff *skb)
110{
111	struct bpf_sock_tuple tuple = {};
112	struct bpf_sock *sk;
 
113
114	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
115	if (sk) {
116		sk += 1;
117		bpf_sk_release(sk);
118	}
119	return 0;
120}
121
122SEC("?tc")
123int err_modify_sk_or_null_pointer(struct __sk_buff *skb)
124{
125	struct bpf_sock_tuple tuple = {};
126	struct bpf_sock *sk;
 
127
128	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
129	sk += 1;
130	if (sk)
131		bpf_sk_release(sk);
132	return 0;
133}
134
135SEC("?tc")
136int err_no_release(struct __sk_buff *skb)
137{
138	struct bpf_sock_tuple tuple = {};
139
140	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
141	return 0;
142}
143
144SEC("?tc")
145int err_release_twice(struct __sk_buff *skb)
146{
147	struct bpf_sock_tuple tuple = {};
148	struct bpf_sock *sk;
149
150	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
151	bpf_sk_release(sk);
152	bpf_sk_release(sk);
153	return 0;
154}
155
156SEC("?tc")
157int err_release_unchecked(struct __sk_buff *skb)
158{
159	struct bpf_sock_tuple tuple = {};
160	struct bpf_sock *sk;
161
162	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
163	bpf_sk_release(sk);
164	return 0;
165}
166
167void lookup_no_release(struct __sk_buff *skb)
168{
169	struct bpf_sock_tuple tuple = {};
170	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
171}
172
173SEC("?tc")
174int err_no_release_subcall(struct __sk_buff *skb)
175{
176	lookup_no_release(skb);
177	return 0;
178}

  1/* SPDX-License-Identifier: GPL-2.0 */
  2// Copyright (c) 2018 Covalent IO, Inc. http://covalent.io
  3
  4#include <stddef.h>
  5#include <stdbool.h>
  6#include <string.h>
  7#include <linux/bpf.h>
  8#include <linux/if_ether.h>
  9#include <linux/in.h>
 10#include <linux/ip.h>
 11#include <linux/ipv6.h>
 12#include <linux/pkt_cls.h>
 13#include <linux/tcp.h>
 14#include <sys/socket.h>
 15#include <bpf/bpf_helpers.h>
 16#include <bpf/bpf_endian.h>
 17
 18int _version SEC("version") = 1;
 19char _license[] SEC("license") = "GPL";
 20
 21/* Fill 'tuple' with L3 info, and attempt to find L4. On fail, return NULL. */
 22static struct bpf_sock_tuple *get_tuple(void *data, __u64 nh_off,
 23					void *data_end, __u16 eth_proto,
 24					bool *ipv4)
 25{
 26	struct bpf_sock_tuple *result;
 
 27	__u8 proto = 0;
 28	__u64 ihl_len;
 29
 30	if (eth_proto == bpf_htons(ETH_P_IP)) {
 31		struct iphdr *iph = (struct iphdr *)(data + nh_off);
 32
 33		if (iph + 1 > data_end)
 34			return NULL;
 35		ihl_len = iph->ihl * 4;
 36		proto = iph->protocol;
 37		*ipv4 = true;
 38		result = (struct bpf_sock_tuple *)&iph->saddr;
 39	} else if (eth_proto == bpf_htons(ETH_P_IPV6)) {
 40		struct ipv6hdr *ip6h = (struct ipv6hdr *)(data + nh_off);
 41
 42		if (ip6h + 1 > data_end)
 43			return NULL;
 44		ihl_len = sizeof(*ip6h);
 45		proto = ip6h->nexthdr;
 46		*ipv4 = true;
 47		result = (struct bpf_sock_tuple *)&ip6h->saddr;
 48	}
 49
 50	if (data + nh_off + ihl_len > data_end || proto != IPPROTO_TCP)
 51		return NULL;
 52
 53	return result;
 54}
 55
 56SEC("classifier/sk_lookup_success")
 57int bpf_sk_lookup_test0(struct __sk_buff *skb)
 58{
 59	void *data_end = (void *)(long)skb->data_end;
 60	void *data = (void *)(long)skb->data;
 61	struct ethhdr *eth = (struct ethhdr *)(data);
 62	struct bpf_sock_tuple *tuple;
 63	struct bpf_sock *sk;
 64	size_t tuple_len;
 65	bool ipv4;
 66
 67	if (eth + 1 > data_end)
 68		return TC_ACT_SHOT;
 69
 70	tuple = get_tuple(data, sizeof(*eth), data_end, eth->h_proto, &ipv4);
 71	if (!tuple || tuple + sizeof *tuple > data_end)
 72		return TC_ACT_SHOT;
 73
 74	tuple_len = ipv4 ? sizeof(tuple->ipv4) : sizeof(tuple->ipv6);
 75	sk = bpf_sk_lookup_tcp(skb, tuple, tuple_len, BPF_F_CURRENT_NETNS, 0);
 76	bpf_printk("sk=%d\n", sk ? 1 : 0);
 77	if (sk)
 78		bpf_sk_release(sk);
 79	return sk ? TC_ACT_OK : TC_ACT_UNSPEC;
 80}
 81
 82SEC("classifier/sk_lookup_success_simple")
 83int bpf_sk_lookup_test1(struct __sk_buff *skb)
 84{
 85	struct bpf_sock_tuple tuple = {};
 86	struct bpf_sock *sk;
 87
 88	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
 89	if (sk)
 90		bpf_sk_release(sk);
 91	return 0;
 92}
 93
 94SEC("classifier/fail_use_after_free")
 95int bpf_sk_lookup_uaf(struct __sk_buff *skb)
 96{
 97	struct bpf_sock_tuple tuple = {};
 98	struct bpf_sock *sk;
 99	__u32 family = 0;
100
101	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
102	if (sk) {
103		bpf_sk_release(sk);
104		family = sk->family;
105	}
106	return family;
107}
108
109SEC("classifier/fail_modify_sk_pointer")
110int bpf_sk_lookup_modptr(struct __sk_buff *skb)
111{
112	struct bpf_sock_tuple tuple = {};
113	struct bpf_sock *sk;
114	__u32 family;
115
116	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
117	if (sk) {
118		sk += 1;
119		bpf_sk_release(sk);
120	}
121	return 0;
122}
123
124SEC("classifier/fail_modify_sk_or_null_pointer")
125int bpf_sk_lookup_modptr_or_null(struct __sk_buff *skb)
126{
127	struct bpf_sock_tuple tuple = {};
128	struct bpf_sock *sk;
129	__u32 family;
130
131	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
132	sk += 1;
133	if (sk)
134		bpf_sk_release(sk);
135	return 0;
136}
137
138SEC("classifier/fail_no_release")
139int bpf_sk_lookup_test2(struct __sk_buff *skb)
140{
141	struct bpf_sock_tuple tuple = {};
142
143	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
144	return 0;
145}
146
147SEC("classifier/fail_release_twice")
148int bpf_sk_lookup_test3(struct __sk_buff *skb)
149{
150	struct bpf_sock_tuple tuple = {};
151	struct bpf_sock *sk;
152
153	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
154	bpf_sk_release(sk);
155	bpf_sk_release(sk);
156	return 0;
157}
158
159SEC("classifier/fail_release_unchecked")
160int bpf_sk_lookup_test4(struct __sk_buff *skb)
161{
162	struct bpf_sock_tuple tuple = {};
163	struct bpf_sock *sk;
164
165	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
166	bpf_sk_release(sk);
167	return 0;
168}
169
170void lookup_no_release(struct __sk_buff *skb)
171{
172	struct bpf_sock_tuple tuple = {};
173	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
174}
175
176SEC("classifier/fail_no_release_subcall")
177int bpf_sk_lookup_test5(struct __sk_buff *skb)
178{
179	lookup_no_release(skb);
180	return 0;
181}