blob: 649326bf64ea37e82afe63901560f96c687a468b [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{
Andrew Morgan72c2d582007-10-18 03:05:59 -070039 if (target->euid == 0) {
Andrew Morgane338d262008-02-04 22:29:42 -080040 cap_set_full(*permitted);
41 cap_set_init_eff(*effective);
42 } else {
43 cap_clear(*permitted);
44 cap_clear(*effective);
Andrew Morgan72c2d582007-10-18 03:05:59 -070045 }
Andrew Morgane338d262008-02-04 22:29:42 -080046
47 cap_clear(*inheritable);
48
49 if (target->fsuid != 0) {
50 *permitted = cap_drop_fs_set(*permitted);
51 *effective = cap_drop_fs_set(*effective);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 }
53 return 0;
54}
55
56static int dummy_capset_check (struct task_struct *target,
57 kernel_cap_t * effective,
58 kernel_cap_t * inheritable,
59 kernel_cap_t * permitted)
60{
61 return -EPERM;
62}
63
64static void dummy_capset_set (struct task_struct *target,
65 kernel_cap_t * effective,
66 kernel_cap_t * inheritable,
67 kernel_cap_t * permitted)
68{
69 return;
70}
71
72static int dummy_acct (struct file *file)
73{
74 return 0;
75}
76
77static int dummy_capable (struct task_struct *tsk, int cap)
78{
79 if (cap_raised (tsk->cap_effective, cap))
80 return 0;
81 return -EPERM;
82}
83
84static int dummy_sysctl (ctl_table * table, int op)
85{
86 return 0;
87}
88
89static int dummy_quotactl (int cmds, int type, int id, struct super_block *sb)
90{
91 return 0;
92}
93
94static int dummy_quota_on (struct dentry *dentry)
95{
96 return 0;
97}
98
99static int dummy_syslog (int type)
100{
101 if ((type != 3 && type != 10) && current->euid)
102 return -EPERM;
103 return 0;
104}
105
106static int dummy_settime(struct timespec *ts, struct timezone *tz)
107{
108 if (!capable(CAP_SYS_TIME))
109 return -EPERM;
110 return 0;
111}
112
Alan Cox34b4e4a2007-08-22 14:01:28 -0700113static int dummy_vm_enough_memory(struct mm_struct *mm, long pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 int cap_sys_admin = 0;
116
117 if (dummy_capable(current, CAP_SYS_ADMIN) == 0)
118 cap_sys_admin = 1;
Alan Cox34b4e4a2007-08-22 14:01:28 -0700119 return __vm_enough_memory(mm, pages, cap_sys_admin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
121
122static int dummy_bprm_alloc_security (struct linux_binprm *bprm)
123{
124 return 0;
125}
126
127static void dummy_bprm_free_security (struct linux_binprm *bprm)
128{
129 return;
130}
131
132static void dummy_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
133{
134 if (bprm->e_uid != current->uid || bprm->e_gid != current->gid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700135 set_dumpable(current->mm, suid_dumpable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137 if ((unsafe & ~LSM_UNSAFE_PTRACE_CAP) && !capable(CAP_SETUID)) {
138 bprm->e_uid = current->uid;
139 bprm->e_gid = current->gid;
140 }
141 }
142
143 current->suid = current->euid = current->fsuid = bprm->e_uid;
144 current->sgid = current->egid = current->fsgid = bprm->e_gid;
145
146 dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
147}
148
149static void dummy_bprm_post_apply_creds (struct linux_binprm *bprm)
150{
151 return;
152}
153
154static int dummy_bprm_set_security (struct linux_binprm *bprm)
155{
156 return 0;
157}
158
159static int dummy_bprm_check_security (struct linux_binprm *bprm)
160{
161 return 0;
162}
163
164static int dummy_bprm_secureexec (struct linux_binprm *bprm)
165{
166 /* The new userland will simply use the value provided
167 in the AT_SECURE field to decide whether secure mode
168 is required. Hence, this logic is required to preserve
169 the legacy decision algorithm used by the old userland. */
170 return (current->euid != current->uid ||
171 current->egid != current->gid);
172}
173
174static int dummy_sb_alloc_security (struct super_block *sb)
175{
176 return 0;
177}
178
179static void dummy_sb_free_security (struct super_block *sb)
180{
181 return;
182}
183
184static int dummy_sb_copy_data (struct file_system_type *type,
185 void *orig, void *copy)
186{
187 return 0;
188}
189
190static int dummy_sb_kern_mount (struct super_block *sb, void *data)
191{
192 return 0;
193}
194
David Howells726c3342006-06-23 02:02:58 -0700195static int dummy_sb_statfs (struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
197 return 0;
198}
199
200static int dummy_sb_mount (char *dev_name, struct nameidata *nd, char *type,
201 unsigned long flags, void *data)
202{
203 return 0;
204}
205
206static int dummy_sb_check_sb (struct vfsmount *mnt, struct nameidata *nd)
207{
208 return 0;
209}
210
211static int dummy_sb_umount (struct vfsmount *mnt, int flags)
212{
213 return 0;
214}
215
216static void dummy_sb_umount_close (struct vfsmount *mnt)
217{
218 return;
219}
220
221static void dummy_sb_umount_busy (struct vfsmount *mnt)
222{
223 return;
224}
225
226static void dummy_sb_post_remount (struct vfsmount *mnt, unsigned long flags,
227 void *data)
228{
229 return;
230}
231
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233static void dummy_sb_post_addmount (struct vfsmount *mnt, struct nameidata *nd)
234{
235 return;
236}
237
238static int dummy_sb_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
239{
240 return 0;
241}
242
243static void dummy_sb_post_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
244{
245 return;
246}
247
Eric Parisc9180a52007-11-30 13:00:35 -0500248static int dummy_sb_get_mnt_opts(const struct super_block *sb, char ***mount_options,
249 int **flags, int *num_opts)
250{
251 *mount_options = NULL;
252 *flags = NULL;
253 *num_opts = 0;
254 return 0;
255}
256
257static int dummy_sb_set_mnt_opts(struct super_block *sb, char **mount_options,
258 int *flags, int num_opts)
259{
260 if (unlikely(num_opts))
261 return -EOPNOTSUPP;
262 return 0;
263}
264
265static void dummy_sb_clone_mnt_opts(const struct super_block *oldsb,
266 struct super_block *newsb)
267{
268 return;
269}
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271static int dummy_inode_alloc_security (struct inode *inode)
272{
273 return 0;
274}
275
276static void dummy_inode_free_security (struct inode *inode)
277{
278 return;
279}
280
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700281static int dummy_inode_init_security (struct inode *inode, struct inode *dir,
282 char **name, void **value, size_t *len)
283{
284 return -EOPNOTSUPP;
285}
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287static int dummy_inode_create (struct inode *inode, struct dentry *dentry,
288 int mask)
289{
290 return 0;
291}
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293static int dummy_inode_link (struct dentry *old_dentry, struct inode *inode,
294 struct dentry *new_dentry)
295{
296 return 0;
297}
298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299static int dummy_inode_unlink (struct inode *inode, struct dentry *dentry)
300{
301 return 0;
302}
303
304static int dummy_inode_symlink (struct inode *inode, struct dentry *dentry,
305 const char *name)
306{
307 return 0;
308}
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310static int dummy_inode_mkdir (struct inode *inode, struct dentry *dentry,
311 int mask)
312{
313 return 0;
314}
315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316static int dummy_inode_rmdir (struct inode *inode, struct dentry *dentry)
317{
318 return 0;
319}
320
321static int dummy_inode_mknod (struct inode *inode, struct dentry *dentry,
322 int mode, dev_t dev)
323{
324 return 0;
325}
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327static int dummy_inode_rename (struct inode *old_inode,
328 struct dentry *old_dentry,
329 struct inode *new_inode,
330 struct dentry *new_dentry)
331{
332 return 0;
333}
334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335static int dummy_inode_readlink (struct dentry *dentry)
336{
337 return 0;
338}
339
340static int dummy_inode_follow_link (struct dentry *dentry,
341 struct nameidata *nameidata)
342{
343 return 0;
344}
345
346static int dummy_inode_permission (struct inode *inode, int mask, struct nameidata *nd)
347{
348 return 0;
349}
350
351static int dummy_inode_setattr (struct dentry *dentry, struct iattr *iattr)
352{
353 return 0;
354}
355
356static int dummy_inode_getattr (struct vfsmount *mnt, struct dentry *dentry)
357{
358 return 0;
359}
360
361static void dummy_inode_delete (struct inode *ino)
362{
363 return;
364}
365
366static int dummy_inode_setxattr (struct dentry *dentry, char *name, void *value,
367 size_t size, int flags)
368{
369 if (!strncmp(name, XATTR_SECURITY_PREFIX,
370 sizeof(XATTR_SECURITY_PREFIX) - 1) &&
371 !capable(CAP_SYS_ADMIN))
372 return -EPERM;
373 return 0;
374}
375
376static void dummy_inode_post_setxattr (struct dentry *dentry, char *name, void *value,
377 size_t size, int flags)
378{
379}
380
381static int dummy_inode_getxattr (struct dentry *dentry, char *name)
382{
383 return 0;
384}
385
386static int dummy_inode_listxattr (struct dentry *dentry)
387{
388 return 0;
389}
390
391static int dummy_inode_removexattr (struct dentry *dentry, char *name)
392{
393 if (!strncmp(name, XATTR_SECURITY_PREFIX,
394 sizeof(XATTR_SECURITY_PREFIX) - 1) &&
395 !capable(CAP_SYS_ADMIN))
396 return -EPERM;
397 return 0;
398}
399
Serge E. Hallynb5376772007-10-16 23:31:36 -0700400static int dummy_inode_need_killpriv(struct dentry *dentry)
401{
402 return 0;
403}
404
405static int dummy_inode_killpriv(struct dentry *dentry)
406{
407 return 0;
408}
409
David P. Quigley42492592008-02-04 22:29:39 -0800410static int dummy_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
412 return -EOPNOTSUPP;
413}
414
415static int dummy_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
416{
417 return -EOPNOTSUPP;
418}
419
420static int dummy_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
421{
422 return 0;
423}
424
425static int dummy_file_permission (struct file *file, int mask)
426{
427 return 0;
428}
429
430static int dummy_file_alloc_security (struct file *file)
431{
432 return 0;
433}
434
435static void dummy_file_free_security (struct file *file)
436{
437 return;
438}
439
440static int dummy_file_ioctl (struct file *file, unsigned int command,
441 unsigned long arg)
442{
443 return 0;
444}
445
446static int dummy_file_mmap (struct file *file, unsigned long reqprot,
447 unsigned long prot,
Eric Parised032182007-06-28 15:55:21 -0400448 unsigned long flags,
449 unsigned long addr,
450 unsigned long addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Eric Parisab5a91a2007-11-26 18:47:46 -0500452 if ((addr < mmap_min_addr) && !capable(CAP_SYS_RAWIO))
Eric Parised032182007-06-28 15:55:21 -0400453 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return 0;
455}
456
457static int dummy_file_mprotect (struct vm_area_struct *vma,
458 unsigned long reqprot,
459 unsigned long prot)
460{
461 return 0;
462}
463
464static int dummy_file_lock (struct file *file, unsigned int cmd)
465{
466 return 0;
467}
468
469static int dummy_file_fcntl (struct file *file, unsigned int cmd,
470 unsigned long arg)
471{
472 return 0;
473}
474
475static int dummy_file_set_fowner (struct file *file)
476{
477 return 0;
478}
479
480static int dummy_file_send_sigiotask (struct task_struct *tsk,
481 struct fown_struct *fown, int sig)
482{
483 return 0;
484}
485
486static int dummy_file_receive (struct file *file)
487{
488 return 0;
489}
490
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +0900491static int dummy_dentry_open (struct file *file)
492{
493 return 0;
494}
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496static int dummy_task_create (unsigned long clone_flags)
497{
498 return 0;
499}
500
501static int dummy_task_alloc_security (struct task_struct *p)
502{
503 return 0;
504}
505
506static void dummy_task_free_security (struct task_struct *p)
507{
508 return;
509}
510
511static int dummy_task_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
512{
513 return 0;
514}
515
516static int dummy_task_post_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
517{
518 dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
519 return 0;
520}
521
522static int dummy_task_setgid (gid_t id0, gid_t id1, gid_t id2, int flags)
523{
524 return 0;
525}
526
527static int dummy_task_setpgid (struct task_struct *p, pid_t pgid)
528{
529 return 0;
530}
531
532static int dummy_task_getpgid (struct task_struct *p)
533{
534 return 0;
535}
536
537static int dummy_task_getsid (struct task_struct *p)
538{
539 return 0;
540}
541
David Quigleyf9008e42006-06-30 01:55:46 -0700542static void dummy_task_getsecid (struct task_struct *p, u32 *secid)
543{ }
544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545static int dummy_task_setgroups (struct group_info *group_info)
546{
547 return 0;
548}
549
550static int dummy_task_setnice (struct task_struct *p, int nice)
551{
552 return 0;
553}
554
James Morris03e68062006-06-23 02:03:58 -0700555static int dummy_task_setioprio (struct task_struct *p, int ioprio)
556{
557 return 0;
558}
559
David Quigleya1836a42006-06-30 01:55:49 -0700560static int dummy_task_getioprio (struct task_struct *p)
561{
562 return 0;
563}
564
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565static int dummy_task_setrlimit (unsigned int resource, struct rlimit *new_rlim)
566{
567 return 0;
568}
569
570static int dummy_task_setscheduler (struct task_struct *p, int policy,
571 struct sched_param *lp)
572{
573 return 0;
574}
575
576static int dummy_task_getscheduler (struct task_struct *p)
577{
578 return 0;
579}
580
David Quigley35601542006-06-23 02:04:01 -0700581static int dummy_task_movememory (struct task_struct *p)
582{
583 return 0;
584}
585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586static int dummy_task_wait (struct task_struct *p)
587{
588 return 0;
589}
590
591static int dummy_task_kill (struct task_struct *p, struct siginfo *info,
David Quigleyf9008e42006-06-30 01:55:46 -0700592 int sig, u32 secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 return 0;
595}
596
597static int dummy_task_prctl (int option, unsigned long arg2, unsigned long arg3,
598 unsigned long arg4, unsigned long arg5)
599{
600 return 0;
601}
602
603static void dummy_task_reparent_to_init (struct task_struct *p)
604{
605 p->euid = p->fsuid = 0;
606 return;
607}
608
609static void dummy_task_to_inode(struct task_struct *p, struct inode *inode)
610{ }
611
612static int dummy_ipc_permission (struct kern_ipc_perm *ipcp, short flag)
613{
614 return 0;
615}
616
617static int dummy_msg_msg_alloc_security (struct msg_msg *msg)
618{
619 return 0;
620}
621
622static void dummy_msg_msg_free_security (struct msg_msg *msg)
623{
624 return;
625}
626
627static int dummy_msg_queue_alloc_security (struct msg_queue *msq)
628{
629 return 0;
630}
631
632static void dummy_msg_queue_free_security (struct msg_queue *msq)
633{
634 return;
635}
636
637static int dummy_msg_queue_associate (struct msg_queue *msq,
638 int msqflg)
639{
640 return 0;
641}
642
643static int dummy_msg_queue_msgctl (struct msg_queue *msq, int cmd)
644{
645 return 0;
646}
647
648static int dummy_msg_queue_msgsnd (struct msg_queue *msq, struct msg_msg *msg,
649 int msgflg)
650{
651 return 0;
652}
653
654static int dummy_msg_queue_msgrcv (struct msg_queue *msq, struct msg_msg *msg,
655 struct task_struct *target, long type,
656 int mode)
657{
658 return 0;
659}
660
661static int dummy_shm_alloc_security (struct shmid_kernel *shp)
662{
663 return 0;
664}
665
666static void dummy_shm_free_security (struct shmid_kernel *shp)
667{
668 return;
669}
670
671static int dummy_shm_associate (struct shmid_kernel *shp, int shmflg)
672{
673 return 0;
674}
675
676static int dummy_shm_shmctl (struct shmid_kernel *shp, int cmd)
677{
678 return 0;
679}
680
681static int dummy_shm_shmat (struct shmid_kernel *shp, char __user *shmaddr,
682 int shmflg)
683{
684 return 0;
685}
686
687static int dummy_sem_alloc_security (struct sem_array *sma)
688{
689 return 0;
690}
691
692static void dummy_sem_free_security (struct sem_array *sma)
693{
694 return;
695}
696
697static int dummy_sem_associate (struct sem_array *sma, int semflg)
698{
699 return 0;
700}
701
702static int dummy_sem_semctl (struct sem_array *sma, int cmd)
703{
704 return 0;
705}
706
707static int dummy_sem_semop (struct sem_array *sma,
708 struct sembuf *sops, unsigned nsops, int alter)
709{
710 return 0;
711}
712
713static int dummy_netlink_send (struct sock *sk, struct sk_buff *skb)
714{
715 NETLINK_CB(skb).eff_cap = current->cap_effective;
716 return 0;
717}
718
Darrel Goeddelc7bdb542006-06-27 13:26:11 -0700719static int dummy_netlink_recv (struct sk_buff *skb, int cap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720{
Darrel Goeddelc7bdb542006-06-27 13:26:11 -0700721 if (!cap_raised (NETLINK_CB (skb).eff_cap, cap))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 return -EPERM;
723 return 0;
724}
725
726#ifdef CONFIG_SECURITY_NETWORK
727static int dummy_unix_stream_connect (struct socket *sock,
728 struct socket *other,
729 struct sock *newsk)
730{
731 return 0;
732}
733
734static int dummy_unix_may_send (struct socket *sock,
735 struct socket *other)
736{
737 return 0;
738}
739
740static int dummy_socket_create (int family, int type,
741 int protocol, int kern)
742{
743 return 0;
744}
745
Venkat Yekkirala7420ed22006-08-04 23:17:57 -0700746static int dummy_socket_post_create (struct socket *sock, int family, int type,
747 int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Venkat Yekkirala7420ed22006-08-04 23:17:57 -0700749 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
752static int dummy_socket_bind (struct socket *sock, struct sockaddr *address,
753 int addrlen)
754{
755 return 0;
756}
757
758static int dummy_socket_connect (struct socket *sock, struct sockaddr *address,
759 int addrlen)
760{
761 return 0;
762}
763
764static int dummy_socket_listen (struct socket *sock, int backlog)
765{
766 return 0;
767}
768
769static int dummy_socket_accept (struct socket *sock, struct socket *newsock)
770{
771 return 0;
772}
773
774static void dummy_socket_post_accept (struct socket *sock,
775 struct socket *newsock)
776{
777 return;
778}
779
780static int dummy_socket_sendmsg (struct socket *sock, struct msghdr *msg,
781 int size)
782{
783 return 0;
784}
785
786static int dummy_socket_recvmsg (struct socket *sock, struct msghdr *msg,
787 int size, int flags)
788{
789 return 0;
790}
791
792static int dummy_socket_getsockname (struct socket *sock)
793{
794 return 0;
795}
796
797static int dummy_socket_getpeername (struct socket *sock)
798{
799 return 0;
800}
801
802static int dummy_socket_setsockopt (struct socket *sock, int level, int optname)
803{
804 return 0;
805}
806
807static int dummy_socket_getsockopt (struct socket *sock, int level, int optname)
808{
809 return 0;
810}
811
812static int dummy_socket_shutdown (struct socket *sock, int how)
813{
814 return 0;
815}
816
817static int dummy_socket_sock_rcv_skb (struct sock *sk, struct sk_buff *skb)
818{
819 return 0;
820}
821
Catherine Zhang2c7946a2006-03-20 22:41:23 -0800822static int dummy_socket_getpeersec_stream(struct socket *sock, char __user *optval,
823 int __user *optlen, unsigned len)
824{
825 return -ENOPROTOOPT;
826}
827
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700828static int dummy_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
830 return -ENOPROTOOPT;
831}
832
Al Viro7d877f32005-10-21 03:20:43 -0400833static inline int dummy_sk_alloc_security (struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
835 return 0;
836}
837
838static inline void dummy_sk_free_security (struct sock *sk)
839{
840}
Trent Jaegerdf718372005-12-13 23:12:27 -0800841
Venkat Yekkirala892c1412006-08-04 23:08:56 -0700842static inline void dummy_sk_clone_security (const struct sock *sk, struct sock *newsk)
843{
844}
845
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700846static inline void dummy_sk_getsecid(struct sock *sk, u32 *secid)
Trent Jaegerdf718372005-12-13 23:12:27 -0800847{
Trent Jaegerdf718372005-12-13 23:12:27 -0800848}
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700849
850static inline void dummy_sock_graft(struct sock* sk, struct socket *parent)
851{
852}
853
854static inline int dummy_inet_conn_request(struct sock *sk,
855 struct sk_buff *skb, struct request_sock *req)
856{
857 return 0;
858}
859
860static inline void dummy_inet_csk_clone(struct sock *newsk,
861 const struct request_sock *req)
862{
863}
864
Venkat Yekkirala6b877692006-11-08 17:04:09 -0600865static inline void dummy_inet_conn_established(struct sock *sk,
866 struct sk_buff *skb)
867{
868}
869
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700870static inline void dummy_req_classify_flow(const struct request_sock *req,
871 struct flowi *fl)
872{
873}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874#endif /* CONFIG_SECURITY_NETWORK */
875
Trent Jaegerdf718372005-12-13 23:12:27 -0800876#ifdef CONFIG_SECURITY_NETWORK_XFRM
Venkat Yekkiralacb969f02006-07-24 23:32:20 -0700877static int dummy_xfrm_policy_alloc_security(struct xfrm_policy *xp,
Venkat Yekkiralac1a856c2006-11-08 17:03:44 -0600878 struct xfrm_user_sec_ctx *sec_ctx)
Trent Jaegerdf718372005-12-13 23:12:27 -0800879{
880 return 0;
881}
882
883static inline int dummy_xfrm_policy_clone_security(struct xfrm_policy *old, struct xfrm_policy *new)
884{
885 return 0;
886}
887
888static void dummy_xfrm_policy_free_security(struct xfrm_policy *xp)
889{
890}
891
Catherine Zhangc8c05a82006-06-08 23:39:49 -0700892static int dummy_xfrm_policy_delete_security(struct xfrm_policy *xp)
893{
894 return 0;
895}
896
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700897static int dummy_xfrm_state_alloc_security(struct xfrm_state *x,
Venkat Yekkiralac1a856c2006-11-08 17:03:44 -0600898 struct xfrm_user_sec_ctx *sec_ctx, u32 secid)
Trent Jaegerdf718372005-12-13 23:12:27 -0800899{
900 return 0;
901}
902
903static void dummy_xfrm_state_free_security(struct xfrm_state *x)
904{
905}
906
Catherine Zhangc8c05a82006-06-08 23:39:49 -0700907static int dummy_xfrm_state_delete_security(struct xfrm_state *x)
908{
909 return 0;
910}
911
Trent Jaegerdf718372005-12-13 23:12:27 -0800912static int dummy_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir)
913{
914 return 0;
915}
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700916
917static int dummy_xfrm_state_pol_flow_match(struct xfrm_state *x,
918 struct xfrm_policy *xp, struct flowi *fl)
919{
920 return 1;
921}
922
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700923static int dummy_xfrm_decode_session(struct sk_buff *skb, u32 *fl, int ckall)
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700924{
925 return 0;
926}
927
Trent Jaegerdf718372005-12-13 23:12:27 -0800928#endif /* CONFIG_SECURITY_NETWORK_XFRM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929static int dummy_register_security (const char *name, struct security_operations *ops)
930{
931 return -EINVAL;
932}
933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934static void dummy_d_instantiate (struct dentry *dentry, struct inode *inode)
935{
936 return;
937}
938
Al Viro04ff9702007-03-12 16:17:58 +0000939static int dummy_getprocattr(struct task_struct *p, char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940{
941 return -EINVAL;
942}
943
944static int dummy_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
945{
946 return -EINVAL;
947}
948
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700949static int dummy_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
950{
951 return -EOPNOTSUPP;
952}
953
David Howells63cb3442008-01-15 23:47:35 +0000954static int dummy_secctx_to_secid(char *secdata, u32 seclen, u32 *secid)
955{
956 return -EOPNOTSUPP;
957}
958
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700959static void dummy_release_secctx(char *secdata, u32 seclen)
960{
961}
962
David Howells29db9192005-10-30 15:02:44 -0800963#ifdef CONFIG_KEYS
David Howells7e047ef2006-06-26 00:24:50 -0700964static inline int dummy_key_alloc(struct key *key, struct task_struct *ctx,
965 unsigned long flags)
David Howells29db9192005-10-30 15:02:44 -0800966{
967 return 0;
968}
969
970static inline void dummy_key_free(struct key *key)
971{
972}
973
974static inline int dummy_key_permission(key_ref_t key_ref,
975 struct task_struct *context,
976 key_perm_t perm)
977{
978 return 0;
979}
980#endif /* CONFIG_KEYS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
982struct security_operations dummy_security_ops;
983
984#define set_to_dummy_if_null(ops, function) \
985 do { \
986 if (!ops->function) { \
987 ops->function = dummy_##function; \
988 pr_debug("Had to override the " #function \
989 " security operation with the dummy one.\n");\
990 } \
991 } while (0)
992
993void security_fixup_ops (struct security_operations *ops)
994{
995 set_to_dummy_if_null(ops, ptrace);
996 set_to_dummy_if_null(ops, capget);
997 set_to_dummy_if_null(ops, capset_check);
998 set_to_dummy_if_null(ops, capset_set);
999 set_to_dummy_if_null(ops, acct);
1000 set_to_dummy_if_null(ops, capable);
1001 set_to_dummy_if_null(ops, quotactl);
1002 set_to_dummy_if_null(ops, quota_on);
1003 set_to_dummy_if_null(ops, sysctl);
1004 set_to_dummy_if_null(ops, syslog);
1005 set_to_dummy_if_null(ops, settime);
1006 set_to_dummy_if_null(ops, vm_enough_memory);
1007 set_to_dummy_if_null(ops, bprm_alloc_security);
1008 set_to_dummy_if_null(ops, bprm_free_security);
1009 set_to_dummy_if_null(ops, bprm_apply_creds);
1010 set_to_dummy_if_null(ops, bprm_post_apply_creds);
1011 set_to_dummy_if_null(ops, bprm_set_security);
1012 set_to_dummy_if_null(ops, bprm_check_security);
1013 set_to_dummy_if_null(ops, bprm_secureexec);
1014 set_to_dummy_if_null(ops, sb_alloc_security);
1015 set_to_dummy_if_null(ops, sb_free_security);
1016 set_to_dummy_if_null(ops, sb_copy_data);
1017 set_to_dummy_if_null(ops, sb_kern_mount);
1018 set_to_dummy_if_null(ops, sb_statfs);
1019 set_to_dummy_if_null(ops, sb_mount);
1020 set_to_dummy_if_null(ops, sb_check_sb);
1021 set_to_dummy_if_null(ops, sb_umount);
1022 set_to_dummy_if_null(ops, sb_umount_close);
1023 set_to_dummy_if_null(ops, sb_umount_busy);
1024 set_to_dummy_if_null(ops, sb_post_remount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 set_to_dummy_if_null(ops, sb_post_addmount);
1026 set_to_dummy_if_null(ops, sb_pivotroot);
1027 set_to_dummy_if_null(ops, sb_post_pivotroot);
Eric Parisc9180a52007-11-30 13:00:35 -05001028 set_to_dummy_if_null(ops, sb_get_mnt_opts);
1029 set_to_dummy_if_null(ops, sb_set_mnt_opts);
1030 set_to_dummy_if_null(ops, sb_clone_mnt_opts);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 set_to_dummy_if_null(ops, inode_alloc_security);
1032 set_to_dummy_if_null(ops, inode_free_security);
Stephen Smalley5e41ff92005-09-09 13:01:35 -07001033 set_to_dummy_if_null(ops, inode_init_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 set_to_dummy_if_null(ops, inode_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 set_to_dummy_if_null(ops, inode_link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 set_to_dummy_if_null(ops, inode_unlink);
1037 set_to_dummy_if_null(ops, inode_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 set_to_dummy_if_null(ops, inode_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 set_to_dummy_if_null(ops, inode_rmdir);
1040 set_to_dummy_if_null(ops, inode_mknod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 set_to_dummy_if_null(ops, inode_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 set_to_dummy_if_null(ops, inode_readlink);
1043 set_to_dummy_if_null(ops, inode_follow_link);
1044 set_to_dummy_if_null(ops, inode_permission);
1045 set_to_dummy_if_null(ops, inode_setattr);
1046 set_to_dummy_if_null(ops, inode_getattr);
1047 set_to_dummy_if_null(ops, inode_delete);
1048 set_to_dummy_if_null(ops, inode_setxattr);
1049 set_to_dummy_if_null(ops, inode_post_setxattr);
1050 set_to_dummy_if_null(ops, inode_getxattr);
1051 set_to_dummy_if_null(ops, inode_listxattr);
1052 set_to_dummy_if_null(ops, inode_removexattr);
Serge E. Hallynb5376772007-10-16 23:31:36 -07001053 set_to_dummy_if_null(ops, inode_need_killpriv);
1054 set_to_dummy_if_null(ops, inode_killpriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 set_to_dummy_if_null(ops, inode_getsecurity);
1056 set_to_dummy_if_null(ops, inode_setsecurity);
1057 set_to_dummy_if_null(ops, inode_listsecurity);
1058 set_to_dummy_if_null(ops, file_permission);
1059 set_to_dummy_if_null(ops, file_alloc_security);
1060 set_to_dummy_if_null(ops, file_free_security);
1061 set_to_dummy_if_null(ops, file_ioctl);
1062 set_to_dummy_if_null(ops, file_mmap);
1063 set_to_dummy_if_null(ops, file_mprotect);
1064 set_to_dummy_if_null(ops, file_lock);
1065 set_to_dummy_if_null(ops, file_fcntl);
1066 set_to_dummy_if_null(ops, file_set_fowner);
1067 set_to_dummy_if_null(ops, file_send_sigiotask);
1068 set_to_dummy_if_null(ops, file_receive);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09001069 set_to_dummy_if_null(ops, dentry_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 set_to_dummy_if_null(ops, task_create);
1071 set_to_dummy_if_null(ops, task_alloc_security);
1072 set_to_dummy_if_null(ops, task_free_security);
1073 set_to_dummy_if_null(ops, task_setuid);
1074 set_to_dummy_if_null(ops, task_post_setuid);
1075 set_to_dummy_if_null(ops, task_setgid);
1076 set_to_dummy_if_null(ops, task_setpgid);
1077 set_to_dummy_if_null(ops, task_getpgid);
1078 set_to_dummy_if_null(ops, task_getsid);
David Quigleyf9008e42006-06-30 01:55:46 -07001079 set_to_dummy_if_null(ops, task_getsecid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 set_to_dummy_if_null(ops, task_setgroups);
1081 set_to_dummy_if_null(ops, task_setnice);
James Morris03e68062006-06-23 02:03:58 -07001082 set_to_dummy_if_null(ops, task_setioprio);
David Quigleya1836a42006-06-30 01:55:49 -07001083 set_to_dummy_if_null(ops, task_getioprio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 set_to_dummy_if_null(ops, task_setrlimit);
1085 set_to_dummy_if_null(ops, task_setscheduler);
1086 set_to_dummy_if_null(ops, task_getscheduler);
David Quigley35601542006-06-23 02:04:01 -07001087 set_to_dummy_if_null(ops, task_movememory);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 set_to_dummy_if_null(ops, task_wait);
1089 set_to_dummy_if_null(ops, task_kill);
1090 set_to_dummy_if_null(ops, task_prctl);
1091 set_to_dummy_if_null(ops, task_reparent_to_init);
1092 set_to_dummy_if_null(ops, task_to_inode);
1093 set_to_dummy_if_null(ops, ipc_permission);
1094 set_to_dummy_if_null(ops, msg_msg_alloc_security);
1095 set_to_dummy_if_null(ops, msg_msg_free_security);
1096 set_to_dummy_if_null(ops, msg_queue_alloc_security);
1097 set_to_dummy_if_null(ops, msg_queue_free_security);
1098 set_to_dummy_if_null(ops, msg_queue_associate);
1099 set_to_dummy_if_null(ops, msg_queue_msgctl);
1100 set_to_dummy_if_null(ops, msg_queue_msgsnd);
1101 set_to_dummy_if_null(ops, msg_queue_msgrcv);
1102 set_to_dummy_if_null(ops, shm_alloc_security);
1103 set_to_dummy_if_null(ops, shm_free_security);
1104 set_to_dummy_if_null(ops, shm_associate);
1105 set_to_dummy_if_null(ops, shm_shmctl);
1106 set_to_dummy_if_null(ops, shm_shmat);
1107 set_to_dummy_if_null(ops, sem_alloc_security);
1108 set_to_dummy_if_null(ops, sem_free_security);
1109 set_to_dummy_if_null(ops, sem_associate);
1110 set_to_dummy_if_null(ops, sem_semctl);
1111 set_to_dummy_if_null(ops, sem_semop);
1112 set_to_dummy_if_null(ops, netlink_send);
1113 set_to_dummy_if_null(ops, netlink_recv);
1114 set_to_dummy_if_null(ops, register_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 set_to_dummy_if_null(ops, d_instantiate);
1116 set_to_dummy_if_null(ops, getprocattr);
1117 set_to_dummy_if_null(ops, setprocattr);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001118 set_to_dummy_if_null(ops, secid_to_secctx);
David Howells63cb3442008-01-15 23:47:35 +00001119 set_to_dummy_if_null(ops, secctx_to_secid);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001120 set_to_dummy_if_null(ops, release_secctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121#ifdef CONFIG_SECURITY_NETWORK
1122 set_to_dummy_if_null(ops, unix_stream_connect);
1123 set_to_dummy_if_null(ops, unix_may_send);
1124 set_to_dummy_if_null(ops, socket_create);
1125 set_to_dummy_if_null(ops, socket_post_create);
1126 set_to_dummy_if_null(ops, socket_bind);
1127 set_to_dummy_if_null(ops, socket_connect);
1128 set_to_dummy_if_null(ops, socket_listen);
1129 set_to_dummy_if_null(ops, socket_accept);
1130 set_to_dummy_if_null(ops, socket_post_accept);
1131 set_to_dummy_if_null(ops, socket_sendmsg);
1132 set_to_dummy_if_null(ops, socket_recvmsg);
1133 set_to_dummy_if_null(ops, socket_getsockname);
1134 set_to_dummy_if_null(ops, socket_getpeername);
1135 set_to_dummy_if_null(ops, socket_setsockopt);
1136 set_to_dummy_if_null(ops, socket_getsockopt);
1137 set_to_dummy_if_null(ops, socket_shutdown);
1138 set_to_dummy_if_null(ops, socket_sock_rcv_skb);
Arnaldo Carvalho de Meloc841aa02006-03-20 22:47:37 -08001139 set_to_dummy_if_null(ops, socket_getpeersec_stream);
1140 set_to_dummy_if_null(ops, socket_getpeersec_dgram);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 set_to_dummy_if_null(ops, sk_alloc_security);
1142 set_to_dummy_if_null(ops, sk_free_security);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07001143 set_to_dummy_if_null(ops, sk_clone_security);
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001144 set_to_dummy_if_null(ops, sk_getsecid);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001145 set_to_dummy_if_null(ops, sock_graft);
1146 set_to_dummy_if_null(ops, inet_conn_request);
1147 set_to_dummy_if_null(ops, inet_csk_clone);
Venkat Yekkirala6b877692006-11-08 17:04:09 -06001148 set_to_dummy_if_null(ops, inet_conn_established);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001149 set_to_dummy_if_null(ops, req_classify_flow);
Trent Jaegerdf718372005-12-13 23:12:27 -08001150 #endif /* CONFIG_SECURITY_NETWORK */
1151#ifdef CONFIG_SECURITY_NETWORK_XFRM
1152 set_to_dummy_if_null(ops, xfrm_policy_alloc_security);
1153 set_to_dummy_if_null(ops, xfrm_policy_clone_security);
1154 set_to_dummy_if_null(ops, xfrm_policy_free_security);
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001155 set_to_dummy_if_null(ops, xfrm_policy_delete_security);
Trent Jaegerdf718372005-12-13 23:12:27 -08001156 set_to_dummy_if_null(ops, xfrm_state_alloc_security);
1157 set_to_dummy_if_null(ops, xfrm_state_free_security);
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001158 set_to_dummy_if_null(ops, xfrm_state_delete_security);
Trent Jaegerdf718372005-12-13 23:12:27 -08001159 set_to_dummy_if_null(ops, xfrm_policy_lookup);
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001160 set_to_dummy_if_null(ops, xfrm_state_pol_flow_match);
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001161 set_to_dummy_if_null(ops, xfrm_decode_session);
Trent Jaegerdf718372005-12-13 23:12:27 -08001162#endif /* CONFIG_SECURITY_NETWORK_XFRM */
David Howells29db9192005-10-30 15:02:44 -08001163#ifdef CONFIG_KEYS
1164 set_to_dummy_if_null(ops, key_alloc);
1165 set_to_dummy_if_null(ops, key_free);
1166 set_to_dummy_if_null(ops, key_permission);
1167#endif /* CONFIG_KEYS */
1168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169}
1170