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 
18 int _version SEC("version") = 1;
19 char _license[] SEC("license") = "GPL";
20 
21 /* Fill 'tuple' with L3 info, and attempt to find L4. On fail, return NULL. */
22 static 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 
56 SEC("classifier/sk_lookup_success")
57 int 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 	if (sk)
77 		bpf_sk_release(sk);
78 	return sk ? TC_ACT_OK : TC_ACT_UNSPEC;
79 }
80 
81 SEC("classifier/sk_lookup_success_simple")
82 int bpf_sk_lookup_test1(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 
93 SEC("classifier/fail_use_after_free")
94 int bpf_sk_lookup_uaf(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 
108 SEC("classifier/fail_modify_sk_pointer")
109 int bpf_sk_lookup_modptr(struct __sk_buff *skb)
110 {
111 	struct bpf_sock_tuple tuple = {};
112 	struct bpf_sock *sk;
113 	__u32 family;
114 
115 	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
116 	if (sk) {
117 		sk += 1;
118 		bpf_sk_release(sk);
119 	}
120 	return 0;
121 }
122 
123 SEC("classifier/fail_modify_sk_or_null_pointer")
124 int bpf_sk_lookup_modptr_or_null(struct __sk_buff *skb)
125 {
126 	struct bpf_sock_tuple tuple = {};
127 	struct bpf_sock *sk;
128 	__u32 family;
129 
130 	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
131 	sk += 1;
132 	if (sk)
133 		bpf_sk_release(sk);
134 	return 0;
135 }
136 
137 SEC("classifier/fail_no_release")
138 int bpf_sk_lookup_test2(struct __sk_buff *skb)
139 {
140 	struct bpf_sock_tuple tuple = {};
141 
142 	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
143 	return 0;
144 }
145 
146 SEC("classifier/fail_release_twice")
147 int bpf_sk_lookup_test3(struct __sk_buff *skb)
148 {
149 	struct bpf_sock_tuple tuple = {};
150 	struct bpf_sock *sk;
151 
152 	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
153 	bpf_sk_release(sk);
154 	bpf_sk_release(sk);
155 	return 0;
156 }
157 
158 SEC("classifier/fail_release_unchecked")
159 int bpf_sk_lookup_test4(struct __sk_buff *skb)
160 {
161 	struct bpf_sock_tuple tuple = {};
162 	struct bpf_sock *sk;
163 
164 	sk = bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
165 	bpf_sk_release(sk);
166 	return 0;
167 }
168 
169 void lookup_no_release(struct __sk_buff *skb)
170 {
171 	struct bpf_sock_tuple tuple = {};
172 	bpf_sk_lookup_tcp(skb, &tuple, sizeof(tuple), BPF_F_CURRENT_NETNS, 0);
173 }
174 
175 SEC("classifier/fail_no_release_subcall")
176 int bpf_sk_lookup_test5(struct __sk_buff *skb)
177 {
178 	lookup_no_release(skb);
179 	return 0;
180 }
181