1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/types.h>
15#include <linux/stddef.h>
16#include <linux/kernel.h>
17#include <linux/fs.h>
18#include <linux/init.h>
19#include <net/sock.h>
20#include <linux/un.h>
21#include <net/af_unix.h>
22#include <linux/audit.h>
23#include <linux/ipv6.h>
24#include <linux/ip.h>
25#include <net/ip.h>
26#include <net/ipv6.h>
27#include <linux/tcp.h>
28#include <linux/udp.h>
29#include <linux/dccp.h>
30#include <linux/sctp.h>
31#include <linux/lsm_audit.h>
32
33
34
35
36
37
38
39
40
41int ipv4_skb_to_auditdata(struct sk_buff *skb,
42 struct common_audit_data *ad, u8 *proto)
43{
44 int ret = 0;
45 struct iphdr *ih;
46
47 ih = ip_hdr(skb);
48 if (ih == NULL)
49 return -EINVAL;
50
51 ad->u.net.v4info.saddr = ih->saddr;
52 ad->u.net.v4info.daddr = ih->daddr;
53
54 if (proto)
55 *proto = ih->protocol;
56
57 if (ntohs(ih->frag_off) & IP_OFFSET)
58 return 0;
59
60 switch (ih->protocol) {
61 case IPPROTO_TCP: {
62 struct tcphdr *th = tcp_hdr(skb);
63 if (th == NULL)
64 break;
65
66 ad->u.net.sport = th->source;
67 ad->u.net.dport = th->dest;
68 break;
69 }
70 case IPPROTO_UDP: {
71 struct udphdr *uh = udp_hdr(skb);
72 if (uh == NULL)
73 break;
74
75 ad->u.net.sport = uh->source;
76 ad->u.net.dport = uh->dest;
77 break;
78 }
79 case IPPROTO_DCCP: {
80 struct dccp_hdr *dh = dccp_hdr(skb);
81 if (dh == NULL)
82 break;
83
84 ad->u.net.sport = dh->dccph_sport;
85 ad->u.net.dport = dh->dccph_dport;
86 break;
87 }
88 case IPPROTO_SCTP: {
89 struct sctphdr *sh = sctp_hdr(skb);
90 if (sh == NULL)
91 break;
92 ad->u.net.sport = sh->source;
93 ad->u.net.dport = sh->dest;
94 break;
95 }
96 default:
97 ret = -EINVAL;
98 }
99 return ret;
100}
101#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
102
103
104
105
106
107
108
109
110int ipv6_skb_to_auditdata(struct sk_buff *skb,
111 struct common_audit_data *ad, u8 *proto)
112{
113 int offset, ret = 0;
114 struct ipv6hdr *ip6;
115 u8 nexthdr;
116
117 ip6 = ipv6_hdr(skb);
118 if (ip6 == NULL)
119 return -EINVAL;
120 ipv6_addr_copy(&ad->u.net.v6info.saddr, &ip6->saddr);
121 ipv6_addr_copy(&ad->u.net.v6info.daddr, &ip6->daddr);
122 ret = 0;
123
124
125 offset = skb_network_offset(skb);
126 offset += sizeof(*ip6);
127 nexthdr = ip6->nexthdr;
128 offset = ipv6_skip_exthdr(skb, offset, &nexthdr);
129 if (offset < 0)
130 return 0;
131 if (proto)
132 *proto = nexthdr;
133 switch (nexthdr) {
134 case IPPROTO_TCP: {
135 struct tcphdr _tcph, *th;
136
137 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
138 if (th == NULL)
139 break;
140
141 ad->u.net.sport = th->source;
142 ad->u.net.dport = th->dest;
143 break;
144 }
145 case IPPROTO_UDP: {
146 struct udphdr _udph, *uh;
147
148 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
149 if (uh == NULL)
150 break;
151
152 ad->u.net.sport = uh->source;
153 ad->u.net.dport = uh->dest;
154 break;
155 }
156 case IPPROTO_DCCP: {
157 struct dccp_hdr _dccph, *dh;
158
159 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
160 if (dh == NULL)
161 break;
162
163 ad->u.net.sport = dh->dccph_sport;
164 ad->u.net.dport = dh->dccph_dport;
165 break;
166 }
167 case IPPROTO_SCTP: {
168 struct sctphdr _sctph, *sh;
169
170 sh = skb_header_pointer(skb, offset, sizeof(_sctph), &_sctph);
171 if (sh == NULL)
172 break;
173 ad->u.net.sport = sh->source;
174 ad->u.net.dport = sh->dest;
175 break;
176 }
177 default:
178 ret = -EINVAL;
179 }
180 return ret;
181}
182#endif
183
184
185static inline void print_ipv6_addr(struct audit_buffer *ab,
186 struct in6_addr *addr, __be16 port,
187 char *name1, char *name2)
188{
189 if (!ipv6_addr_any(addr))
190 audit_log_format(ab, " %s=%pI6c", name1, addr);
191 if (port)
192 audit_log_format(ab, " %s=%d", name2, ntohs(port));
193}
194
195static inline void print_ipv4_addr(struct audit_buffer *ab, __be32 addr,
196 __be16 port, char *name1, char *name2)
197{
198 if (addr)
199 audit_log_format(ab, " %s=%pI4", name1, &addr);
200 if (port)
201 audit_log_format(ab, " %s=%d", name2, ntohs(port));
202}
203
204
205
206
207
208
209static void dump_common_audit_data(struct audit_buffer *ab,
210 struct common_audit_data *a)
211{
212 struct inode *inode = NULL;
213 struct task_struct *tsk = current;
214
215 if (a->tsk)
216 tsk = a->tsk;
217 if (tsk && tsk->pid) {
218 audit_log_format(ab, " pid=%d comm=", tsk->pid);
219 audit_log_untrustedstring(ab, tsk->comm);
220 }
221
222 switch (a->type) {
223 case LSM_AUDIT_NO_AUDIT:
224 return;
225 case LSM_AUDIT_DATA_IPC:
226 audit_log_format(ab, " key=%d ", a->u.ipc_id);
227 break;
228 case LSM_AUDIT_DATA_CAP:
229 audit_log_format(ab, " capability=%d ", a->u.cap);
230 break;
231 case LSM_AUDIT_DATA_FS:
232 if (a->u.fs.path.dentry) {
233 struct dentry *dentry = a->u.fs.path.dentry;
234 if (a->u.fs.path.mnt) {
235 audit_log_d_path(ab, "path=", &a->u.fs.path);
236 } else {
237 audit_log_format(ab, " name=");
238 audit_log_untrustedstring(ab,
239 dentry->d_name.name);
240 }
241 inode = dentry->d_inode;
242 } else if (a->u.fs.inode) {
243 struct dentry *dentry;
244 inode = a->u.fs.inode;
245 dentry = d_find_alias(inode);
246 if (dentry) {
247 audit_log_format(ab, " name=");
248 audit_log_untrustedstring(ab,
249 dentry->d_name.name);
250 dput(dentry);
251 }
252 }
253 if (inode)
254 audit_log_format(ab, " dev=%s ino=%lu",
255 inode->i_sb->s_id,
256 inode->i_ino);
257 break;
258 case LSM_AUDIT_DATA_TASK:
259 tsk = a->u.tsk;
260 if (tsk && tsk->pid) {
261 audit_log_format(ab, " pid=%d comm=", tsk->pid);
262 audit_log_untrustedstring(ab, tsk->comm);
263 }
264 break;
265 case LSM_AUDIT_DATA_NET:
266 if (a->u.net.sk) {
267 struct sock *sk = a->u.net.sk;
268 struct unix_sock *u;
269 int len = 0;
270 char *p = NULL;
271
272 switch (sk->sk_family) {
273 case AF_INET: {
274 struct inet_sock *inet = inet_sk(sk);
275
276 print_ipv4_addr(ab, inet->rcv_saddr,
277 inet->sport,
278 "laddr", "lport");
279 print_ipv4_addr(ab, inet->daddr,
280 inet->dport,
281 "faddr", "fport");
282 break;
283 }
284 case AF_INET6: {
285 struct inet_sock *inet = inet_sk(sk);
286 struct ipv6_pinfo *inet6 = inet6_sk(sk);
287
288 print_ipv6_addr(ab, &inet6->rcv_saddr,
289 inet->sport,
290 "laddr", "lport");
291 print_ipv6_addr(ab, &inet6->daddr,
292 inet->dport,
293 "faddr", "fport");
294 break;
295 }
296 case AF_UNIX:
297 u = unix_sk(sk);
298 if (u->dentry) {
299 struct path path = {
300 .dentry = u->dentry,
301 .mnt = u->mnt
302 };
303 audit_log_d_path(ab, "path=", &path);
304 break;
305 }
306 if (!u->addr)
307 break;
308 len = u->addr->len-sizeof(short);
309 p = &u->addr->name->sun_path[0];
310 audit_log_format(ab, " path=");
311 if (*p)
312 audit_log_untrustedstring(ab, p);
313 else
314 audit_log_n_hex(ab, p, len);
315 break;
316 }
317 }
318
319 switch (a->u.net.family) {
320 case AF_INET:
321 print_ipv4_addr(ab, a->u.net.v4info.saddr,
322 a->u.net.sport,
323 "saddr", "src");
324 print_ipv4_addr(ab, a->u.net.v4info.daddr,
325 a->u.net.dport,
326 "daddr", "dest");
327 break;
328 case AF_INET6:
329 print_ipv6_addr(ab, &a->u.net.v6info.saddr,
330 a->u.net.sport,
331 "saddr", "src");
332 print_ipv6_addr(ab, &a->u.net.v6info.daddr,
333 a->u.net.dport,
334 "daddr", "dest");
335 break;
336 }
337 if (a->u.net.netif > 0) {
338 struct net_device *dev;
339
340
341 dev = dev_get_by_index(&init_net, a->u.net.netif);
342 if (dev) {
343 audit_log_format(ab, " netif=%s", dev->name);
344 dev_put(dev);
345 }
346 }
347 break;
348#ifdef CONFIG_KEYS
349 case LSM_AUDIT_DATA_KEY:
350 audit_log_format(ab, " key_serial=%u", a->u.key_struct.key);
351 if (a->u.key_struct.key_desc) {
352 audit_log_format(ab, " key_desc=");
353 audit_log_untrustedstring(ab, a->u.key_struct.key_desc);
354 }
355 break;
356#endif
357 }
358}
359
360
361
362
363
364
365
366
367void common_lsm_audit(struct common_audit_data *a)
368{
369 struct audit_buffer *ab;
370
371 if (a == NULL)
372 return;
373
374 ab = audit_log_start(current->audit_context, GFP_ATOMIC, AUDIT_AVC);
375
376 if (ab == NULL)
377 return;
378
379 if (a->lsm_pre_audit)
380 a->lsm_pre_audit(ab, a);
381
382 dump_common_audit_data(ab, a);
383
384 if (a->lsm_post_audit)
385 a->lsm_post_audit(ab, a);
386
387 audit_log_end(ab);
388}
389
