Branch data Line data Source code
1 : : /*
2 : : * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
3 : : *
4 : : * This program is free software; you can redistribute it and/or modify
5 : : * it under the terms of the GNU General Public License as published by
6 : : * the Free Software Foundation, version 2.
7 : : *
8 : : * Author:
9 : : * Casey Schaufler <casey@schaufler-ca.com>
10 : : *
11 : : */
12 : :
13 : : #ifndef _SECURITY_SMACK_H
14 : : #define _SECURITY_SMACK_H
15 : :
16 : : #include <linux/capability.h>
17 : : #include <linux/spinlock.h>
18 : : #include <linux/security.h>
19 : : #include <linux/in.h>
20 : : #include <net/netlabel.h>
21 : : #include <linux/list.h>
22 : : #include <linux/rculist.h>
23 : : #include <linux/lsm_audit.h>
24 : :
25 : : /*
26 : : * Smack labels were limited to 23 characters for a long time.
27 : : */
28 : : #define SMK_LABELLEN 24
29 : : #define SMK_LONGLABEL 256
30 : :
31 : : /*
32 : : * This is the repository for labels seen so that it is
33 : : * not necessary to keep allocating tiny chuncks of memory
34 : : * and so that they can be shared.
35 : : *
36 : : * Labels are never modified in place. Anytime a label
37 : : * is imported (e.g. xattrset on a file) the list is checked
38 : : * for it and it is added if it doesn't exist. The address
39 : : * is passed out in either case. Entries are added, but
40 : : * never deleted.
41 : : *
42 : : * Since labels are hanging around anyway it doesn't
43 : : * hurt to maintain a secid for those awkward situations
44 : : * where kernel components that ought to use LSM independent
45 : : * interfaces don't. The secid should go away when all of
46 : : * these components have been repaired.
47 : : *
48 : : * The cipso value associated with the label gets stored here, too.
49 : : *
50 : : * Keep the access rules for this subject label here so that
51 : : * the entire set of rules does not need to be examined every
52 : : * time.
53 : : */
54 : : struct smack_known {
55 : : struct list_head list;
56 : : struct hlist_node smk_hashed;
57 : : char *smk_known;
58 : : u32 smk_secid;
59 : : struct netlbl_lsm_secattr smk_netlabel; /* on wire labels */
60 : : struct list_head smk_rules; /* access rules */
61 : : struct mutex smk_rules_lock; /* lock for rules */
62 : : };
63 : :
64 : : /*
65 : : * Maximum number of bytes for the levels in a CIPSO IP option.
66 : : * Why 23? CIPSO is constrained to 30, so a 32 byte buffer is
67 : : * bigger than can be used, and 24 is the next lower multiple
68 : : * of 8, and there are too many issues if there isn't space set
69 : : * aside for the terminating null byte.
70 : : */
71 : : #define SMK_CIPSOLEN 24
72 : :
73 : : struct superblock_smack {
74 : : char *smk_root;
75 : : char *smk_floor;
76 : : char *smk_hat;
77 : : char *smk_default;
78 : : int smk_initialized;
79 : : };
80 : :
81 : : struct socket_smack {
82 : : struct smack_known *smk_out; /* outbound label */
83 : : char *smk_in; /* inbound label */
84 : : char *smk_packet; /* TCP peer label */
85 : : };
86 : :
87 : : /*
88 : : * Inode smack data
89 : : */
90 : : struct inode_smack {
91 : : char *smk_inode; /* label of the fso */
92 : : struct smack_known *smk_task; /* label of the task */
93 : : struct smack_known *smk_mmap; /* label of the mmap domain */
94 : : struct mutex smk_lock; /* initialization lock */
95 : : int smk_flags; /* smack inode flags */
96 : : };
97 : :
98 : : struct task_smack {
99 : : struct smack_known *smk_task; /* label for access control */
100 : : struct smack_known *smk_forked; /* label when forked */
101 : : struct list_head smk_rules; /* per task access rules */
102 : : struct mutex smk_rules_lock; /* lock for the rules */
103 : : };
104 : :
105 : : #define SMK_INODE_INSTANT 0x01 /* inode is instantiated */
106 : : #define SMK_INODE_TRANSMUTE 0x02 /* directory is transmuting */
107 : : #define SMK_INODE_CHANGED 0x04 /* smack was transmuted */
108 : :
109 : : /*
110 : : * A label access rule.
111 : : */
112 : : struct smack_rule {
113 : : struct list_head list;
114 : : struct smack_known *smk_subject;
115 : : char *smk_object;
116 : : int smk_access;
117 : : };
118 : :
119 : : /*
120 : : * An entry in the table identifying hosts.
121 : : */
122 : : struct smk_netlbladdr {
123 : : struct list_head list;
124 : : struct sockaddr_in smk_host; /* network address */
125 : : struct in_addr smk_mask; /* network mask */
126 : : char *smk_label; /* label */
127 : : };
128 : :
129 : : /*
130 : : * An entry in the table identifying ports.
131 : : */
132 : : struct smk_port_label {
133 : : struct list_head list;
134 : : struct sock *smk_sock; /* socket initialized on */
135 : : unsigned short smk_port; /* the port number */
136 : : char *smk_in; /* incoming label */
137 : : struct smack_known *smk_out; /* outgoing label */
138 : : };
139 : :
140 : : /*
141 : : * Mount options
142 : : */
143 : : #define SMK_FSDEFAULT "smackfsdef="
144 : : #define SMK_FSFLOOR "smackfsfloor="
145 : : #define SMK_FSHAT "smackfshat="
146 : : #define SMK_FSROOT "smackfsroot="
147 : : #define SMK_FSTRANS "smackfstransmute="
148 : :
149 : : #define SMACK_CIPSO_OPTION "-CIPSO"
150 : :
151 : : /*
152 : : * How communications on this socket are treated.
153 : : * Usually it's determined by the underlying netlabel code
154 : : * but there are certain cases, including single label hosts
155 : : * and potentially single label interfaces for which the
156 : : * treatment can not be known in advance.
157 : : *
158 : : * The possibility of additional labeling schemes being
159 : : * introduced in the future exists as well.
160 : : */
161 : : #define SMACK_UNLABELED_SOCKET 0
162 : : #define SMACK_CIPSO_SOCKET 1
163 : :
164 : : /*
165 : : * CIPSO defaults.
166 : : */
167 : : #define SMACK_CIPSO_DOI_DEFAULT 3 /* Historical */
168 : : #define SMACK_CIPSO_DOI_INVALID -1 /* Not a DOI */
169 : : #define SMACK_CIPSO_DIRECT_DEFAULT 250 /* Arbitrary */
170 : : #define SMACK_CIPSO_MAPPED_DEFAULT 251 /* Also arbitrary */
171 : : #define SMACK_CIPSO_MAXLEVEL 255 /* CIPSO 2.2 standard */
172 : : /*
173 : : * CIPSO 2.2 standard is 239, but Smack wants to use the
174 : : * categories in a structured way that limits the value to
175 : : * the bits in 23 bytes, hence the unusual number.
176 : : */
177 : : #define SMACK_CIPSO_MAXCATNUM 184 /* 23 * 8 */
178 : :
179 : : /*
180 : : * Flags for untraditional access modes.
181 : : * It shouldn't be necessary to avoid conflicts with definitions
182 : : * in fs.h, but do so anyway.
183 : : */
184 : : #define MAY_TRANSMUTE 0x00001000 /* Controls directory labeling */
185 : : #define MAY_LOCK 0x00002000 /* Locks should be writes, but ... */
186 : :
187 : : /*
188 : : * Just to make the common cases easier to deal with
189 : : */
190 : : #define MAY_ANYREAD (MAY_READ | MAY_EXEC)
191 : : #define MAY_READWRITE (MAY_READ | MAY_WRITE)
192 : : #define MAY_NOT 0
193 : :
194 : : /*
195 : : * Number of access types used by Smack (rwxatl)
196 : : */
197 : : #define SMK_NUM_ACCESS_TYPE 6
198 : :
199 : : /* SMACK data */
200 : : struct smack_audit_data {
201 : : const char *function;
202 : : char *subject;
203 : : char *object;
204 : : char *request;
205 : : int result;
206 : : };
207 : :
208 : : /*
209 : : * Smack audit data; is empty if CONFIG_AUDIT not set
210 : : * to save some stack
211 : : */
212 : : struct smk_audit_info {
213 : : #ifdef CONFIG_AUDIT
214 : : struct common_audit_data a;
215 : : struct smack_audit_data sad;
216 : : #endif
217 : : };
218 : : /*
219 : : * These functions are in smack_lsm.c
220 : : */
221 : : struct inode_smack *new_inode_smack(char *);
222 : :
223 : : /*
224 : : * These functions are in smack_access.c
225 : : */
226 : : int smk_access_entry(char *, char *, struct list_head *);
227 : : int smk_access(struct smack_known *, char *, int, struct smk_audit_info *);
228 : : int smk_curacc(char *, u32, struct smk_audit_info *);
229 : : struct smack_known *smack_from_secid(const u32);
230 : : char *smk_parse_smack(const char *string, int len);
231 : : int smk_netlbl_mls(int, char *, struct netlbl_lsm_secattr *, int);
232 : : char *smk_import(const char *, int);
233 : : struct smack_known *smk_import_entry(const char *, int);
234 : : void smk_insert_entry(struct smack_known *skp);
235 : : struct smack_known *smk_find_entry(const char *);
236 : : u32 smack_to_secid(const char *);
237 : :
238 : : /*
239 : : * Shared data.
240 : : */
241 : : extern int smack_cipso_direct;
242 : : extern int smack_cipso_mapped;
243 : : extern struct smack_known *smack_net_ambient;
244 : : extern struct smack_known *smack_onlycap;
245 : : extern struct smack_known *smack_syslog_label;
246 : : extern const char *smack_cipso_option;
247 : :
248 : : extern struct smack_known smack_known_floor;
249 : : extern struct smack_known smack_known_hat;
250 : : extern struct smack_known smack_known_huh;
251 : : extern struct smack_known smack_known_invalid;
252 : : extern struct smack_known smack_known_star;
253 : : extern struct smack_known smack_known_web;
254 : :
255 : : extern struct mutex smack_known_lock;
256 : : extern struct list_head smack_known_list;
257 : : extern struct list_head smk_netlbladdr_list;
258 : :
259 : : extern struct security_operations smack_ops;
260 : :
261 : : #define SMACK_HASH_SLOTS 16
262 : : extern struct hlist_head smack_known_hash[SMACK_HASH_SLOTS];
263 : :
264 : : /*
265 : : * Is the directory transmuting?
266 : : */
267 : : static inline int smk_inode_transmutable(const struct inode *isp)
268 : : {
269 : : struct inode_smack *sip = isp->i_security;
270 : 0 : return (sip->smk_flags & SMK_INODE_TRANSMUTE) != 0;
271 : : }
272 : :
273 : : /*
274 : : * Present a pointer to the smack label in an inode blob.
275 : : */
276 : : static inline char *smk_of_inode(const struct inode *isp)
277 : : {
278 : : struct inode_smack *sip = isp->i_security;
279 : 0 : return sip->smk_inode;
280 : : }
281 : :
282 : : /*
283 : : * Present a pointer to the smack label entry in an task blob.
284 : : */
285 : : static inline struct smack_known *smk_of_task(const struct task_smack *tsp)
286 : : {
287 : : return tsp->smk_task;
288 : : }
289 : :
290 : : /*
291 : : * Present a pointer to the forked smack label entry in an task blob.
292 : : */
293 : : static inline struct smack_known *smk_of_forked(const struct task_smack *tsp)
294 : : {
295 : : return tsp->smk_forked;
296 : : }
297 : :
298 : : /*
299 : : * Present a pointer to the smack label in the current task blob.
300 : : */
301 : : static inline struct smack_known *smk_of_current(void)
302 : : {
303 : 0 : return smk_of_task(current_security());
304 : : }
305 : :
306 : : /*
307 : : * Is the task privileged and allowed to be privileged
308 : : * by the onlycap rule.
309 : : */
310 : : static inline int smack_privileged(int cap)
311 : : {
312 : : struct smack_known *skp = smk_of_current();
313 : :
314 [ # # ][ # # ]: 0 : if (!capable(cap))
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
[ # # # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
315 : : return 0;
316 [ # # ][ # # ]: 0 : if (smack_onlycap == NULL || smack_onlycap == skp)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
317 : : return 1;
318 : : return 0;
319 : : }
320 : :
321 : : /*
322 : : * logging functions
323 : : */
324 : : #define SMACK_AUDIT_DENIED 0x1
325 : : #define SMACK_AUDIT_ACCEPT 0x2
326 : : extern int log_policy;
327 : :
328 : : void smack_log(char *subject_label, char *object_label,
329 : : int request,
330 : : int result, struct smk_audit_info *auditdata);
331 : :
332 : : #ifdef CONFIG_AUDIT
333 : :
334 : : /*
335 : : * some inline functions to set up audit data
336 : : * they do nothing if CONFIG_AUDIT is not set
337 : : *
338 : : */
339 : : static inline void smk_ad_init(struct smk_audit_info *a, const char *func,
340 : : char type)
341 : : {
342 : 0 : memset(&a->sad, 0, sizeof(a->sad));
343 : 0 : a->a.type = type;
344 : 0 : a->a.smack_audit_data = &a->sad;
345 : 0 : a->a.smack_audit_data->function = func;
346 : : }
347 : :
348 : : static inline void smk_ad_init_net(struct smk_audit_info *a, const char *func,
349 : : char type, struct lsm_network_audit *net)
350 : : {
351 : : smk_ad_init(a, func, type);
352 : 0 : memset(net, 0, sizeof(*net));
353 : 0 : a->a.u.net = net;
354 : : }
355 : :
356 : : static inline void smk_ad_setfield_u_tsk(struct smk_audit_info *a,
357 : : struct task_struct *t)
358 : : {
359 : 0 : a->a.u.tsk = t;
360 : : }
361 : : static inline void smk_ad_setfield_u_fs_path_dentry(struct smk_audit_info *a,
362 : : struct dentry *d)
363 : : {
364 : 0 : a->a.u.dentry = d;
365 : : }
366 : : static inline void smk_ad_setfield_u_fs_inode(struct smk_audit_info *a,
367 : : struct inode *i)
368 : : {
369 : 0 : a->a.u.inode = i;
370 : : }
371 : : static inline void smk_ad_setfield_u_fs_path(struct smk_audit_info *a,
372 : : struct path p)
373 : : {
374 : 0 : a->a.u.path = p;
375 : : }
376 : : static inline void smk_ad_setfield_u_net_sk(struct smk_audit_info *a,
377 : : struct sock *sk)
378 : : {
379 : 0 : a->a.u.net->sk = sk;
380 : : }
381 : :
382 : : #else /* no AUDIT */
383 : :
384 : : static inline void smk_ad_init(struct smk_audit_info *a, const char *func,
385 : : char type)
386 : : {
387 : : }
388 : : static inline void smk_ad_setfield_u_tsk(struct smk_audit_info *a,
389 : : struct task_struct *t)
390 : : {
391 : : }
392 : : static inline void smk_ad_setfield_u_fs_path_dentry(struct smk_audit_info *a,
393 : : struct dentry *d)
394 : : {
395 : : }
396 : : static inline void smk_ad_setfield_u_fs_path_mnt(struct smk_audit_info *a,
397 : : struct vfsmount *m)
398 : : {
399 : : }
400 : : static inline void smk_ad_setfield_u_fs_inode(struct smk_audit_info *a,
401 : : struct inode *i)
402 : : {
403 : : }
404 : : static inline void smk_ad_setfield_u_fs_path(struct smk_audit_info *a,
405 : : struct path p)
406 : : {
407 : : }
408 : : static inline void smk_ad_setfield_u_net_sk(struct smk_audit_info *a,
409 : : struct sock *sk)
410 : : {
411 : : }
412 : : #endif
413 : :
414 : : #endif /* _SECURITY_SMACK_H */
|
