1
2
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_helpers.h"
16#include "bpf_endian.h"
17
18int _version SEC("version") = 1;
19char _license[] SEC("license") = "GPL";
20
21
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("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 if (sk)
77 bpf_sk_release(sk);
78 return sk ? TC_ACT_OK : TC_ACT_UNSPEC;
79}
80
81SEC("sk_lookup_success_simple")
82int 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
93SEC("fail_use_after_free")
94int 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
108SEC("fail_modify_sk_pointer")
109int 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
123SEC("fail_modify_sk_or_null_pointer")
124int 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
137SEC("fail_no_release")
138int 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
146SEC("fail_release_twice")
147int 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
158SEC("fail_release_unchecked")
159int 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
169void 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
175SEC("fail_no_release_subcall")
176int bpf_sk_lookup_test5(struct __sk_buff *skb)
177{
178 lookup_no_release(skb);
179 return 0;
180}
181
