Branch data Line data Source code
1 : : /*
2 : : * Security plug functions
3 : : *
4 : : * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
5 : : * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
6 : : * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
7 : : *
8 : : * This program is free software; you can redistribute it and/or modify
9 : : * it under the terms of the GNU General Public License as published by
10 : : * the Free Software Foundation; either version 2 of the License, or
11 : : * (at your option) any later version.
12 : : */
13 : :
14 : : #include <linux/capability.h>
15 : : #include <linux/dcache.h>
16 : : #include <linux/module.h>
17 : : #include <linux/init.h>
18 : : #include <linux/kernel.h>
19 : : #include <linux/security.h>
20 : : #include <linux/integrity.h>
21 : : #include <linux/ima.h>
22 : : #include <linux/evm.h>
23 : : #include <linux/fsnotify.h>
24 : : #include <linux/mman.h>
25 : : #include <linux/mount.h>
26 : : #include <linux/personality.h>
27 : : #include <linux/backing-dev.h>
28 : : #include <net/flow.h>
29 : :
30 : : #define MAX_LSM_EVM_XATTR 2
31 : :
32 : : /* Boot-time LSM user choice */
33 : : static __initdata char chosen_lsm[SECURITY_NAME_MAX + 1] =
34 : : CONFIG_DEFAULT_SECURITY;
35 : :
36 : : static struct security_operations *security_ops;
37 : : static struct security_operations default_security_ops = {
38 : : .name = "default",
39 : : };
40 : :
41 : : static inline int __init verify(struct security_operations *ops)
42 : : {
43 : : /* verify the security_operations structure exists */
44 [ # # ]: 0 : if (!ops)
45 : : return -EINVAL;
46 : 0 : security_fixup_ops(ops);
47 : : return 0;
48 : : }
49 : :
50 : 0 : static void __init do_security_initcalls(void)
51 : : {
52 : : initcall_t *call;
53 : : call = __security_initcall_start;
54 [ # # ]: 0 : while (call < __security_initcall_end) {
55 : 0 : (*call) ();
56 : 0 : call++;
57 : : }
58 : 0 : }
59 : :
60 : : /**
61 : : * security_init - initializes the security framework
62 : : *
63 : : * This should be called early in the kernel initialization sequence.
64 : : */
65 : 0 : int __init security_init(void)
66 : : {
67 : 0 : printk(KERN_INFO "Security Framework initialized\n");
68 : :
69 : 0 : security_fixup_ops(&default_security_ops);
70 : 0 : security_ops = &default_security_ops;
71 : 0 : do_security_initcalls();
72 : :
73 : 0 : return 0;
74 : : }
75 : :
76 : 0 : void reset_security_ops(void)
77 : : {
78 : 0 : security_ops = &default_security_ops;
79 : 0 : }
80 : :
81 : : /* Save user chosen LSM */
82 : 0 : static int __init choose_lsm(char *str)
83 : : {
84 : 0 : strncpy(chosen_lsm, str, SECURITY_NAME_MAX);
85 : 0 : return 1;
86 : : }
87 : : __setup("security=", choose_lsm);
88 : :
89 : : /**
90 : : * security_module_enable - Load given security module on boot ?
91 : : * @ops: a pointer to the struct security_operations that is to be checked.
92 : : *
93 : : * Each LSM must pass this method before registering its own operations
94 : : * to avoid security registration races. This method may also be used
95 : : * to check if your LSM is currently loaded during kernel initialization.
96 : : *
97 : : * Return true if:
98 : : * -The passed LSM is the one chosen by user at boot time,
99 : : * -or the passed LSM is configured as the default and the user did not
100 : : * choose an alternate LSM at boot time.
101 : : * Otherwise, return false.
102 : : */
103 : 0 : int __init security_module_enable(struct security_operations *ops)
104 : : {
105 : 0 : return !strcmp(ops->name, chosen_lsm);
106 : : }
107 : :
108 : : /**
109 : : * register_security - registers a security framework with the kernel
110 : : * @ops: a pointer to the struct security_options that is to be registered
111 : : *
112 : : * This function allows a security module to register itself with the
113 : : * kernel security subsystem. Some rudimentary checking is done on the @ops
114 : : * value passed to this function. You'll need to check first if your LSM
115 : : * is allowed to register its @ops by calling security_module_enable(@ops).
116 : : *
117 : : * If there is already a security module registered with the kernel,
118 : : * an error will be returned. Otherwise %0 is returned on success.
119 : : */
120 : 0 : int __init register_security(struct security_operations *ops)
121 : : {
122 [ # # ]: 0 : if (verify(ops)) {
123 : 0 : printk(KERN_DEBUG "%s could not verify "
124 : : "security_operations structure.\n", __func__);
125 : 0 : return -EINVAL;
126 : : }
127 : :
128 [ # # ]: 0 : if (security_ops != &default_security_ops)
129 : : return -EAGAIN;
130 : :
131 : 0 : security_ops = ops;
132 : :
133 : 0 : return 0;
134 : : }
135 : :
136 : : /* Security operations */
137 : :
138 : 0 : int security_binder_set_context_mgr(struct task_struct *mgr)
139 : : {
140 : 0 : return security_ops->binder_set_context_mgr(mgr);
141 : : }
142 : :
143 : 0 : int security_binder_transaction(struct task_struct *from, struct task_struct *to)
144 : : {
145 : 0 : return security_ops->binder_transaction(from, to);
146 : : }
147 : :
148 : 0 : int security_binder_transfer_binder(struct task_struct *from, struct task_struct *to)
149 : : {
150 : 0 : return security_ops->binder_transfer_binder(from, to);
151 : : }
152 : :
153 : 0 : int security_binder_transfer_file(struct task_struct *from, struct task_struct *to, struct file *file)
154 : : {
155 : 0 : return security_ops->binder_transfer_file(from, to, file);
156 : : }
157 : :
158 : 0 : int security_ptrace_access_check(struct task_struct *child, unsigned int mode)
159 : : {
160 : : #ifdef CONFIG_SECURITY_YAMA_STACKED
161 : : int rc;
162 : : rc = yama_ptrace_access_check(child, mode);
163 : : if (rc)
164 : : return rc;
165 : : #endif
166 : 89758 : return security_ops->ptrace_access_check(child, mode);
167 : : }
168 : :
169 : 0 : int security_ptrace_traceme(struct task_struct *parent)
170 : : {
171 : : #ifdef CONFIG_SECURITY_YAMA_STACKED
172 : : int rc;
173 : : rc = yama_ptrace_traceme(parent);
174 : : if (rc)
175 : : return rc;
176 : : #endif
177 : 102 : return security_ops->ptrace_traceme(parent);
178 : : }
179 : :
180 : 0 : int security_capget(struct task_struct *target,
181 : : kernel_cap_t *effective,
182 : : kernel_cap_t *inheritable,
183 : : kernel_cap_t *permitted)
184 : : {
185 : 4 : return security_ops->capget(target, effective, inheritable, permitted);
186 : : }
187 : :
188 : 0 : int security_capset(struct cred *new, const struct cred *old,
189 : : const kernel_cap_t *effective,
190 : : const kernel_cap_t *inheritable,
191 : : const kernel_cap_t *permitted)
192 : : {
193 : 1 : return security_ops->capset(new, old,
194 : : effective, inheritable, permitted);
195 : : }
196 : :
197 : 0 : int security_capable(const struct cred *cred, struct user_namespace *ns,
198 : : int cap)
199 : : {
200 : 84532 : return security_ops->capable(cred, ns, cap, SECURITY_CAP_AUDIT);
201 : : }
202 : :
203 : 0 : int security_capable_noaudit(const struct cred *cred, struct user_namespace *ns,
204 : : int cap)
205 : : {
206 : 75556 : return security_ops->capable(cred, ns, cap, SECURITY_CAP_NOAUDIT);
207 : : }
208 : :
209 : 0 : int security_quotactl(int cmds, int type, int id, struct super_block *sb)
210 : : {
211 : 0 : return security_ops->quotactl(cmds, type, id, sb);
212 : : }
213 : :
214 : 0 : int security_quota_on(struct dentry *dentry)
215 : : {
216 : 0 : return security_ops->quota_on(dentry);
217 : : }
218 : :
219 : 0 : int security_syslog(int type)
220 : : {
221 : 1624 : return security_ops->syslog(type);
222 : : }
223 : :
224 : 0 : int security_settime(const struct timespec *ts, const struct timezone *tz)
225 : : {
226 : 13 : return security_ops->settime(ts, tz);
227 : : }
228 : :
229 : 0 : int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
230 : : {
231 : 15624412 : return security_ops->vm_enough_memory(mm, pages);
232 : : }
233 : :
234 : 0 : int security_bprm_set_creds(struct linux_binprm *bprm)
235 : : {
236 : 27604 : return security_ops->bprm_set_creds(bprm);
237 : : }
238 : :
239 : 0 : int security_bprm_check(struct linux_binprm *bprm)
240 : : {
241 : : int ret;
242 : :
243 : 27606 : ret = security_ops->bprm_check_security(bprm);
244 [ - + ]: 27605 : if (ret)
245 : 0 : return ret;
246 : : return ima_bprm_check(bprm);
247 : : }
248 : :
249 : 0 : void security_bprm_committing_creds(struct linux_binprm *bprm)
250 : : {
251 : 27246 : security_ops->bprm_committing_creds(bprm);
252 : 27246 : }
253 : :
254 : 0 : void security_bprm_committed_creds(struct linux_binprm *bprm)
255 : : {
256 : 27246 : security_ops->bprm_committed_creds(bprm);
257 : 27246 : }
258 : :
259 : 0 : int security_bprm_secureexec(struct linux_binprm *bprm)
260 : : {
261 : 27246 : return security_ops->bprm_secureexec(bprm);
262 : : }
263 : :
264 : 0 : int security_sb_alloc(struct super_block *sb)
265 : : {
266 : 28 : return security_ops->sb_alloc_security(sb);
267 : : }
268 : :
269 : 0 : void security_sb_free(struct super_block *sb)
270 : : {
271 : 28 : security_ops->sb_free_security(sb);
272 : 28 : }
273 : :
274 : 0 : int security_sb_copy_data(char *orig, char *copy)
275 : : {
276 : 5 : return security_ops->sb_copy_data(orig, copy);
277 : : }
278 : : EXPORT_SYMBOL(security_sb_copy_data);
279 : :
280 : 0 : int security_sb_remount(struct super_block *sb, void *data)
281 : : {
282 : 8 : return security_ops->sb_remount(sb, data);
283 : : }
284 : :
285 : 0 : int security_sb_kern_mount(struct super_block *sb, int flags, void *data)
286 : : {
287 : 29 : return security_ops->sb_kern_mount(sb, flags, data);
288 : : }
289 : :
290 : 0 : int security_sb_show_options(struct seq_file *m, struct super_block *sb)
291 : : {
292 : 605 : return security_ops->sb_show_options(m, sb);
293 : : }
294 : :
295 : 0 : int security_sb_statfs(struct dentry *dentry)
296 : : {
297 : 8242 : return security_ops->sb_statfs(dentry);
298 : : }
299 : :
300 : 0 : int security_sb_mount(const char *dev_name, struct path *path,
301 : : const char *type, unsigned long flags, void *data)
302 : : {
303 : 3118 : return security_ops->sb_mount(dev_name, path, type, flags, data);
304 : : }
305 : :
306 : 0 : int security_sb_umount(struct vfsmount *mnt, int flags)
307 : : {
308 : 76 : return security_ops->sb_umount(mnt, flags);
309 : : }
310 : :
311 : 0 : int security_sb_pivotroot(struct path *old_path, struct path *new_path)
312 : : {
313 : 0 : return security_ops->sb_pivotroot(old_path, new_path);
314 : : }
315 : :
316 : 0 : int security_sb_set_mnt_opts(struct super_block *sb,
317 : : struct security_mnt_opts *opts,
318 : : unsigned long kern_flags,
319 : : unsigned long *set_kern_flags)
320 : : {
321 : 0 : return security_ops->sb_set_mnt_opts(sb, opts, kern_flags,
322 : : set_kern_flags);
323 : : }
324 : : EXPORT_SYMBOL(security_sb_set_mnt_opts);
325 : :
326 : 0 : int security_sb_clone_mnt_opts(const struct super_block *oldsb,
327 : : struct super_block *newsb)
328 : : {
329 : 0 : return security_ops->sb_clone_mnt_opts(oldsb, newsb);
330 : : }
331 : : EXPORT_SYMBOL(security_sb_clone_mnt_opts);
332 : :
333 : 0 : int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts)
334 : : {
335 : 0 : return security_ops->sb_parse_opts_str(options, opts);
336 : : }
337 : : EXPORT_SYMBOL(security_sb_parse_opts_str);
338 : :
339 : 0 : int security_inode_alloc(struct inode *inode)
340 : : {
341 : 1702615 : inode->i_security = NULL;
342 : 1702615 : return security_ops->inode_alloc_security(inode);
343 : : }
344 : :
345 : 0 : void security_inode_free(struct inode *inode)
346 : : {
347 : : integrity_inode_free(inode);
348 : 1687141 : security_ops->inode_free_security(inode);
349 : 1706547 : }
350 : :
351 : 0 : int security_dentry_init_security(struct dentry *dentry, int mode,
352 : : struct qstr *name, void **ctx,
353 : : u32 *ctxlen)
354 : : {
355 : 0 : return security_ops->dentry_init_security(dentry, mode, name,
356 : : ctx, ctxlen);
357 : : }
358 : : EXPORT_SYMBOL(security_dentry_init_security);
359 : :
360 : 0 : int security_inode_init_security(struct inode *inode, struct inode *dir,
361 : : const struct qstr *qstr,
362 : : const initxattrs initxattrs, void *fs_data)
363 : : {
364 : : struct xattr new_xattrs[MAX_LSM_EVM_XATTR + 1];
365 : : struct xattr *lsm_xattr, *evm_xattr, *xattr;
366 : : int ret;
367 : :
368 [ + - ]: 833 : if (unlikely(IS_PRIVATE(inode)))
369 : : return 0;
370 : :
371 [ - + ]: 833 : if (!initxattrs)
372 : 0 : return security_ops->inode_init_security(inode, dir, qstr,
373 : : NULL, NULL, NULL);
374 : 833 : memset(new_xattrs, 0, sizeof(new_xattrs));
375 : : lsm_xattr = new_xattrs;
376 : 833 : ret = security_ops->inode_init_security(inode, dir, qstr,
377 : : &lsm_xattr->name,
378 : : &lsm_xattr->value,
379 : : &lsm_xattr->value_len);
380 [ - + ]: 833 : if (ret)
381 : : goto out;
382 : :
383 : : evm_xattr = lsm_xattr + 1;
384 : : ret = evm_inode_init_security(inode, lsm_xattr, evm_xattr);
385 : : if (ret)
386 : : goto out;
387 : 0 : ret = initxattrs(inode, new_xattrs, fs_data);
388 : : out:
389 [ - + ]: 1666 : for (xattr = new_xattrs; xattr->value != NULL; xattr++)
390 : 0 : kfree(xattr->value);
391 [ - + ]: 833 : return (ret == -EOPNOTSUPP) ? 0 : ret;
392 : : }
393 : : EXPORT_SYMBOL(security_inode_init_security);
394 : :
395 : 0 : int security_old_inode_init_security(struct inode *inode, struct inode *dir,
396 : : const struct qstr *qstr, const char **name,
397 : : void **value, size_t *len)
398 : : {
399 [ # # ]: 0 : if (unlikely(IS_PRIVATE(inode)))
400 : : return -EOPNOTSUPP;
401 : 0 : return security_ops->inode_init_security(inode, dir, qstr, name, value,
402 : : len);
403 : : }
404 : : EXPORT_SYMBOL(security_old_inode_init_security);
405 : :
406 : : #ifdef CONFIG_SECURITY_PATH
407 : 0 : int security_path_mknod(struct path *dir, struct dentry *dentry, umode_t mode,
408 : : unsigned int dev)
409 : : {
410 [ + ]: 233037 : if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
411 : : return 0;
412 : 233039 : return security_ops->path_mknod(dir, dentry, mode, dev);
413 : : }
414 : : EXPORT_SYMBOL(security_path_mknod);
415 : :
416 : 0 : int security_path_mkdir(struct path *dir, struct dentry *dentry, umode_t mode)
417 : : {
418 [ + ]: 35019 : if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
419 : : return 0;
420 : 35206 : return security_ops->path_mkdir(dir, dentry, mode);
421 : : }
422 : : EXPORT_SYMBOL(security_path_mkdir);
423 : :
424 : 0 : int security_path_rmdir(struct path *dir, struct dentry *dentry)
425 : : {
426 [ + ]: 35480 : if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
427 : : return 0;
428 : 35486 : return security_ops->path_rmdir(dir, dentry);
429 : : }
430 : :
431 : 0 : int security_path_unlink(struct path *dir, struct dentry *dentry)
432 : : {
433 [ + ]: 89727 : if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
434 : : return 0;
435 : 89729 : return security_ops->path_unlink(dir, dentry);
436 : : }
437 : : EXPORT_SYMBOL(security_path_unlink);
438 : :
439 : 0 : int security_path_symlink(struct path *dir, struct dentry *dentry,
440 : : const char *old_name)
441 : : {
442 [ + - ]: 4625 : if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
443 : : return 0;
444 : 4625 : return security_ops->path_symlink(dir, dentry, old_name);
445 : : }
446 : :
447 : 0 : int security_path_link(struct dentry *old_dentry, struct path *new_dir,
448 : : struct dentry *new_dentry)
449 : : {
450 [ + - ]: 5290 : if (unlikely(IS_PRIVATE(old_dentry->d_inode)))
451 : : return 0;
452 : 5290 : return security_ops->path_link(old_dentry, new_dir, new_dentry);
453 : : }
454 : :
455 : 0 : int security_path_rename(struct path *old_dir, struct dentry *old_dentry,
456 : : struct path *new_dir, struct dentry *new_dentry)
457 : : {
458 [ + - ][ + + ]: 153096 : if (unlikely(IS_PRIVATE(old_dentry->d_inode) ||
[ + - ][ + - ]
459 : : (new_dentry->d_inode && IS_PRIVATE(new_dentry->d_inode))))
460 : : return 0;
461 : 153096 : return security_ops->path_rename(old_dir, old_dentry, new_dir,
462 : : new_dentry);
463 : : }
464 : : EXPORT_SYMBOL(security_path_rename);
465 : :
466 : 0 : int security_path_truncate(struct path *path)
467 : : {
468 [ + + ]: 37616 : if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
469 : : return 0;
470 : 37608 : return security_ops->path_truncate(path);
471 : : }
472 : :
473 : 0 : int security_path_chmod(struct path *path, umode_t mode)
474 : : {
475 [ + - ]: 4074 : if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
476 : : return 0;
477 : 4074 : return security_ops->path_chmod(path, mode);
478 : : }
479 : :
480 : 0 : int security_path_chown(struct path *path, kuid_t uid, kgid_t gid)
481 : : {
482 [ + - ]: 1665 : if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
483 : : return 0;
484 : 1665 : return security_ops->path_chown(path, uid, gid);
485 : : }
486 : :
487 : 0 : int security_path_chroot(struct path *path)
488 : : {
489 : 1 : return security_ops->path_chroot(path);
490 : : }
491 : : #endif
492 : :
493 : 0 : int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode)
494 : : {
495 [ + ]: 186329 : if (unlikely(IS_PRIVATE(dir)))
496 : : return 0;
497 : 186370 : return security_ops->inode_create(dir, dentry, mode);
498 : : }
499 : : EXPORT_SYMBOL_GPL(security_inode_create);
500 : :
501 : 0 : int security_inode_link(struct dentry *old_dentry, struct inode *dir,
502 : : struct dentry *new_dentry)
503 : : {
504 [ + - ]: 5288 : if (unlikely(IS_PRIVATE(old_dentry->d_inode)))
505 : : return 0;
506 : 5288 : return security_ops->inode_link(old_dentry, dir, new_dentry);
507 : : }
508 : :
509 : 0 : int security_inode_unlink(struct inode *dir, struct dentry *dentry)
510 : : {
511 [ + - ]: 88902 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
512 : : return 0;
513 : 88902 : return security_ops->inode_unlink(dir, dentry);
514 : : }
515 : :
516 : 0 : int security_inode_symlink(struct inode *dir, struct dentry *dentry,
517 : : const char *old_name)
518 : : {
519 [ + - ]: 4625 : if (unlikely(IS_PRIVATE(dir)))
520 : : return 0;
521 : 4625 : return security_ops->inode_symlink(dir, dentry, old_name);
522 : : }
523 : :
524 : 0 : int security_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
525 : : {
526 [ + ]: 35155 : if (unlikely(IS_PRIVATE(dir)))
527 : : return 0;
528 : 35212 : return security_ops->inode_mkdir(dir, dentry, mode);
529 : : }
530 : : EXPORT_SYMBOL_GPL(security_inode_mkdir);
531 : :
532 : 0 : int security_inode_rmdir(struct inode *dir, struct dentry *dentry)
533 : : {
534 [ + ]: 35334 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
535 : : return 0;
536 : 35351 : return security_ops->inode_rmdir(dir, dentry);
537 : : }
538 : :
539 : 0 : int security_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
540 : : {
541 [ + - ]: 46904 : if (unlikely(IS_PRIVATE(dir)))
542 : : return 0;
543 : 46904 : return security_ops->inode_mknod(dir, dentry, mode, dev);
544 : : }
545 : :
546 : 0 : int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
547 : : struct inode *new_dir, struct dentry *new_dentry)
548 : : {
549 [ + - ][ + + ]: 153092 : if (unlikely(IS_PRIVATE(old_dentry->d_inode) ||
[ + - ][ + - ]
550 : : (new_dentry->d_inode && IS_PRIVATE(new_dentry->d_inode))))
551 : : return 0;
552 : 153092 : return security_ops->inode_rename(old_dir, old_dentry,
553 : : new_dir, new_dentry);
554 : : }
555 : :
556 : 0 : int security_inode_readlink(struct dentry *dentry)
557 : : {
558 [ + - ]: 12067 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
559 : : return 0;
560 : 12067 : return security_ops->inode_readlink(dentry);
561 : : }
562 : :
563 : 0 : int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd)
564 : : {
565 [ + ]: 137935 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
566 : : return 0;
567 : 137936 : return security_ops->inode_follow_link(dentry, nd);
568 : : }
569 : :
570 : 0 : int security_inode_permission(struct inode *inode, int mask)
571 : : {
572 [ + ]: 17863148 : if (unlikely(IS_PRIVATE(inode)))
573 : : return 0;
574 : 17878290 : return security_ops->inode_permission(inode, mask);
575 : : }
576 : :
577 : 0 : int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
578 : : {
579 : : int ret;
580 : :
581 [ + - ]: 45071 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
582 : : return 0;
583 : 45071 : ret = security_ops->inode_setattr(dentry, attr);
584 [ - + ]: 45068 : if (ret)
585 : 0 : return ret;
586 : : return evm_inode_setattr(dentry, attr);
587 : : }
588 : : EXPORT_SYMBOL_GPL(security_inode_setattr);
589 : :
590 : 0 : int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
591 : : {
592 [ + ]: 5135996 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
593 : : return 0;
594 : 5136064 : return security_ops->inode_getattr(mnt, dentry);
595 : : }
596 : :
597 : 0 : int security_inode_setxattr(struct dentry *dentry, const char *name,
598 : : const void *value, size_t size, int flags)
599 : : {
600 : : int ret;
601 : :
602 [ + - ]: 2 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
603 : : return 0;
604 : 2 : ret = security_ops->inode_setxattr(dentry, name, value, size, flags);
605 [ - + ]: 2 : if (ret)
606 : 0 : return ret;
607 : : ret = ima_inode_setxattr(dentry, name, value, size);
608 : : if (ret)
609 : : return ret;
610 : : return evm_inode_setxattr(dentry, name, value, size);
611 : : }
612 : :
613 : 0 : void security_inode_post_setxattr(struct dentry *dentry, const char *name,
614 : : const void *value, size_t size, int flags)
615 : : {
616 [ # # ]: 0 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
617 : 0 : return;
618 : 0 : security_ops->inode_post_setxattr(dentry, name, value, size, flags);
619 : : evm_inode_post_setxattr(dentry, name, value, size);
620 : : }
621 : :
622 : 0 : int security_inode_getxattr(struct dentry *dentry, const char *name)
623 : : {
624 [ + - ]: 199 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
625 : : return 0;
626 : 199 : return security_ops->inode_getxattr(dentry, name);
627 : : }
628 : :
629 : 0 : int security_inode_listxattr(struct dentry *dentry)
630 : : {
631 [ + - ]: 4 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
632 : : return 0;
633 : 4 : return security_ops->inode_listxattr(dentry);
634 : : }
635 : :
636 : 0 : int security_inode_removexattr(struct dentry *dentry, const char *name)
637 : : {
638 : : int ret;
639 : :
640 [ # # ]: 0 : if (unlikely(IS_PRIVATE(dentry->d_inode)))
641 : : return 0;
642 : 0 : ret = security_ops->inode_removexattr(dentry, name);
643 [ # # ]: 0 : if (ret)
644 : 0 : return ret;
645 : : ret = ima_inode_removexattr(dentry, name);
646 : : if (ret)
647 : : return ret;
648 : : return evm_inode_removexattr(dentry, name);
649 : : }
650 : :
651 : 0 : int security_inode_need_killpriv(struct dentry *dentry)
652 : : {
653 : 24161 : return security_ops->inode_need_killpriv(dentry);
654 : : }
655 : :
656 : 0 : int security_inode_killpriv(struct dentry *dentry)
657 : : {
658 : 0 : return security_ops->inode_killpriv(dentry);
659 : : }
660 : :
661 : 0 : int security_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
662 : : {
663 [ + - ]: 84 : if (unlikely(IS_PRIVATE(inode)))
664 : : return -EOPNOTSUPP;
665 : 84 : return security_ops->inode_getsecurity(inode, name, buffer, alloc);
666 : : }
667 : :
668 : 0 : int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
669 : : {
670 [ # # ]: 0 : if (unlikely(IS_PRIVATE(inode)))
671 : : return -EOPNOTSUPP;
672 : 0 : return security_ops->inode_setsecurity(inode, name, value, size, flags);
673 : : }
674 : :
675 : 0 : int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
676 : : {
677 [ # # ]: 0 : if (unlikely(IS_PRIVATE(inode)))
678 : : return 0;
679 : 0 : return security_ops->inode_listsecurity(inode, buffer, buffer_size);
680 : : }
681 : : EXPORT_SYMBOL(security_inode_listsecurity);
682 : :
683 : 0 : void security_inode_getsecid(const struct inode *inode, u32 *secid)
684 : : {
685 : 219 : security_ops->inode_getsecid(inode, secid);
686 : 219 : }
687 : :
688 : 0 : int security_file_permission(struct file *file, int mask)
689 : : {
690 : : int ret;
691 : :
692 : 11730051 : ret = security_ops->file_permission(file, mask);
693 [ + ]: 11770745 : if (ret)
694 : : return ret;
695 : :
696 : 11746051 : return fsnotify_perm(file, mask);
697 : : }
698 : :
699 : 0 : int security_file_alloc(struct file *file)
700 : : {
701 : 4462002 : return security_ops->file_alloc_security(file);
702 : : }
703 : :
704 : 0 : void security_file_free(struct file *file)
705 : : {
706 : 4498991 : security_ops->file_free_security(file);
707 : 4517920 : }
708 : :
709 : 0 : int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
710 : : {
711 : 53080 : return security_ops->file_ioctl(file, cmd, arg);
712 : : }
713 : :
714 : : static inline unsigned long mmap_prot(struct file *file, unsigned long prot)
715 : : {
716 : : /*
717 : : * Does we have PROT_READ and does the application expect
718 : : * it to imply PROT_EXEC? If not, nothing to talk about...
719 : : */
720 [ + + ]: 1804931 : if ((prot & (PROT_READ | PROT_EXEC)) != PROT_READ)
721 : : return prot;
722 [ - + ]: 1653371 : if (!(current->personality & READ_IMPLIES_EXEC))
723 : : return prot;
724 : : /*
725 : : * if that's an anonymous mapping, let it.
726 : : */
727 [ # # ]: 0 : if (!file)
728 : 0 : return prot | PROT_EXEC;
729 : : /*
730 : : * ditto if it's not on noexec mount, except that on !MMU we need
731 : : * BDI_CAP_EXEC_MMAP (== VM_MAYEXEC) in this case
732 : : */
733 [ # # ]: 0 : if (!(file->f_path.mnt->mnt_flags & MNT_NOEXEC)) {
734 : : #ifndef CONFIG_MMU
735 : : unsigned long caps = 0;
736 : : struct address_space *mapping = file->f_mapping;
737 : : if (mapping && mapping->backing_dev_info)
738 : : caps = mapping->backing_dev_info->capabilities;
739 : : if (!(caps & BDI_CAP_EXEC_MAP))
740 : : return prot;
741 : : #endif
742 : 0 : return prot | PROT_EXEC;
743 : : }
744 : : /* anything on noexec mount won't get PROT_EXEC */
745 : : return prot;
746 : : }
747 : :
748 : 0 : int security_mmap_file(struct file *file, unsigned long prot,
749 : : unsigned long flags)
750 : : {
751 : : int ret;
752 : 1804931 : ret = security_ops->mmap_file(file, prot,
753 : : mmap_prot(file, prot), flags);
754 [ - + ]: 1804955 : if (ret)
755 : 0 : return ret;
756 : : return ima_file_mmap(file, prot);
757 : : }
758 : :
759 : 0 : int security_mmap_addr(unsigned long addr)
760 : : {
761 : 3863782 : return security_ops->mmap_addr(addr);
762 : : }
763 : :
764 : 0 : int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
765 : : unsigned long prot)
766 : : {
767 : 250756 : return security_ops->file_mprotect(vma, reqprot, prot);
768 : : }
769 : :
770 : 0 : int security_file_lock(struct file *file, unsigned int cmd)
771 : : {
772 : 2131085 : return security_ops->file_lock(file, cmd);
773 : : }
774 : :
775 : 0 : int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
776 : : {
777 : 2259125 : return security_ops->file_fcntl(file, cmd, arg);
778 : : }
779 : :
780 : 0 : int security_file_set_fowner(struct file *file)
781 : : {
782 : 8 : return security_ops->file_set_fowner(file);
783 : : }
784 : :
785 : 0 : int security_file_send_sigiotask(struct task_struct *tsk,
786 : : struct fown_struct *fown, int sig)
787 : : {
788 : 0 : return security_ops->file_send_sigiotask(tsk, fown, sig);
789 : : }
790 : :
791 : 0 : int security_file_receive(struct file *file)
792 : : {
793 : 2 : return security_ops->file_receive(file);
794 : : }
795 : :
796 : 0 : int security_file_open(struct file *file, const struct cred *cred)
797 : : {
798 : : int ret;
799 : :
800 : 2464177 : ret = security_ops->file_open(file, cred);
801 [ + + ]: 2464228 : if (ret)
802 : : return ret;
803 : :
804 : 2464290 : return fsnotify_perm(file, MAY_OPEN);
805 : : }
806 : :
807 : 0 : int security_task_create(unsigned long clone_flags)
808 : : {
809 : 1104225 : return security_ops->task_create(clone_flags);
810 : : }
811 : :
812 : 0 : void security_task_free(struct task_struct *task)
813 : : {
814 : : #ifdef CONFIG_SECURITY_YAMA_STACKED
815 : : yama_task_free(task);
816 : : #endif
817 : 1103346 : security_ops->task_free(task);
818 : 1103246 : }
819 : :
820 : 0 : int security_cred_alloc_blank(struct cred *cred, gfp_t gfp)
821 : : {
822 : 0 : return security_ops->cred_alloc_blank(cred, gfp);
823 : : }
824 : :
825 : 0 : void security_cred_free(struct cred *cred)
826 : : {
827 : 1330123 : security_ops->cred_free(cred);
828 : 1331352 : }
829 : :
830 : 0 : int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp)
831 : : {
832 : 1332388 : return security_ops->cred_prepare(new, old, gfp);
833 : : }
834 : :
835 : 0 : void security_transfer_creds(struct cred *new, const struct cred *old)
836 : : {
837 : 0 : security_ops->cred_transfer(new, old);
838 : 0 : }
839 : :
840 : 0 : int security_kernel_act_as(struct cred *new, u32 secid)
841 : : {
842 : 0 : return security_ops->kernel_act_as(new, secid);
843 : : }
844 : :
845 : 0 : int security_kernel_create_files_as(struct cred *new, struct inode *inode)
846 : : {
847 : 0 : return security_ops->kernel_create_files_as(new, inode);
848 : : }
849 : :
850 : 0 : int security_kernel_module_request(char *kmod_name)
851 : : {
852 : 25 : return security_ops->kernel_module_request(kmod_name);
853 : : }
854 : :
855 : 0 : int security_kernel_module_from_file(struct file *file)
856 : : {
857 : : int ret;
858 : :
859 : 0 : ret = security_ops->kernel_module_from_file(file);
860 [ # # ]: 0 : if (ret)
861 : 0 : return ret;
862 : : return ima_module_check(file);
863 : : }
864 : :
865 : 0 : int security_task_fix_setuid(struct cred *new, const struct cred *old,
866 : : int flags)
867 : : {
868 : 8370 : return security_ops->task_fix_setuid(new, old, flags);
869 : : }
870 : :
871 : 0 : int security_task_setpgid(struct task_struct *p, pid_t pgid)
872 : : {
873 : 1428 : return security_ops->task_setpgid(p, pgid);
874 : : }
875 : :
876 : 0 : int security_task_getpgid(struct task_struct *p)
877 : : {
878 : 36 : return security_ops->task_getpgid(p);
879 : : }
880 : :
881 : 0 : int security_task_getsid(struct task_struct *p)
882 : : {
883 : 0 : return security_ops->task_getsid(p);
884 : : }
885 : :
886 : 0 : void security_task_getsecid(struct task_struct *p, u32 *secid)
887 : : {
888 : 219 : security_ops->task_getsecid(p, secid);
889 : 219 : }
890 : : EXPORT_SYMBOL(security_task_getsecid);
891 : :
892 : 0 : int security_task_setnice(struct task_struct *p, int nice)
893 : : {
894 : 2904 : return security_ops->task_setnice(p, nice);
895 : : }
896 : :
897 : 0 : int security_task_setioprio(struct task_struct *p, int ioprio)
898 : : {
899 : 4 : return security_ops->task_setioprio(p, ioprio);
900 : : }
901 : :
902 : 0 : int security_task_getioprio(struct task_struct *p)
903 : : {
904 : 0 : return security_ops->task_getioprio(p);
905 : : }
906 : :
907 : 0 : int security_task_setrlimit(struct task_struct *p, unsigned int resource,
908 : : struct rlimit *new_rlim)
909 : : {
910 : 2865 : return security_ops->task_setrlimit(p, resource, new_rlim);
911 : : }
912 : :
913 : 0 : int security_task_setscheduler(struct task_struct *p)
914 : : {
915 : 217 : return security_ops->task_setscheduler(p);
916 : : }
917 : :
918 : 0 : int security_task_getscheduler(struct task_struct *p)
919 : : {
920 : 307 : return security_ops->task_getscheduler(p);
921 : : }
922 : :
923 : 0 : int security_task_movememory(struct task_struct *p)
924 : : {
925 : 0 : return security_ops->task_movememory(p);
926 : : }
927 : :
928 : 0 : int security_task_kill(struct task_struct *p, struct siginfo *info,
929 : : int sig, u32 secid)
930 : : {
931 : 9977144 : return security_ops->task_kill(p, info, sig, secid);
932 : : }
933 : :
934 : 0 : int security_task_wait(struct task_struct *p)
935 : : {
936 : 2788401 : return security_ops->task_wait(p);
937 : : }
938 : :
939 : 0 : int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
940 : : unsigned long arg4, unsigned long arg5)
941 : : {
942 : : #ifdef CONFIG_SECURITY_YAMA_STACKED
943 : : int rc;
944 : : rc = yama_task_prctl(option, arg2, arg3, arg4, arg5);
945 : : if (rc != -ENOSYS)
946 : : return rc;
947 : : #endif
948 : 9249 : return security_ops->task_prctl(option, arg2, arg3, arg4, arg5);
949 : : }
950 : :
951 : 0 : void security_task_to_inode(struct task_struct *p, struct inode *inode)
952 : : {
953 : 178082 : security_ops->task_to_inode(p, inode);
954 : 178082 : }
955 : :
956 : 0 : int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
957 : : {
958 : 50255528 : return security_ops->ipc_permission(ipcp, flag);
959 : : }
960 : :
961 : 0 : void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
962 : : {
963 : 0 : security_ops->ipc_getsecid(ipcp, secid);
964 : 0 : }
965 : :
966 : 0 : int security_msg_msg_alloc(struct msg_msg *msg)
967 : : {
968 : 22982468 : return security_ops->msg_msg_alloc_security(msg);
969 : : }
970 : :
971 : 0 : void security_msg_msg_free(struct msg_msg *msg)
972 : : {
973 : 22649574 : security_ops->msg_msg_free_security(msg);
974 : 23137919 : }
975 : :
976 : 0 : int security_msg_queue_alloc(struct msg_queue *msq)
977 : : {
978 : 4427 : return security_ops->msg_queue_alloc_security(msq);
979 : : }
980 : :
981 : 0 : void security_msg_queue_free(struct msg_queue *msq)
982 : : {
983 : 4421 : security_ops->msg_queue_free_security(msq);
984 : 4420 : }
985 : :
986 : 0 : int security_msg_queue_associate(struct msg_queue *msq, int msqflg)
987 : : {
988 : 17755 : return security_ops->msg_queue_associate(msq, msqflg);
989 : : }
990 : :
991 : 0 : int security_msg_queue_msgctl(struct msg_queue *msq, int cmd)
992 : : {
993 : 4442 : return security_ops->msg_queue_msgctl(msq, cmd);
994 : : }
995 : :
996 : 0 : int security_msg_queue_msgsnd(struct msg_queue *msq,
997 : : struct msg_msg *msg, int msqflg)
998 : : {
999 : 27615540 : return security_ops->msg_queue_msgsnd(msq, msg, msqflg);
1000 : : }
1001 : :
1002 : 0 : int security_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
1003 : : struct task_struct *target, long type, int mode)
1004 : : {
1005 : 22386985 : return security_ops->msg_queue_msgrcv(msq, msg, target, type, mode);
1006 : : }
1007 : :
1008 : 0 : int security_shm_alloc(struct shmid_kernel *shp)
1009 : : {
1010 : 4175 : return security_ops->shm_alloc_security(shp);
1011 : : }
1012 : :
1013 : 0 : void security_shm_free(struct shmid_kernel *shp)
1014 : : {
1015 : 4175 : security_ops->shm_free_security(shp);
1016 : 4175 : }
1017 : :
1018 : 0 : int security_shm_associate(struct shmid_kernel *shp, int shmflg)
1019 : : {
1020 : 7 : return security_ops->shm_associate(shp, shmflg);
1021 : : }
1022 : :
1023 : 0 : int security_shm_shmctl(struct shmid_kernel *shp, int cmd)
1024 : : {
1025 : 4198 : return security_ops->shm_shmctl(shp, cmd);
1026 : : }
1027 : :
1028 : 0 : int security_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr, int shmflg)
1029 : : {
1030 : 1084 : return security_ops->shm_shmat(shp, shmaddr, shmflg);
1031 : : }
1032 : :
1033 : 0 : int security_sem_alloc(struct sem_array *sma)
1034 : : {
1035 : 168 : return security_ops->sem_alloc_security(sma);
1036 : : }
1037 : :
1038 : 0 : void security_sem_free(struct sem_array *sma)
1039 : : {
1040 : 168 : security_ops->sem_free_security(sma);
1041 : 168 : }
1042 : :
1043 : 0 : int security_sem_associate(struct sem_array *sma, int semflg)
1044 : : {
1045 : 0 : return security_ops->sem_associate(sma, semflg);
1046 : : }
1047 : :
1048 : 0 : int security_sem_semctl(struct sem_array *sma, int cmd)
1049 : : {
1050 : 481878 : return security_ops->sem_semctl(sma, cmd);
1051 : : }
1052 : :
1053 : 0 : int security_sem_semop(struct sem_array *sma, struct sembuf *sops,
1054 : : unsigned nsops, int alter)
1055 : : {
1056 : 15644 : return security_ops->sem_semop(sma, sops, nsops, alter);
1057 : : }
1058 : :
1059 : 0 : void security_d_instantiate(struct dentry *dentry, struct inode *inode)
1060 : : {
1061 [ + + ][ + ]: 2449287 : if (unlikely(inode && IS_PRIVATE(inode)))
1062 : 2452674 : return;
1063 : 2457042 : security_ops->d_instantiate(dentry, inode);
1064 : : }
1065 : : EXPORT_SYMBOL(security_d_instantiate);
1066 : :
1067 : 0 : int security_getprocattr(struct task_struct *p, char *name, char **value)
1068 : : {
1069 : 14 : return security_ops->getprocattr(p, name, value);
1070 : : }
1071 : :
1072 : 0 : int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
1073 : : {
1074 : 0 : return security_ops->setprocattr(p, name, value, size);
1075 : : }
1076 : :
1077 : 0 : int security_netlink_send(struct sock *sk, struct sk_buff *skb)
1078 : : {
1079 : 4149 : return security_ops->netlink_send(sk, skb);
1080 : : }
1081 : :
1082 : 0 : int security_ismaclabel(const char *name)
1083 : : {
1084 : 0 : return security_ops->ismaclabel(name);
1085 : : }
1086 : : EXPORT_SYMBOL(security_ismaclabel);
1087 : :
1088 : 0 : int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
1089 : : {
1090 : 0 : return security_ops->secid_to_secctx(secid, secdata, seclen);
1091 : : }
1092 : : EXPORT_SYMBOL(security_secid_to_secctx);
1093 : :
1094 : 0 : int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
1095 : : {
1096 : 0 : return security_ops->secctx_to_secid(secdata, seclen, secid);
1097 : : }
1098 : : EXPORT_SYMBOL(security_secctx_to_secid);
1099 : :
1100 : 0 : void security_release_secctx(char *secdata, u32 seclen)
1101 : : {
1102 : 0 : security_ops->release_secctx(secdata, seclen);
1103 : 0 : }
1104 : : EXPORT_SYMBOL(security_release_secctx);
1105 : :
1106 : 0 : int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
1107 : : {
1108 : 208 : return security_ops->inode_notifysecctx(inode, ctx, ctxlen);
1109 : : }
1110 : : EXPORT_SYMBOL(security_inode_notifysecctx);
1111 : :
1112 : 0 : int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
1113 : : {
1114 : 0 : return security_ops->inode_setsecctx(dentry, ctx, ctxlen);
1115 : : }
1116 : : EXPORT_SYMBOL(security_inode_setsecctx);
1117 : :
1118 : 0 : int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
1119 : : {
1120 : 0 : return security_ops->inode_getsecctx(inode, ctx, ctxlen);
1121 : : }
1122 : : EXPORT_SYMBOL(security_inode_getsecctx);
1123 : :
1124 : : #ifdef CONFIG_SECURITY_NETWORK
1125 : :
1126 : 0 : int security_unix_stream_connect(struct sock *sock, struct sock *other, struct sock *newsk)
1127 : : {
1128 : 101 : return security_ops->unix_stream_connect(sock, other, newsk);
1129 : : }
1130 : : EXPORT_SYMBOL(security_unix_stream_connect);
1131 : :
1132 : 0 : int security_unix_may_send(struct socket *sock, struct socket *other)
1133 : : {
1134 : 11603 : return security_ops->unix_may_send(sock, other);
1135 : : }
1136 : : EXPORT_SYMBOL(security_unix_may_send);
1137 : :
1138 : 0 : int security_socket_create(int family, int type, int protocol, int kern)
1139 : : {
1140 : 531106 : return security_ops->socket_create(family, type, protocol, kern);
1141 : : }
1142 : :
1143 : 0 : int security_socket_post_create(struct socket *sock, int family,
1144 : : int type, int protocol, int kern)
1145 : : {
1146 : 526014 : return security_ops->socket_post_create(sock, family, type,
1147 : : protocol, kern);
1148 : : }
1149 : :
1150 : 0 : int security_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
1151 : : {
1152 : 47376 : return security_ops->socket_bind(sock, address, addrlen);
1153 : : }
1154 : :
1155 : 0 : int security_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
1156 : : {
1157 : 6018 : return security_ops->socket_connect(sock, address, addrlen);
1158 : : }
1159 : :
1160 : 0 : int security_socket_listen(struct socket *sock, int backlog)
1161 : : {
1162 : 11 : return security_ops->socket_listen(sock, backlog);
1163 : : }
1164 : :
1165 : 0 : int security_socket_accept(struct socket *sock, struct socket *newsock)
1166 : : {
1167 : 148 : return security_ops->socket_accept(sock, newsock);
1168 : : }
1169 : :
1170 : 0 : int security_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size)
1171 : : {
1172 : 1245953 : return security_ops->socket_sendmsg(sock, msg, size);
1173 : : }
1174 : :
1175 : 0 : int security_socket_recvmsg(struct socket *sock, struct msghdr *msg,
1176 : : int size, int flags)
1177 : : {
1178 : 806495 : return security_ops->socket_recvmsg(sock, msg, size, flags);
1179 : : }
1180 : :
1181 : 0 : int security_socket_getsockname(struct socket *sock)
1182 : : {
1183 : 758 : return security_ops->socket_getsockname(sock);
1184 : : }
1185 : :
1186 : 0 : int security_socket_getpeername(struct socket *sock)
1187 : : {
1188 : 5 : return security_ops->socket_getpeername(sock);
1189 : : }
1190 : :
1191 : 0 : int security_socket_getsockopt(struct socket *sock, int level, int optname)
1192 : : {
1193 : 105 : return security_ops->socket_getsockopt(sock, level, optname);
1194 : : }
1195 : :
1196 : 0 : int security_socket_setsockopt(struct socket *sock, int level, int optname)
1197 : : {
1198 : 83 : return security_ops->socket_setsockopt(sock, level, optname);
1199 : : }
1200 : :
1201 : 0 : int security_socket_shutdown(struct socket *sock, int how)
1202 : : {
1203 : 47 : return security_ops->socket_shutdown(sock, how);
1204 : : }
1205 : :
1206 : 0 : int security_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
1207 : : {
1208 : 39127 : return security_ops->socket_sock_rcv_skb(sk, skb);
1209 : : }
1210 : : EXPORT_SYMBOL(security_sock_rcv_skb);
1211 : :
1212 : 0 : int security_socket_getpeersec_stream(struct socket *sock, char __user *optval,
1213 : : int __user *optlen, unsigned len)
1214 : : {
1215 : 0 : return security_ops->socket_getpeersec_stream(sock, optval, optlen, len);
1216 : : }
1217 : :
1218 : 0 : int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
1219 : : {
1220 : 1232566 : return security_ops->socket_getpeersec_dgram(sock, skb, secid);
1221 : : }
1222 : : EXPORT_SYMBOL(security_socket_getpeersec_dgram);
1223 : :
1224 : 0 : int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
1225 : : {
1226 : 499879 : return security_ops->sk_alloc_security(sk, family, priority);
1227 : : }
1228 : :
1229 : 0 : void security_sk_free(struct sock *sk)
1230 : : {
1231 : 486756 : security_ops->sk_free_security(sk);
1232 : 524368 : }
1233 : :
1234 : 0 : void security_sk_clone(const struct sock *sk, struct sock *newsk)
1235 : : {
1236 : 26 : security_ops->sk_clone_security(sk, newsk);
1237 : 26 : }
1238 : : EXPORT_SYMBOL(security_sk_clone);
1239 : :
1240 : 0 : void security_sk_classify_flow(struct sock *sk, struct flowi *fl)
1241 : : {
1242 : 93 : security_ops->sk_getsecid(sk, &fl->flowi_secid);
1243 : 93 : }
1244 : : EXPORT_SYMBOL(security_sk_classify_flow);
1245 : :
1246 : 0 : void security_req_classify_flow(const struct request_sock *req, struct flowi *fl)
1247 : : {
1248 : 52 : security_ops->req_classify_flow(req, fl);
1249 : 52 : }
1250 : : EXPORT_SYMBOL(security_req_classify_flow);
1251 : :
1252 : 0 : void security_sock_graft(struct sock *sk, struct socket *parent)
1253 : : {
1254 : 127 : security_ops->sock_graft(sk, parent);
1255 : 127 : }
1256 : : EXPORT_SYMBOL(security_sock_graft);
1257 : :
1258 : 0 : int security_inet_conn_request(struct sock *sk,
1259 : : struct sk_buff *skb, struct request_sock *req)
1260 : : {
1261 : 26 : return security_ops->inet_conn_request(sk, skb, req);
1262 : : }
1263 : : EXPORT_SYMBOL(security_inet_conn_request);
1264 : :
1265 : 0 : void security_inet_csk_clone(struct sock *newsk,
1266 : : const struct request_sock *req)
1267 : : {
1268 : 26 : security_ops->inet_csk_clone(newsk, req);
1269 : 26 : }
1270 : :
1271 : 0 : void security_inet_conn_established(struct sock *sk,
1272 : : struct sk_buff *skb)
1273 : : {
1274 : 26 : security_ops->inet_conn_established(sk, skb);
1275 : 26 : }
1276 : :
1277 : 0 : int security_secmark_relabel_packet(u32 secid)
1278 : : {
1279 : 0 : return security_ops->secmark_relabel_packet(secid);
1280 : : }
1281 : : EXPORT_SYMBOL(security_secmark_relabel_packet);
1282 : :
1283 : 0 : void security_secmark_refcount_inc(void)
1284 : : {
1285 : 0 : security_ops->secmark_refcount_inc();
1286 : 0 : }
1287 : : EXPORT_SYMBOL(security_secmark_refcount_inc);
1288 : :
1289 : 0 : void security_secmark_refcount_dec(void)
1290 : : {
1291 : 0 : security_ops->secmark_refcount_dec();
1292 : 0 : }
1293 : : EXPORT_SYMBOL(security_secmark_refcount_dec);
1294 : :
1295 : 0 : int security_tun_dev_alloc_security(void **security)
1296 : : {
1297 : 0 : return security_ops->tun_dev_alloc_security(security);
1298 : : }
1299 : : EXPORT_SYMBOL(security_tun_dev_alloc_security);
1300 : :
1301 : 0 : void security_tun_dev_free_security(void *security)
1302 : : {
1303 : 0 : security_ops->tun_dev_free_security(security);
1304 : 0 : }
1305 : : EXPORT_SYMBOL(security_tun_dev_free_security);
1306 : :
1307 : 0 : int security_tun_dev_create(void)
1308 : : {
1309 : 0 : return security_ops->tun_dev_create();
1310 : : }
1311 : : EXPORT_SYMBOL(security_tun_dev_create);
1312 : :
1313 : 0 : int security_tun_dev_attach_queue(void *security)
1314 : : {
1315 : 0 : return security_ops->tun_dev_attach_queue(security);
1316 : : }
1317 : : EXPORT_SYMBOL(security_tun_dev_attach_queue);
1318 : :
1319 : 0 : int security_tun_dev_attach(struct sock *sk, void *security)
1320 : : {
1321 : 0 : return security_ops->tun_dev_attach(sk, security);
1322 : : }
1323 : : EXPORT_SYMBOL(security_tun_dev_attach);
1324 : :
1325 : 0 : int security_tun_dev_open(void *security)
1326 : : {
1327 : 0 : return security_ops->tun_dev_open(security);
1328 : : }
1329 : : EXPORT_SYMBOL(security_tun_dev_open);
1330 : :
1331 : 0 : void security_skb_owned_by(struct sk_buff *skb, struct sock *sk)
1332 : : {
1333 : 26 : security_ops->skb_owned_by(skb, sk);
1334 : 26 : }
1335 : :
1336 : : #endif /* CONFIG_SECURITY_NETWORK */
1337 : :
1338 : : #ifdef CONFIG_SECURITY_NETWORK_XFRM
1339 : :
1340 : : int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
1341 : : struct xfrm_user_sec_ctx *sec_ctx,
1342 : : gfp_t gfp)
1343 : : {
1344 : : return security_ops->xfrm_policy_alloc_security(ctxp, sec_ctx, gfp);
1345 : : }
1346 : : EXPORT_SYMBOL(security_xfrm_policy_alloc);
1347 : :
1348 : : int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx,
1349 : : struct xfrm_sec_ctx **new_ctxp)
1350 : : {
1351 : : return security_ops->xfrm_policy_clone_security(old_ctx, new_ctxp);
1352 : : }
1353 : :
1354 : : void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
1355 : : {
1356 : : security_ops->xfrm_policy_free_security(ctx);
1357 : : }
1358 : : EXPORT_SYMBOL(security_xfrm_policy_free);
1359 : :
1360 : : int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
1361 : : {
1362 : : return security_ops->xfrm_policy_delete_security(ctx);
1363 : : }
1364 : :
1365 : : int security_xfrm_state_alloc(struct xfrm_state *x,
1366 : : struct xfrm_user_sec_ctx *sec_ctx)
1367 : : {
1368 : : return security_ops->xfrm_state_alloc(x, sec_ctx);
1369 : : }
1370 : : EXPORT_SYMBOL(security_xfrm_state_alloc);
1371 : :
1372 : : int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
1373 : : struct xfrm_sec_ctx *polsec, u32 secid)
1374 : : {
1375 : : return security_ops->xfrm_state_alloc_acquire(x, polsec, secid);
1376 : : }
1377 : :
1378 : : int security_xfrm_state_delete(struct xfrm_state *x)
1379 : : {
1380 : : return security_ops->xfrm_state_delete_security(x);
1381 : : }
1382 : : EXPORT_SYMBOL(security_xfrm_state_delete);
1383 : :
1384 : : void security_xfrm_state_free(struct xfrm_state *x)
1385 : : {
1386 : : security_ops->xfrm_state_free_security(x);
1387 : : }
1388 : :
1389 : : int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir)
1390 : : {
1391 : : return security_ops->xfrm_policy_lookup(ctx, fl_secid, dir);
1392 : : }
1393 : :
1394 : : int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
1395 : : struct xfrm_policy *xp,
1396 : : const struct flowi *fl)
1397 : : {
1398 : : return security_ops->xfrm_state_pol_flow_match(x, xp, fl);
1399 : : }
1400 : :
1401 : : int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid)
1402 : : {
1403 : : return security_ops->xfrm_decode_session(skb, secid, 1);
1404 : : }
1405 : :
1406 : : void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl)
1407 : : {
1408 : : int rc = security_ops->xfrm_decode_session(skb, &fl->flowi_secid, 0);
1409 : :
1410 : : BUG_ON(rc);
1411 : : }
1412 : : EXPORT_SYMBOL(security_skb_classify_flow);
1413 : :
1414 : : #endif /* CONFIG_SECURITY_NETWORK_XFRM */
1415 : :
1416 : : #ifdef CONFIG_KEYS
1417 : :
1418 : 0 : int security_key_alloc(struct key *key, const struct cred *cred,
1419 : : unsigned long flags)
1420 : : {
1421 : 3 : return security_ops->key_alloc(key, cred, flags);
1422 : : }
1423 : :
1424 : 0 : void security_key_free(struct key *key)
1425 : : {
1426 : 3 : security_ops->key_free(key);
1427 : 3 : }
1428 : :
1429 : 0 : int security_key_permission(key_ref_t key_ref,
1430 : : const struct cred *cred, key_perm_t perm)
1431 : : {
1432 : 4 : return security_ops->key_permission(key_ref, cred, perm);
1433 : : }
1434 : :
1435 : 0 : int security_key_getsecurity(struct key *key, char **_buffer)
1436 : : {
1437 : 0 : return security_ops->key_getsecurity(key, _buffer);
1438 : : }
1439 : :
1440 : : #endif /* CONFIG_KEYS */
1441 : :
1442 : : #ifdef CONFIG_AUDIT
1443 : :
1444 : 0 : int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule)
1445 : : {
1446 : 0 : return security_ops->audit_rule_init(field, op, rulestr, lsmrule);
1447 : : }
1448 : :
1449 : 0 : int security_audit_rule_known(struct audit_krule *krule)
1450 : : {
1451 : 0 : return security_ops->audit_rule_known(krule);
1452 : : }
1453 : :
1454 : 0 : void security_audit_rule_free(void *lsmrule)
1455 : : {
1456 : 0 : security_ops->audit_rule_free(lsmrule);
1457 : 0 : }
1458 : :
1459 : 0 : int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule,
1460 : : struct audit_context *actx)
1461 : : {
1462 : 0 : return security_ops->audit_rule_match(secid, field, op, lsmrule, actx);
1463 : : }
1464 : :
1465 : : #endif /* CONFIG_AUDIT */
|
