blob: 48d4b0a52737b2e28a8fb2e32d589af2db2463f9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Stub functions for the default security function pointers in case no
3 * security model is loaded.
4 *
5 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
6 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
7 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
14
15#undef DEBUG
16
Randy.Dunlapc59ede72006-01-11 12:17:46 -080017#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
19#include <linux/mman.h>
20#include <linux/pagemap.h>
21#include <linux/swap.h>
22#include <linux/security.h>
23#include <linux/skbuff.h>
24#include <linux/netlink.h>
25#include <net/sock.h>
26#include <linux/xattr.h>
27#include <linux/hugetlb.h>
28#include <linux/ptrace.h>
29#include <linux/file.h>
30
31static int dummy_ptrace (struct task_struct *parent, struct task_struct *child)
32{
33 return 0;
34}
35
36static int dummy_capget (struct task_struct *target, kernel_cap_t * effective,
37 kernel_cap_t * inheritable, kernel_cap_t * permitted)
38{
39 *effective = *inheritable = *permitted = 0;
Andrew Morgan72c2d582007-10-18 03:05:59 -070040 if (target->euid == 0) {
41 *permitted |= (~0 & ~CAP_FS_MASK);
42 *effective |= (~0 & ~CAP_TO_MASK(CAP_SETPCAP) & ~CAP_FS_MASK);
43 }
44 if (target->fsuid == 0) {
45 *permitted |= CAP_FS_MASK;
46 *effective |= CAP_FS_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 }
48 return 0;
49}
50
51static int dummy_capset_check (struct task_struct *target,
52 kernel_cap_t * effective,
53 kernel_cap_t * inheritable,
54 kernel_cap_t * permitted)
55{
56 return -EPERM;
57}
58
59static void dummy_capset_set (struct task_struct *target,
60 kernel_cap_t * effective,
61 kernel_cap_t * inheritable,
62 kernel_cap_t * permitted)
63{
64 return;
65}
66
67static int dummy_acct (struct file *file)
68{
69 return 0;
70}
71
72static int dummy_capable (struct task_struct *tsk, int cap)
73{
74 if (cap_raised (tsk->cap_effective, cap))
75 return 0;
76 return -EPERM;
77}
78
79static int dummy_sysctl (ctl_table * table, int op)
80{
81 return 0;
82}
83
84static int dummy_quotactl (int cmds, int type, int id, struct super_block *sb)
85{
86 return 0;
87}
88
89static int dummy_quota_on (struct dentry *dentry)
90{
91 return 0;
92}
93
94static int dummy_syslog (int type)
95{
96 if ((type != 3 && type != 10) && current->euid)
97 return -EPERM;
98 return 0;
99}
100
101static int dummy_settime(struct timespec *ts, struct timezone *tz)
102{
103 if (!capable(CAP_SYS_TIME))
104 return -EPERM;
105 return 0;
106}
107
Alan Cox34b4e4a2007-08-22 14:01:28 -0700108static int dummy_vm_enough_memory(struct mm_struct *mm, long pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 int cap_sys_admin = 0;
111
112 if (dummy_capable(current, CAP_SYS_ADMIN) == 0)
113 cap_sys_admin = 1;
Alan Cox34b4e4a2007-08-22 14:01:28 -0700114 return __vm_enough_memory(mm, pages, cap_sys_admin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
116
117static int dummy_bprm_alloc_security (struct linux_binprm *bprm)
118{
119 return 0;
120}
121
122static void dummy_bprm_free_security (struct linux_binprm *bprm)
123{
124 return;
125}
126
127static void dummy_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
128{
129 if (bprm->e_uid != current->uid || bprm->e_gid != current->gid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700130 set_dumpable(current->mm, suid_dumpable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132 if ((unsafe & ~LSM_UNSAFE_PTRACE_CAP) && !capable(CAP_SETUID)) {
133 bprm->e_uid = current->uid;
134 bprm->e_gid = current->gid;
135 }
136 }
137
138 current->suid = current->euid = current->fsuid = bprm->e_uid;
139 current->sgid = current->egid = current->fsgid = bprm->e_gid;
140
141 dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
142}
143
144static void dummy_bprm_post_apply_creds (struct linux_binprm *bprm)
145{
146 return;
147}
148
149static int dummy_bprm_set_security (struct linux_binprm *bprm)
150{
151 return 0;
152}
153
154static int dummy_bprm_check_security (struct linux_binprm *bprm)
155{
156 return 0;
157}
158
159static int dummy_bprm_secureexec (struct linux_binprm *bprm)
160{
161 /* The new userland will simply use the value provided
162 in the AT_SECURE field to decide whether secure mode
163 is required. Hence, this logic is required to preserve
164 the legacy decision algorithm used by the old userland. */
165 return (current->euid != current->uid ||
166 current->egid != current->gid);
167}
168
169static int dummy_sb_alloc_security (struct super_block *sb)
170{
171 return 0;
172}
173
174static void dummy_sb_free_security (struct super_block *sb)
175{
176 return;
177}
178
179static int dummy_sb_copy_data (struct file_system_type *type,
180 void *orig, void *copy)
181{
182 return 0;
183}
184
185static int dummy_sb_kern_mount (struct super_block *sb, void *data)
186{
187 return 0;
188}
189
David Howells726c3342006-06-23 02:02:58 -0700190static int dummy_sb_statfs (struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
192 return 0;
193}
194
195static int dummy_sb_mount (char *dev_name, struct nameidata *nd, char *type,
196 unsigned long flags, void *data)
197{
198 return 0;
199}
200
201static int dummy_sb_check_sb (struct vfsmount *mnt, struct nameidata *nd)
202{
203 return 0;
204}
205
206static int dummy_sb_umount (struct vfsmount *mnt, int flags)
207{
208 return 0;
209}
210
211static void dummy_sb_umount_close (struct vfsmount *mnt)
212{
213 return;
214}
215
216static void dummy_sb_umount_busy (struct vfsmount *mnt)
217{
218 return;
219}
220
221static void dummy_sb_post_remount (struct vfsmount *mnt, unsigned long flags,
222 void *data)
223{
224 return;
225}
226
227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228static void dummy_sb_post_addmount (struct vfsmount *mnt, struct nameidata *nd)
229{
230 return;
231}
232
233static int dummy_sb_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
234{
235 return 0;
236}
237
238static void dummy_sb_post_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
239{
240 return;
241}
242
Eric Parisc9180a52007-11-30 13:00:35 -0500243static int dummy_sb_get_mnt_opts(const struct super_block *sb, char ***mount_options,
244 int **flags, int *num_opts)
245{
246 *mount_options = NULL;
247 *flags = NULL;
248 *num_opts = 0;
249 return 0;
250}
251
252static int dummy_sb_set_mnt_opts(struct super_block *sb, char **mount_options,
253 int *flags, int num_opts)
254{
255 if (unlikely(num_opts))
256 return -EOPNOTSUPP;
257 return 0;
258}
259
260static void dummy_sb_clone_mnt_opts(const struct super_block *oldsb,
261 struct super_block *newsb)
262{
263 return;
264}
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266static int dummy_inode_alloc_security (struct inode *inode)
267{
268 return 0;
269}
270
271static void dummy_inode_free_security (struct inode *inode)
272{
273 return;
274}
275
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700276static int dummy_inode_init_security (struct inode *inode, struct inode *dir,
277 char **name, void **value, size_t *len)
278{
279 return -EOPNOTSUPP;
280}
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282static int dummy_inode_create (struct inode *inode, struct dentry *dentry,
283 int mask)
284{
285 return 0;
286}
287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288static int dummy_inode_link (struct dentry *old_dentry, struct inode *inode,
289 struct dentry *new_dentry)
290{
291 return 0;
292}
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294static int dummy_inode_unlink (struct inode *inode, struct dentry *dentry)
295{
296 return 0;
297}
298
299static int dummy_inode_symlink (struct inode *inode, struct dentry *dentry,
300 const char *name)
301{
302 return 0;
303}
304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305static int dummy_inode_mkdir (struct inode *inode, struct dentry *dentry,
306 int mask)
307{
308 return 0;
309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311static int dummy_inode_rmdir (struct inode *inode, struct dentry *dentry)
312{
313 return 0;
314}
315
316static int dummy_inode_mknod (struct inode *inode, struct dentry *dentry,
317 int mode, dev_t dev)
318{
319 return 0;
320}
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322static int dummy_inode_rename (struct inode *old_inode,
323 struct dentry *old_dentry,
324 struct inode *new_inode,
325 struct dentry *new_dentry)
326{
327 return 0;
328}
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330static int dummy_inode_readlink (struct dentry *dentry)
331{
332 return 0;
333}
334
335static int dummy_inode_follow_link (struct dentry *dentry,
336 struct nameidata *nameidata)
337{
338 return 0;
339}
340
341static int dummy_inode_permission (struct inode *inode, int mask, struct nameidata *nd)
342{
343 return 0;
344}
345
346static int dummy_inode_setattr (struct dentry *dentry, struct iattr *iattr)
347{
348 return 0;
349}
350
351static int dummy_inode_getattr (struct vfsmount *mnt, struct dentry *dentry)
352{
353 return 0;
354}
355
356static void dummy_inode_delete (struct inode *ino)
357{
358 return;
359}
360
361static int dummy_inode_setxattr (struct dentry *dentry, char *name, void *value,
362 size_t size, int flags)
363{
364 if (!strncmp(name, XATTR_SECURITY_PREFIX,
365 sizeof(XATTR_SECURITY_PREFIX) - 1) &&
366 !capable(CAP_SYS_ADMIN))
367 return -EPERM;
368 return 0;
369}
370
371static void dummy_inode_post_setxattr (struct dentry *dentry, char *name, void *value,
372 size_t size, int flags)
373{
374}
375
376static int dummy_inode_getxattr (struct dentry *dentry, char *name)
377{
378 return 0;
379}
380
381static int dummy_inode_listxattr (struct dentry *dentry)
382{
383 return 0;
384}
385
386static int dummy_inode_removexattr (struct dentry *dentry, char *name)
387{
388 if (!strncmp(name, XATTR_SECURITY_PREFIX,
389 sizeof(XATTR_SECURITY_PREFIX) - 1) &&
390 !capable(CAP_SYS_ADMIN))
391 return -EPERM;
392 return 0;
393}
394
Serge E. Hallynb5376772007-10-16 23:31:36 -0700395static int dummy_inode_need_killpriv(struct dentry *dentry)
396{
397 return 0;
398}
399
400static int dummy_inode_killpriv(struct dentry *dentry)
401{
402 return 0;
403}
404
Dustin Kirkland7306a0b2005-11-16 15:53:13 +0000405static int dummy_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 return -EOPNOTSUPP;
408}
409
410static int dummy_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
411{
412 return -EOPNOTSUPP;
413}
414
415static int dummy_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
416{
417 return 0;
418}
419
420static int dummy_file_permission (struct file *file, int mask)
421{
422 return 0;
423}
424
425static int dummy_file_alloc_security (struct file *file)
426{
427 return 0;
428}
429
430static void dummy_file_free_security (struct file *file)
431{
432 return;
433}
434
435static int dummy_file_ioctl (struct file *file, unsigned int command,
436 unsigned long arg)
437{
438 return 0;
439}
440
441static int dummy_file_mmap (struct file *file, unsigned long reqprot,
442 unsigned long prot,
Eric Parised032182007-06-28 15:55:21 -0400443 unsigned long flags,
444 unsigned long addr,
445 unsigned long addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
Eric Parisab5a91a2007-11-26 18:47:46 -0500447 if ((addr < mmap_min_addr) && !capable(CAP_SYS_RAWIO))
Eric Parised032182007-06-28 15:55:21 -0400448 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 return 0;
450}
451
452static int dummy_file_mprotect (struct vm_area_struct *vma,
453 unsigned long reqprot,
454 unsigned long prot)
455{
456 return 0;
457}
458
459static int dummy_file_lock (struct file *file, unsigned int cmd)
460{
461 return 0;
462}
463
464static int dummy_file_fcntl (struct file *file, unsigned int cmd,
465 unsigned long arg)
466{
467 return 0;
468}
469
470static int dummy_file_set_fowner (struct file *file)
471{
472 return 0;
473}
474
475static int dummy_file_send_sigiotask (struct task_struct *tsk,
476 struct fown_struct *fown, int sig)
477{
478 return 0;
479}
480
481static int dummy_file_receive (struct file *file)
482{
483 return 0;
484}
485
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +0900486static int dummy_dentry_open (struct file *file)
487{
488 return 0;
489}
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491static int dummy_task_create (unsigned long clone_flags)
492{
493 return 0;
494}
495
496static int dummy_task_alloc_security (struct task_struct *p)
497{
498 return 0;
499}
500
501static void dummy_task_free_security (struct task_struct *p)
502{
503 return;
504}
505
506static int dummy_task_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
507{
508 return 0;
509}
510
511static int dummy_task_post_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
512{
513 dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
514 return 0;
515}
516
517static int dummy_task_setgid (gid_t id0, gid_t id1, gid_t id2, int flags)
518{
519 return 0;
520}
521
522static int dummy_task_setpgid (struct task_struct *p, pid_t pgid)
523{
524 return 0;
525}
526
527static int dummy_task_getpgid (struct task_struct *p)
528{
529 return 0;
530}
531
532static int dummy_task_getsid (struct task_struct *p)
533{
534 return 0;
535}
536
David Quigleyf9008e42006-06-30 01:55:46 -0700537static void dummy_task_getsecid (struct task_struct *p, u32 *secid)
538{ }
539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540static int dummy_task_setgroups (struct group_info *group_info)
541{
542 return 0;
543}
544
545static int dummy_task_setnice (struct task_struct *p, int nice)
546{
547 return 0;
548}
549
James Morris03e68062006-06-23 02:03:58 -0700550static int dummy_task_setioprio (struct task_struct *p, int ioprio)
551{
552 return 0;
553}
554
David Quigleya1836a42006-06-30 01:55:49 -0700555static int dummy_task_getioprio (struct task_struct *p)
556{
557 return 0;
558}
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560static int dummy_task_setrlimit (unsigned int resource, struct rlimit *new_rlim)
561{
562 return 0;
563}
564
565static int dummy_task_setscheduler (struct task_struct *p, int policy,
566 struct sched_param *lp)
567{
568 return 0;
569}
570
571static int dummy_task_getscheduler (struct task_struct *p)
572{
573 return 0;
574}
575
David Quigley35601542006-06-23 02:04:01 -0700576static int dummy_task_movememory (struct task_struct *p)
577{
578 return 0;
579}
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581static int dummy_task_wait (struct task_struct *p)
582{
583 return 0;
584}
585
586static int dummy_task_kill (struct task_struct *p, struct siginfo *info,
David Quigleyf9008e42006-06-30 01:55:46 -0700587 int sig, u32 secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588{
589 return 0;
590}
591
592static int dummy_task_prctl (int option, unsigned long arg2, unsigned long arg3,
593 unsigned long arg4, unsigned long arg5)
594{
595 return 0;
596}
597
598static void dummy_task_reparent_to_init (struct task_struct *p)
599{
600 p->euid = p->fsuid = 0;
601 return;
602}
603
604static void dummy_task_to_inode(struct task_struct *p, struct inode *inode)
605{ }
606
607static int dummy_ipc_permission (struct kern_ipc_perm *ipcp, short flag)
608{
609 return 0;
610}
611
612static int dummy_msg_msg_alloc_security (struct msg_msg *msg)
613{
614 return 0;
615}
616
617static void dummy_msg_msg_free_security (struct msg_msg *msg)
618{
619 return;
620}
621
622static int dummy_msg_queue_alloc_security (struct msg_queue *msq)
623{
624 return 0;
625}
626
627static void dummy_msg_queue_free_security (struct msg_queue *msq)
628{
629 return;
630}
631
632static int dummy_msg_queue_associate (struct msg_queue *msq,
633 int msqflg)
634{
635 return 0;
636}
637
638static int dummy_msg_queue_msgctl (struct msg_queue *msq, int cmd)
639{
640 return 0;
641}
642
643static int dummy_msg_queue_msgsnd (struct msg_queue *msq, struct msg_msg *msg,
644 int msgflg)
645{
646 return 0;
647}
648
649static int dummy_msg_queue_msgrcv (struct msg_queue *msq, struct msg_msg *msg,
650 struct task_struct *target, long type,
651 int mode)
652{
653 return 0;
654}
655
656static int dummy_shm_alloc_security (struct shmid_kernel *shp)
657{
658 return 0;
659}
660
661static void dummy_shm_free_security (struct shmid_kernel *shp)
662{
663 return;
664}
665
666static int dummy_shm_associate (struct shmid_kernel *shp, int shmflg)
667{
668 return 0;
669}
670
671static int dummy_shm_shmctl (struct shmid_kernel *shp, int cmd)
672{
673 return 0;
674}
675
676static int dummy_shm_shmat (struct shmid_kernel *shp, char __user *shmaddr,
677 int shmflg)
678{
679 return 0;
680}
681
682static int dummy_sem_alloc_security (struct sem_array *sma)
683{
684 return 0;
685}
686
687static void dummy_sem_free_security (struct sem_array *sma)
688{
689 return;
690}
691
692static int dummy_sem_associate (struct sem_array *sma, int semflg)
693{
694 return 0;
695}
696
697static int dummy_sem_semctl (struct sem_array *sma, int cmd)
698{
699 return 0;
700}
701
702static int dummy_sem_semop (struct sem_array *sma,
703 struct sembuf *sops, unsigned nsops, int alter)
704{
705 return 0;
706}
707
708static int dummy_netlink_send (struct sock *sk, struct sk_buff *skb)
709{
710 NETLINK_CB(skb).eff_cap = current->cap_effective;
711 return 0;
712}
713
Darrel Goeddelc7bdb542006-06-27 13:26:11 -0700714static int dummy_netlink_recv (struct sk_buff *skb, int cap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715{
Darrel Goeddelc7bdb542006-06-27 13:26:11 -0700716 if (!cap_raised (NETLINK_CB (skb).eff_cap, cap))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return -EPERM;
718 return 0;
719}
720
721#ifdef CONFIG_SECURITY_NETWORK
722static int dummy_unix_stream_connect (struct socket *sock,
723 struct socket *other,
724 struct sock *newsk)
725{
726 return 0;
727}
728
729static int dummy_unix_may_send (struct socket *sock,
730 struct socket *other)
731{
732 return 0;
733}
734
735static int dummy_socket_create (int family, int type,
736 int protocol, int kern)
737{
738 return 0;
739}
740
Venkat Yekkirala7420ed22006-08-04 23:17:57 -0700741static int dummy_socket_post_create (struct socket *sock, int family, int type,
742 int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
Venkat Yekkirala7420ed22006-08-04 23:17:57 -0700744 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
746
747static int dummy_socket_bind (struct socket *sock, struct sockaddr *address,
748 int addrlen)
749{
750 return 0;
751}
752
753static int dummy_socket_connect (struct socket *sock, struct sockaddr *address,
754 int addrlen)
755{
756 return 0;
757}
758
759static int dummy_socket_listen (struct socket *sock, int backlog)
760{
761 return 0;
762}
763
764static int dummy_socket_accept (struct socket *sock, struct socket *newsock)
765{
766 return 0;
767}
768
769static void dummy_socket_post_accept (struct socket *sock,
770 struct socket *newsock)
771{
772 return;
773}
774
775static int dummy_socket_sendmsg (struct socket *sock, struct msghdr *msg,
776 int size)
777{
778 return 0;
779}
780
781static int dummy_socket_recvmsg (struct socket *sock, struct msghdr *msg,
782 int size, int flags)
783{
784 return 0;
785}
786
787static int dummy_socket_getsockname (struct socket *sock)
788{
789 return 0;
790}
791
792static int dummy_socket_getpeername (struct socket *sock)
793{
794 return 0;
795}
796
797static int dummy_socket_setsockopt (struct socket *sock, int level, int optname)
798{
799 return 0;
800}
801
802static int dummy_socket_getsockopt (struct socket *sock, int level, int optname)
803{
804 return 0;
805}
806
807static int dummy_socket_shutdown (struct socket *sock, int how)
808{
809 return 0;
810}
811
812static int dummy_socket_sock_rcv_skb (struct sock *sk, struct sk_buff *skb)
813{
814 return 0;
815}
816
Catherine Zhang2c7946a2006-03-20 22:41:23 -0800817static int dummy_socket_getpeersec_stream(struct socket *sock, char __user *optval,
818 int __user *optlen, unsigned len)
819{
820 return -ENOPROTOOPT;
821}
822
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700823static int dummy_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
825 return -ENOPROTOOPT;
826}
827
Al Viro7d877f32005-10-21 03:20:43 -0400828static inline int dummy_sk_alloc_security (struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
830 return 0;
831}
832
833static inline void dummy_sk_free_security (struct sock *sk)
834{
835}
Trent Jaegerdf718372005-12-13 23:12:27 -0800836
Venkat Yekkirala892c1412006-08-04 23:08:56 -0700837static inline void dummy_sk_clone_security (const struct sock *sk, struct sock *newsk)
838{
839}
840
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700841static inline void dummy_sk_getsecid(struct sock *sk, u32 *secid)
Trent Jaegerdf718372005-12-13 23:12:27 -0800842{
Trent Jaegerdf718372005-12-13 23:12:27 -0800843}
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700844
845static inline void dummy_sock_graft(struct sock* sk, struct socket *parent)
846{
847}
848
849static inline int dummy_inet_conn_request(struct sock *sk,
850 struct sk_buff *skb, struct request_sock *req)
851{
852 return 0;
853}
854
855static inline void dummy_inet_csk_clone(struct sock *newsk,
856 const struct request_sock *req)
857{
858}
859
Venkat Yekkirala6b877692006-11-08 17:04:09 -0600860static inline void dummy_inet_conn_established(struct sock *sk,
861 struct sk_buff *skb)
862{
863}
864
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700865static inline void dummy_req_classify_flow(const struct request_sock *req,
866 struct flowi *fl)
867{
868}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869#endif /* CONFIG_SECURITY_NETWORK */
870
Trent Jaegerdf718372005-12-13 23:12:27 -0800871#ifdef CONFIG_SECURITY_NETWORK_XFRM
Venkat Yekkiralacb969f02006-07-24 23:32:20 -0700872static int dummy_xfrm_policy_alloc_security(struct xfrm_policy *xp,
Venkat Yekkiralac1a856c2006-11-08 17:03:44 -0600873 struct xfrm_user_sec_ctx *sec_ctx)
Trent Jaegerdf718372005-12-13 23:12:27 -0800874{
875 return 0;
876}
877
878static inline int dummy_xfrm_policy_clone_security(struct xfrm_policy *old, struct xfrm_policy *new)
879{
880 return 0;
881}
882
883static void dummy_xfrm_policy_free_security(struct xfrm_policy *xp)
884{
885}
886
Catherine Zhangc8c05a82006-06-08 23:39:49 -0700887static int dummy_xfrm_policy_delete_security(struct xfrm_policy *xp)
888{
889 return 0;
890}
891
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700892static int dummy_xfrm_state_alloc_security(struct xfrm_state *x,
Venkat Yekkiralac1a856c2006-11-08 17:03:44 -0600893 struct xfrm_user_sec_ctx *sec_ctx, u32 secid)
Trent Jaegerdf718372005-12-13 23:12:27 -0800894{
895 return 0;
896}
897
898static void dummy_xfrm_state_free_security(struct xfrm_state *x)
899{
900}
901
Catherine Zhangc8c05a82006-06-08 23:39:49 -0700902static int dummy_xfrm_state_delete_security(struct xfrm_state *x)
903{
904 return 0;
905}
906
Trent Jaegerdf718372005-12-13 23:12:27 -0800907static int dummy_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir)
908{
909 return 0;
910}
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700911
912static int dummy_xfrm_state_pol_flow_match(struct xfrm_state *x,
913 struct xfrm_policy *xp, struct flowi *fl)
914{
915 return 1;
916}
917
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700918static int dummy_xfrm_decode_session(struct sk_buff *skb, u32 *fl, int ckall)
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700919{
920 return 0;
921}
922
Trent Jaegerdf718372005-12-13 23:12:27 -0800923#endif /* CONFIG_SECURITY_NETWORK_XFRM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924static int dummy_register_security (const char *name, struct security_operations *ops)
925{
926 return -EINVAL;
927}
928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929static void dummy_d_instantiate (struct dentry *dentry, struct inode *inode)
930{
931 return;
932}
933
Al Viro04ff9702007-03-12 16:17:58 +0000934static int dummy_getprocattr(struct task_struct *p, char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935{
936 return -EINVAL;
937}
938
939static int dummy_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
940{
941 return -EINVAL;
942}
943
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700944static int dummy_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
945{
946 return -EOPNOTSUPP;
947}
948
David Howells63cb3442008-01-15 23:47:35 +0000949static int dummy_secctx_to_secid(char *secdata, u32 seclen, u32 *secid)
950{
951 return -EOPNOTSUPP;
952}
953
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700954static void dummy_release_secctx(char *secdata, u32 seclen)
955{
956}
957
David Howells29db9192005-10-30 15:02:44 -0800958#ifdef CONFIG_KEYS
David Howells7e047ef2006-06-26 00:24:50 -0700959static inline int dummy_key_alloc(struct key *key, struct task_struct *ctx,
960 unsigned long flags)
David Howells29db9192005-10-30 15:02:44 -0800961{
962 return 0;
963}
964
965static inline void dummy_key_free(struct key *key)
966{
967}
968
969static inline int dummy_key_permission(key_ref_t key_ref,
970 struct task_struct *context,
971 key_perm_t perm)
972{
973 return 0;
974}
975#endif /* CONFIG_KEYS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
977struct security_operations dummy_security_ops;
978
979#define set_to_dummy_if_null(ops, function) \
980 do { \
981 if (!ops->function) { \
982 ops->function = dummy_##function; \
983 pr_debug("Had to override the " #function \
984 " security operation with the dummy one.\n");\
985 } \
986 } while (0)
987
988void security_fixup_ops (struct security_operations *ops)
989{
990 set_to_dummy_if_null(ops, ptrace);
991 set_to_dummy_if_null(ops, capget);
992 set_to_dummy_if_null(ops, capset_check);
993 set_to_dummy_if_null(ops, capset_set);
994 set_to_dummy_if_null(ops, acct);
995 set_to_dummy_if_null(ops, capable);
996 set_to_dummy_if_null(ops, quotactl);
997 set_to_dummy_if_null(ops, quota_on);
998 set_to_dummy_if_null(ops, sysctl);
999 set_to_dummy_if_null(ops, syslog);
1000 set_to_dummy_if_null(ops, settime);
1001 set_to_dummy_if_null(ops, vm_enough_memory);
1002 set_to_dummy_if_null(ops, bprm_alloc_security);
1003 set_to_dummy_if_null(ops, bprm_free_security);
1004 set_to_dummy_if_null(ops, bprm_apply_creds);
1005 set_to_dummy_if_null(ops, bprm_post_apply_creds);
1006 set_to_dummy_if_null(ops, bprm_set_security);
1007 set_to_dummy_if_null(ops, bprm_check_security);
1008 set_to_dummy_if_null(ops, bprm_secureexec);
1009 set_to_dummy_if_null(ops, sb_alloc_security);
1010 set_to_dummy_if_null(ops, sb_free_security);
1011 set_to_dummy_if_null(ops, sb_copy_data);
1012 set_to_dummy_if_null(ops, sb_kern_mount);
1013 set_to_dummy_if_null(ops, sb_statfs);
1014 set_to_dummy_if_null(ops, sb_mount);
1015 set_to_dummy_if_null(ops, sb_check_sb);
1016 set_to_dummy_if_null(ops, sb_umount);
1017 set_to_dummy_if_null(ops, sb_umount_close);
1018 set_to_dummy_if_null(ops, sb_umount_busy);
1019 set_to_dummy_if_null(ops, sb_post_remount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 set_to_dummy_if_null(ops, sb_post_addmount);
1021 set_to_dummy_if_null(ops, sb_pivotroot);
1022 set_to_dummy_if_null(ops, sb_post_pivotroot);
Eric Parisc9180a52007-11-30 13:00:35 -05001023 set_to_dummy_if_null(ops, sb_get_mnt_opts);
1024 set_to_dummy_if_null(ops, sb_set_mnt_opts);
1025 set_to_dummy_if_null(ops, sb_clone_mnt_opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 set_to_dummy_if_null(ops, inode_alloc_security);
1027 set_to_dummy_if_null(ops, inode_free_security);
Stephen Smalley5e41ff92005-09-09 13:01:35 -07001028 set_to_dummy_if_null(ops, inode_init_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 set_to_dummy_if_null(ops, inode_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 set_to_dummy_if_null(ops, inode_link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 set_to_dummy_if_null(ops, inode_unlink);
1032 set_to_dummy_if_null(ops, inode_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 set_to_dummy_if_null(ops, inode_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 set_to_dummy_if_null(ops, inode_rmdir);
1035 set_to_dummy_if_null(ops, inode_mknod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 set_to_dummy_if_null(ops, inode_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 set_to_dummy_if_null(ops, inode_readlink);
1038 set_to_dummy_if_null(ops, inode_follow_link);
1039 set_to_dummy_if_null(ops, inode_permission);
1040 set_to_dummy_if_null(ops, inode_setattr);
1041 set_to_dummy_if_null(ops, inode_getattr);
1042 set_to_dummy_if_null(ops, inode_delete);
1043 set_to_dummy_if_null(ops, inode_setxattr);
1044 set_to_dummy_if_null(ops, inode_post_setxattr);
1045 set_to_dummy_if_null(ops, inode_getxattr);
1046 set_to_dummy_if_null(ops, inode_listxattr);
1047 set_to_dummy_if_null(ops, inode_removexattr);
Serge E. Hallynb5376772007-10-16 23:31:36 -07001048 set_to_dummy_if_null(ops, inode_need_killpriv);
1049 set_to_dummy_if_null(ops, inode_killpriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 set_to_dummy_if_null(ops, inode_getsecurity);
1051 set_to_dummy_if_null(ops, inode_setsecurity);
1052 set_to_dummy_if_null(ops, inode_listsecurity);
1053 set_to_dummy_if_null(ops, file_permission);
1054 set_to_dummy_if_null(ops, file_alloc_security);
1055 set_to_dummy_if_null(ops, file_free_security);
1056 set_to_dummy_if_null(ops, file_ioctl);
1057 set_to_dummy_if_null(ops, file_mmap);
1058 set_to_dummy_if_null(ops, file_mprotect);
1059 set_to_dummy_if_null(ops, file_lock);
1060 set_to_dummy_if_null(ops, file_fcntl);
1061 set_to_dummy_if_null(ops, file_set_fowner);
1062 set_to_dummy_if_null(ops, file_send_sigiotask);
1063 set_to_dummy_if_null(ops, file_receive);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09001064 set_to_dummy_if_null(ops, dentry_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 set_to_dummy_if_null(ops, task_create);
1066 set_to_dummy_if_null(ops, task_alloc_security);
1067 set_to_dummy_if_null(ops, task_free_security);
1068 set_to_dummy_if_null(ops, task_setuid);
1069 set_to_dummy_if_null(ops, task_post_setuid);
1070 set_to_dummy_if_null(ops, task_setgid);
1071 set_to_dummy_if_null(ops, task_setpgid);
1072 set_to_dummy_if_null(ops, task_getpgid);
1073 set_to_dummy_if_null(ops, task_getsid);
David Quigleyf9008e42006-06-30 01:55:46 -07001074 set_to_dummy_if_null(ops, task_getsecid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 set_to_dummy_if_null(ops, task_setgroups);
1076 set_to_dummy_if_null(ops, task_setnice);
James Morris03e68062006-06-23 02:03:58 -07001077 set_to_dummy_if_null(ops, task_setioprio);
David Quigleya1836a42006-06-30 01:55:49 -07001078 set_to_dummy_if_null(ops, task_getioprio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 set_to_dummy_if_null(ops, task_setrlimit);
1080 set_to_dummy_if_null(ops, task_setscheduler);
1081 set_to_dummy_if_null(ops, task_getscheduler);
David Quigley35601542006-06-23 02:04:01 -07001082 set_to_dummy_if_null(ops, task_movememory);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 set_to_dummy_if_null(ops, task_wait);
1084 set_to_dummy_if_null(ops, task_kill);
1085 set_to_dummy_if_null(ops, task_prctl);
1086 set_to_dummy_if_null(ops, task_reparent_to_init);
1087 set_to_dummy_if_null(ops, task_to_inode);
1088 set_to_dummy_if_null(ops, ipc_permission);
1089 set_to_dummy_if_null(ops, msg_msg_alloc_security);
1090 set_to_dummy_if_null(ops, msg_msg_free_security);
1091 set_to_dummy_if_null(ops, msg_queue_alloc_security);
1092 set_to_dummy_if_null(ops, msg_queue_free_security);
1093 set_to_dummy_if_null(ops, msg_queue_associate);
1094 set_to_dummy_if_null(ops, msg_queue_msgctl);
1095 set_to_dummy_if_null(ops, msg_queue_msgsnd);
1096 set_to_dummy_if_null(ops, msg_queue_msgrcv);
1097 set_to_dummy_if_null(ops, shm_alloc_security);
1098 set_to_dummy_if_null(ops, shm_free_security);
1099 set_to_dummy_if_null(ops, shm_associate);
1100 set_to_dummy_if_null(ops, shm_shmctl);
1101 set_to_dummy_if_null(ops, shm_shmat);
1102 set_to_dummy_if_null(ops, sem_alloc_security);
1103 set_to_dummy_if_null(ops, sem_free_security);
1104 set_to_dummy_if_null(ops, sem_associate);
1105 set_to_dummy_if_null(ops, sem_semctl);
1106 set_to_dummy_if_null(ops, sem_semop);
1107 set_to_dummy_if_null(ops, netlink_send);
1108 set_to_dummy_if_null(ops, netlink_recv);
1109 set_to_dummy_if_null(ops, register_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 set_to_dummy_if_null(ops, d_instantiate);
1111 set_to_dummy_if_null(ops, getprocattr);
1112 set_to_dummy_if_null(ops, setprocattr);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001113 set_to_dummy_if_null(ops, secid_to_secctx);
David Howells63cb3442008-01-15 23:47:35 +00001114 set_to_dummy_if_null(ops, secctx_to_secid);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001115 set_to_dummy_if_null(ops, release_secctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116#ifdef CONFIG_SECURITY_NETWORK
1117 set_to_dummy_if_null(ops, unix_stream_connect);
1118 set_to_dummy_if_null(ops, unix_may_send);
1119 set_to_dummy_if_null(ops, socket_create);
1120 set_to_dummy_if_null(ops, socket_post_create);
1121 set_to_dummy_if_null(ops, socket_bind);
1122 set_to_dummy_if_null(ops, socket_connect);
1123 set_to_dummy_if_null(ops, socket_listen);
1124 set_to_dummy_if_null(ops, socket_accept);
1125 set_to_dummy_if_null(ops, socket_post_accept);
1126 set_to_dummy_if_null(ops, socket_sendmsg);
1127 set_to_dummy_if_null(ops, socket_recvmsg);
1128 set_to_dummy_if_null(ops, socket_getsockname);
1129 set_to_dummy_if_null(ops, socket_getpeername);
1130 set_to_dummy_if_null(ops, socket_setsockopt);
1131 set_to_dummy_if_null(ops, socket_getsockopt);
1132 set_to_dummy_if_null(ops, socket_shutdown);
1133 set_to_dummy_if_null(ops, socket_sock_rcv_skb);
Arnaldo Carvalho de Meloc841aa02006-03-20 22:47:37 -08001134 set_to_dummy_if_null(ops, socket_getpeersec_stream);
1135 set_to_dummy_if_null(ops, socket_getpeersec_dgram);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 set_to_dummy_if_null(ops, sk_alloc_security);
1137 set_to_dummy_if_null(ops, sk_free_security);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07001138 set_to_dummy_if_null(ops, sk_clone_security);
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001139 set_to_dummy_if_null(ops, sk_getsecid);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001140 set_to_dummy_if_null(ops, sock_graft);
1141 set_to_dummy_if_null(ops, inet_conn_request);
1142 set_to_dummy_if_null(ops, inet_csk_clone);
Venkat Yekkirala6b877692006-11-08 17:04:09 -06001143 set_to_dummy_if_null(ops, inet_conn_established);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001144 set_to_dummy_if_null(ops, req_classify_flow);
Trent Jaegerdf718372005-12-13 23:12:27 -08001145 #endif /* CONFIG_SECURITY_NETWORK */
1146#ifdef CONFIG_SECURITY_NETWORK_XFRM
1147 set_to_dummy_if_null(ops, xfrm_policy_alloc_security);
1148 set_to_dummy_if_null(ops, xfrm_policy_clone_security);
1149 set_to_dummy_if_null(ops, xfrm_policy_free_security);
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001150 set_to_dummy_if_null(ops, xfrm_policy_delete_security);
Trent Jaegerdf718372005-12-13 23:12:27 -08001151 set_to_dummy_if_null(ops, xfrm_state_alloc_security);
1152 set_to_dummy_if_null(ops, xfrm_state_free_security);
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001153 set_to_dummy_if_null(ops, xfrm_state_delete_security);
Trent Jaegerdf718372005-12-13 23:12:27 -08001154 set_to_dummy_if_null(ops, xfrm_policy_lookup);
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001155 set_to_dummy_if_null(ops, xfrm_state_pol_flow_match);
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001156 set_to_dummy_if_null(ops, xfrm_decode_session);
Trent Jaegerdf718372005-12-13 23:12:27 -08001157#endif /* CONFIG_SECURITY_NETWORK_XFRM */
David Howells29db9192005-10-30 15:02:44 -08001158#ifdef CONFIG_KEYS
1159 set_to_dummy_if_null(ops, key_alloc);
1160 set_to_dummy_if_null(ops, key_free);
1161 set_to_dummy_if_null(ops, key_permission);
1162#endif /* CONFIG_KEYS */
1163
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164}
1165