dummy.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132
  1. /*
  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. #undef DEBUG
  15. #include <linux/capability.h>
  16. #include <linux/module.h>
  17. #include <linux/kernel.h>
  18. #include <linux/mman.h>
  19. #include <linux/pagemap.h>
  20. #include <linux/swap.h>
  21. #include <linux/security.h>
  22. #include <linux/skbuff.h>
  23. #include <linux/netlink.h>
  24. #include <net/sock.h>
  25. #include <linux/xattr.h>
  26. #include <linux/hugetlb.h>
  27. #include <linux/ptrace.h>
  28. #include <linux/file.h>
  29. static int dummy_ptrace (struct task_struct *parent, struct task_struct *child)
  30. {
  31. return 0;
  32. }
  33. static int dummy_capget (struct task_struct *target, kernel_cap_t * effective,
  34. kernel_cap_t * inheritable, kernel_cap_t * permitted)
  35. {
  36. *effective = *inheritable = *permitted = 0;
  37. if (!issecure(SECURE_NOROOT)) {
  38. if (target->euid == 0) {
  39. *permitted |= (~0 & ~CAP_FS_MASK);
  40. *effective |= (~0 & ~CAP_TO_MASK(CAP_SETPCAP) & ~CAP_FS_MASK);
  41. }
  42. if (target->fsuid == 0) {
  43. *permitted |= CAP_FS_MASK;
  44. *effective |= CAP_FS_MASK;
  45. }
  46. }
  47. return 0;
  48. }
  49. static int dummy_capset_check (struct task_struct *target,
  50. kernel_cap_t * effective,
  51. kernel_cap_t * inheritable,
  52. kernel_cap_t * permitted)
  53. {
  54. return -EPERM;
  55. }
  56. static void dummy_capset_set (struct task_struct *target,
  57. kernel_cap_t * effective,
  58. kernel_cap_t * inheritable,
  59. kernel_cap_t * permitted)
  60. {
  61. return;
  62. }
  63. static int dummy_acct (struct file *file)
  64. {
  65. return 0;
  66. }
  67. static int dummy_capable (struct task_struct *tsk, int cap)
  68. {
  69. if (cap_raised (tsk->cap_effective, cap))
  70. return 0;
  71. return -EPERM;
  72. }
  73. static int dummy_sysctl (ctl_table * table, int op)
  74. {
  75. return 0;
  76. }
  77. static int dummy_quotactl (int cmds, int type, int id, struct super_block *sb)
  78. {
  79. return 0;
  80. }
  81. static int dummy_quota_on (struct dentry *dentry)
  82. {
  83. return 0;
  84. }
  85. static int dummy_syslog (int type)
  86. {
  87. if ((type != 3 && type != 10) && current->euid)
  88. return -EPERM;
  89. return 0;
  90. }
  91. static int dummy_settime(struct timespec *ts, struct timezone *tz)
  92. {
  93. if (!capable(CAP_SYS_TIME))
  94. return -EPERM;
  95. return 0;
  96. }
  97. static int dummy_vm_enough_memory(long pages)
  98. {
  99. int cap_sys_admin = 0;
  100. if (dummy_capable(current, CAP_SYS_ADMIN) == 0)
  101. cap_sys_admin = 1;
  102. return __vm_enough_memory(pages, cap_sys_admin);
  103. }
  104. static int dummy_bprm_alloc_security (struct linux_binprm *bprm)
  105. {
  106. return 0;
  107. }
  108. static void dummy_bprm_free_security (struct linux_binprm *bprm)
  109. {
  110. return;
  111. }
  112. static void dummy_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
  113. {
  114. if (bprm->e_uid != current->uid || bprm->e_gid != current->gid) {
  115. current->mm->dumpable = suid_dumpable;
  116. if ((unsafe & ~LSM_UNSAFE_PTRACE_CAP) && !capable(CAP_SETUID)) {
  117. bprm->e_uid = current->uid;
  118. bprm->e_gid = current->gid;
  119. }
  120. }
  121. current->suid = current->euid = current->fsuid = bprm->e_uid;
  122. current->sgid = current->egid = current->fsgid = bprm->e_gid;
  123. dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
  124. }
  125. static void dummy_bprm_post_apply_creds (struct linux_binprm *bprm)
  126. {
  127. return;
  128. }
  129. static int dummy_bprm_set_security (struct linux_binprm *bprm)
  130. {
  131. return 0;
  132. }
  133. static int dummy_bprm_check_security (struct linux_binprm *bprm)
  134. {
  135. return 0;
  136. }
  137. static int dummy_bprm_secureexec (struct linux_binprm *bprm)
  138. {
  139. /* The new userland will simply use the value provided
  140. in the AT_SECURE field to decide whether secure mode
  141. is required. Hence, this logic is required to preserve
  142. the legacy decision algorithm used by the old userland. */
  143. return (current->euid != current->uid ||
  144. current->egid != current->gid);
  145. }
  146. static int dummy_sb_alloc_security (struct super_block *sb)
  147. {
  148. return 0;
  149. }
  150. static void dummy_sb_free_security (struct super_block *sb)
  151. {
  152. return;
  153. }
  154. static int dummy_sb_copy_data (struct file_system_type *type,
  155. void *orig, void *copy)
  156. {
  157. return 0;
  158. }
  159. static int dummy_sb_kern_mount (struct super_block *sb, void *data)
  160. {
  161. return 0;
  162. }
  163. static int dummy_sb_statfs (struct dentry *dentry)
  164. {
  165. return 0;
  166. }
  167. static int dummy_sb_mount (char *dev_name, struct nameidata *nd, char *type,
  168. unsigned long flags, void *data)
  169. {
  170. return 0;
  171. }
  172. static int dummy_sb_check_sb (struct vfsmount *mnt, struct nameidata *nd)
  173. {
  174. return 0;
  175. }
  176. static int dummy_sb_umount (struct vfsmount *mnt, int flags)
  177. {
  178. return 0;
  179. }
  180. static void dummy_sb_umount_close (struct vfsmount *mnt)
  181. {
  182. return;
  183. }
  184. static void dummy_sb_umount_busy (struct vfsmount *mnt)
  185. {
  186. return;
  187. }
  188. static void dummy_sb_post_remount (struct vfsmount *mnt, unsigned long flags,
  189. void *data)
  190. {
  191. return;
  192. }
  193. static void dummy_sb_post_mountroot (void)
  194. {
  195. return;
  196. }
  197. static void dummy_sb_post_addmount (struct vfsmount *mnt, struct nameidata *nd)
  198. {
  199. return;
  200. }
  201. static int dummy_sb_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
  202. {
  203. return 0;
  204. }
  205. static void dummy_sb_post_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
  206. {
  207. return;
  208. }
  209. static int dummy_inode_alloc_security (struct inode *inode)
  210. {
  211. return 0;
  212. }
  213. static void dummy_inode_free_security (struct inode *inode)
  214. {
  215. return;
  216. }
  217. static int dummy_inode_init_security (struct inode *inode, struct inode *dir,
  218. char **name, void **value, size_t *len)
  219. {
  220. return -EOPNOTSUPP;
  221. }
  222. static int dummy_inode_create (struct inode *inode, struct dentry *dentry,
  223. int mask)
  224. {
  225. return 0;
  226. }
  227. static int dummy_inode_link (struct dentry *old_dentry, struct inode *inode,
  228. struct dentry *new_dentry)
  229. {
  230. return 0;
  231. }
  232. static int dummy_inode_unlink (struct inode *inode, struct dentry *dentry)
  233. {
  234. return 0;
  235. }
  236. static int dummy_inode_symlink (struct inode *inode, struct dentry *dentry,
  237. const char *name)
  238. {
  239. return 0;
  240. }
  241. static int dummy_inode_mkdir (struct inode *inode, struct dentry *dentry,
  242. int mask)
  243. {
  244. return 0;
  245. }
  246. static int dummy_inode_rmdir (struct inode *inode, struct dentry *dentry)
  247. {
  248. return 0;
  249. }
  250. static int dummy_inode_mknod (struct inode *inode, struct dentry *dentry,
  251. int mode, dev_t dev)
  252. {
  253. return 0;
  254. }
  255. static int dummy_inode_rename (struct inode *old_inode,
  256. struct dentry *old_dentry,
  257. struct inode *new_inode,
  258. struct dentry *new_dentry)
  259. {
  260. return 0;
  261. }
  262. static int dummy_inode_readlink (struct dentry *dentry)
  263. {
  264. return 0;
  265. }
  266. static int dummy_inode_follow_link (struct dentry *dentry,
  267. struct nameidata *nameidata)
  268. {
  269. return 0;
  270. }
  271. static int dummy_inode_permission (struct inode *inode, int mask, struct nameidata *nd)
  272. {
  273. return 0;
  274. }
  275. static int dummy_inode_setattr (struct dentry *dentry, struct iattr *iattr)
  276. {
  277. return 0;
  278. }
  279. static int dummy_inode_getattr (struct vfsmount *mnt, struct dentry *dentry)
  280. {
  281. return 0;
  282. }
  283. static void dummy_inode_delete (struct inode *ino)
  284. {
  285. return;
  286. }
  287. static int dummy_inode_setxattr (struct dentry *dentry, char *name, void *value,
  288. size_t size, int flags)
  289. {
  290. if (!strncmp(name, XATTR_SECURITY_PREFIX,
  291. sizeof(XATTR_SECURITY_PREFIX) - 1) &&
  292. !capable(CAP_SYS_ADMIN))
  293. return -EPERM;
  294. return 0;
  295. }
  296. static void dummy_inode_post_setxattr (struct dentry *dentry, char *name, void *value,
  297. size_t size, int flags)
  298. {
  299. }
  300. static int dummy_inode_getxattr (struct dentry *dentry, char *name)
  301. {
  302. return 0;
  303. }
  304. static int dummy_inode_listxattr (struct dentry *dentry)
  305. {
  306. return 0;
  307. }
  308. static int dummy_inode_removexattr (struct dentry *dentry, char *name)
  309. {
  310. if (!strncmp(name, XATTR_SECURITY_PREFIX,
  311. sizeof(XATTR_SECURITY_PREFIX) - 1) &&
  312. !capable(CAP_SYS_ADMIN))
  313. return -EPERM;
  314. return 0;
  315. }
  316. static int dummy_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
  317. {
  318. return -EOPNOTSUPP;
  319. }
  320. static int dummy_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
  321. {
  322. return -EOPNOTSUPP;
  323. }
  324. static int dummy_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
  325. {
  326. return 0;
  327. }
  328. static const char *dummy_inode_xattr_getsuffix(void)
  329. {
  330. return NULL;
  331. }
  332. static int dummy_file_permission (struct file *file, int mask)
  333. {
  334. return 0;
  335. }
  336. static int dummy_file_alloc_security (struct file *file)
  337. {
  338. return 0;
  339. }
  340. static void dummy_file_free_security (struct file *file)
  341. {
  342. return;
  343. }
  344. static int dummy_file_ioctl (struct file *file, unsigned int command,
  345. unsigned long arg)
  346. {
  347. return 0;
  348. }
  349. static int dummy_file_mmap (struct file *file, unsigned long reqprot,
  350. unsigned long prot,
  351. unsigned long flags)
  352. {
  353. return 0;
  354. }
  355. static int dummy_file_mprotect (struct vm_area_struct *vma,
  356. unsigned long reqprot,
  357. unsigned long prot)
  358. {
  359. return 0;
  360. }
  361. static int dummy_file_lock (struct file *file, unsigned int cmd)
  362. {
  363. return 0;
  364. }
  365. static int dummy_file_fcntl (struct file *file, unsigned int cmd,
  366. unsigned long arg)
  367. {
  368. return 0;
  369. }
  370. static int dummy_file_set_fowner (struct file *file)
  371. {
  372. return 0;
  373. }
  374. static int dummy_file_send_sigiotask (struct task_struct *tsk,
  375. struct fown_struct *fown, int sig)
  376. {
  377. return 0;
  378. }
  379. static int dummy_file_receive (struct file *file)
  380. {
  381. return 0;
  382. }
  383. static int dummy_task_create (unsigned long clone_flags)
  384. {
  385. return 0;
  386. }
  387. static int dummy_task_alloc_security (struct task_struct *p)
  388. {
  389. return 0;
  390. }
  391. static void dummy_task_free_security (struct task_struct *p)
  392. {
  393. return;
  394. }
  395. static int dummy_task_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
  396. {
  397. return 0;
  398. }
  399. static int dummy_task_post_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
  400. {
  401. dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
  402. return 0;
  403. }
  404. static int dummy_task_setgid (gid_t id0, gid_t id1, gid_t id2, int flags)
  405. {
  406. return 0;
  407. }
  408. static int dummy_task_setpgid (struct task_struct *p, pid_t pgid)
  409. {
  410. return 0;
  411. }
  412. static int dummy_task_getpgid (struct task_struct *p)
  413. {
  414. return 0;
  415. }
  416. static int dummy_task_getsid (struct task_struct *p)
  417. {
  418. return 0;
  419. }
  420. static void dummy_task_getsecid (struct task_struct *p, u32 *secid)
  421. { }
  422. static int dummy_task_setgroups (struct group_info *group_info)
  423. {
  424. return 0;
  425. }
  426. static int dummy_task_setnice (struct task_struct *p, int nice)
  427. {
  428. return 0;
  429. }
  430. static int dummy_task_setioprio (struct task_struct *p, int ioprio)
  431. {
  432. return 0;
  433. }
  434. static int dummy_task_getioprio (struct task_struct *p)
  435. {
  436. return 0;
  437. }
  438. static int dummy_task_setrlimit (unsigned int resource, struct rlimit *new_rlim)
  439. {
  440. return 0;
  441. }
  442. static int dummy_task_setscheduler (struct task_struct *p, int policy,
  443. struct sched_param *lp)
  444. {
  445. return 0;
  446. }
  447. static int dummy_task_getscheduler (struct task_struct *p)
  448. {
  449. return 0;
  450. }
  451. static int dummy_task_movememory (struct task_struct *p)
  452. {
  453. return 0;
  454. }
  455. static int dummy_task_wait (struct task_struct *p)
  456. {
  457. return 0;
  458. }
  459. static int dummy_task_kill (struct task_struct *p, struct siginfo *info,
  460. int sig, u32 secid)
  461. {
  462. return 0;
  463. }
  464. static int dummy_task_prctl (int option, unsigned long arg2, unsigned long arg3,
  465. unsigned long arg4, unsigned long arg5)
  466. {
  467. return 0;
  468. }
  469. static void dummy_task_reparent_to_init (struct task_struct *p)
  470. {
  471. p->euid = p->fsuid = 0;
  472. return;
  473. }
  474. static void dummy_task_to_inode(struct task_struct *p, struct inode *inode)
  475. { }
  476. static int dummy_ipc_permission (struct kern_ipc_perm *ipcp, short flag)
  477. {
  478. return 0;
  479. }
  480. static int dummy_msg_msg_alloc_security (struct msg_msg *msg)
  481. {
  482. return 0;
  483. }
  484. static void dummy_msg_msg_free_security (struct msg_msg *msg)
  485. {
  486. return;
  487. }
  488. static int dummy_msg_queue_alloc_security (struct msg_queue *msq)
  489. {
  490. return 0;
  491. }
  492. static void dummy_msg_queue_free_security (struct msg_queue *msq)
  493. {
  494. return;
  495. }
  496. static int dummy_msg_queue_associate (struct msg_queue *msq,
  497. int msqflg)
  498. {
  499. return 0;
  500. }
  501. static int dummy_msg_queue_msgctl (struct msg_queue *msq, int cmd)
  502. {
  503. return 0;
  504. }
  505. static int dummy_msg_queue_msgsnd (struct msg_queue *msq, struct msg_msg *msg,
  506. int msgflg)
  507. {
  508. return 0;
  509. }
  510. static int dummy_msg_queue_msgrcv (struct msg_queue *msq, struct msg_msg *msg,
  511. struct task_struct *target, long type,
  512. int mode)
  513. {
  514. return 0;
  515. }
  516. static int dummy_shm_alloc_security (struct shmid_kernel *shp)
  517. {
  518. return 0;
  519. }
  520. static void dummy_shm_free_security (struct shmid_kernel *shp)
  521. {
  522. return;
  523. }
  524. static int dummy_shm_associate (struct shmid_kernel *shp, int shmflg)
  525. {
  526. return 0;
  527. }
  528. static int dummy_shm_shmctl (struct shmid_kernel *shp, int cmd)
  529. {
  530. return 0;
  531. }
  532. static int dummy_shm_shmat (struct shmid_kernel *shp, char __user *shmaddr,
  533. int shmflg)
  534. {
  535. return 0;
  536. }
  537. static int dummy_sem_alloc_security (struct sem_array *sma)
  538. {
  539. return 0;
  540. }
  541. static void dummy_sem_free_security (struct sem_array *sma)
  542. {
  543. return;
  544. }
  545. static int dummy_sem_associate (struct sem_array *sma, int semflg)
  546. {
  547. return 0;
  548. }
  549. static int dummy_sem_semctl (struct sem_array *sma, int cmd)
  550. {
  551. return 0;
  552. }
  553. static int dummy_sem_semop (struct sem_array *sma,
  554. struct sembuf *sops, unsigned nsops, int alter)
  555. {
  556. return 0;
  557. }
  558. static int dummy_netlink_send (struct sock *sk, struct sk_buff *skb)
  559. {
  560. NETLINK_CB(skb).eff_cap = current->cap_effective;
  561. return 0;
  562. }
  563. static int dummy_netlink_recv (struct sk_buff *skb, int cap)
  564. {
  565. if (!cap_raised (NETLINK_CB (skb).eff_cap, cap))
  566. return -EPERM;
  567. return 0;
  568. }
  569. #ifdef CONFIG_SECURITY_NETWORK
  570. static int dummy_unix_stream_connect (struct socket *sock,
  571. struct socket *other,
  572. struct sock *newsk)
  573. {
  574. return 0;
  575. }
  576. static int dummy_unix_may_send (struct socket *sock,
  577. struct socket *other)
  578. {
  579. return 0;
  580. }
  581. static int dummy_socket_create (int family, int type,
  582. int protocol, int kern)
  583. {
  584. return 0;
  585. }
  586. static int dummy_socket_post_create (struct socket *sock, int family, int type,
  587. int protocol, int kern)
  588. {
  589. return 0;
  590. }
  591. static int dummy_socket_bind (struct socket *sock, struct sockaddr *address,
  592. int addrlen)
  593. {
  594. return 0;
  595. }
  596. static int dummy_socket_connect (struct socket *sock, struct sockaddr *address,
  597. int addrlen)
  598. {
  599. return 0;
  600. }
  601. static int dummy_socket_listen (struct socket *sock, int backlog)
  602. {
  603. return 0;
  604. }
  605. static int dummy_socket_accept (struct socket *sock, struct socket *newsock)
  606. {
  607. return 0;
  608. }
  609. static void dummy_socket_post_accept (struct socket *sock,
  610. struct socket *newsock)
  611. {
  612. return;
  613. }
  614. static int dummy_socket_sendmsg (struct socket *sock, struct msghdr *msg,
  615. int size)
  616. {
  617. return 0;
  618. }
  619. static int dummy_socket_recvmsg (struct socket *sock, struct msghdr *msg,
  620. int size, int flags)
  621. {
  622. return 0;
  623. }
  624. static int dummy_socket_getsockname (struct socket *sock)
  625. {
  626. return 0;
  627. }
  628. static int dummy_socket_getpeername (struct socket *sock)
  629. {
  630. return 0;
  631. }
  632. static int dummy_socket_setsockopt (struct socket *sock, int level, int optname)
  633. {
  634. return 0;
  635. }
  636. static int dummy_socket_getsockopt (struct socket *sock, int level, int optname)
  637. {
  638. return 0;
  639. }
  640. static int dummy_socket_shutdown (struct socket *sock, int how)
  641. {
  642. return 0;
  643. }
  644. static int dummy_socket_sock_rcv_skb (struct sock *sk, struct sk_buff *skb)
  645. {
  646. return 0;
  647. }
  648. static int dummy_socket_getpeersec_stream(struct socket *sock, char __user *optval,
  649. int __user *optlen, unsigned len)
  650. {
  651. return -ENOPROTOOPT;
  652. }
  653. static int dummy_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
  654. {
  655. return -ENOPROTOOPT;
  656. }
  657. static inline int dummy_sk_alloc_security (struct sock *sk, int family, gfp_t priority)
  658. {
  659. return 0;
  660. }
  661. static inline void dummy_sk_free_security (struct sock *sk)
  662. {
  663. }
  664. static inline void dummy_sk_clone_security (const struct sock *sk, struct sock *newsk)
  665. {
  666. }
  667. static inline void dummy_sk_getsecid(struct sock *sk, u32 *secid)
  668. {
  669. }
  670. static inline void dummy_sock_graft(struct sock* sk, struct socket *parent)
  671. {
  672. }
  673. static inline int dummy_inet_conn_request(struct sock *sk,
  674. struct sk_buff *skb, struct request_sock *req)
  675. {
  676. return 0;
  677. }
  678. static inline void dummy_inet_csk_clone(struct sock *newsk,
  679. const struct request_sock *req)
  680. {
  681. }
  682. static inline void dummy_inet_conn_established(struct sock *sk,
  683. struct sk_buff *skb)
  684. {
  685. }
  686. static inline void dummy_req_classify_flow(const struct request_sock *req,
  687. struct flowi *fl)
  688. {
  689. }
  690. #endif /* CONFIG_SECURITY_NETWORK */
  691. #ifdef CONFIG_SECURITY_NETWORK_XFRM
  692. static int dummy_xfrm_policy_alloc_security(struct xfrm_policy *xp,
  693. struct xfrm_user_sec_ctx *sec_ctx)
  694. {
  695. return 0;
  696. }
  697. static inline int dummy_xfrm_policy_clone_security(struct xfrm_policy *old, struct xfrm_policy *new)
  698. {
  699. return 0;
  700. }
  701. static void dummy_xfrm_policy_free_security(struct xfrm_policy *xp)
  702. {
  703. }
  704. static int dummy_xfrm_policy_delete_security(struct xfrm_policy *xp)
  705. {
  706. return 0;
  707. }
  708. static int dummy_xfrm_state_alloc_security(struct xfrm_state *x,
  709. struct xfrm_user_sec_ctx *sec_ctx, u32 secid)
  710. {
  711. return 0;
  712. }
  713. static void dummy_xfrm_state_free_security(struct xfrm_state *x)
  714. {
  715. }
  716. static int dummy_xfrm_state_delete_security(struct xfrm_state *x)
  717. {
  718. return 0;
  719. }
  720. static int dummy_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir)
  721. {
  722. return 0;
  723. }
  724. static int dummy_xfrm_state_pol_flow_match(struct xfrm_state *x,
  725. struct xfrm_policy *xp, struct flowi *fl)
  726. {
  727. return 1;
  728. }
  729. static int dummy_xfrm_decode_session(struct sk_buff *skb, u32 *fl, int ckall)
  730. {
  731. return 0;
  732. }
  733. #endif /* CONFIG_SECURITY_NETWORK_XFRM */
  734. static int dummy_register_security (const char *name, struct security_operations *ops)
  735. {
  736. return -EINVAL;
  737. }
  738. static int dummy_unregister_security (const char *name, struct security_operations *ops)
  739. {
  740. return -EINVAL;
  741. }
  742. static void dummy_d_instantiate (struct dentry *dentry, struct inode *inode)
  743. {
  744. return;
  745. }
  746. static int dummy_getprocattr(struct task_struct *p, char *name, char **value)
  747. {
  748. return -EINVAL;
  749. }
  750. static int dummy_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
  751. {
  752. return -EINVAL;
  753. }
  754. static int dummy_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
  755. {
  756. return -EOPNOTSUPP;
  757. }
  758. static void dummy_release_secctx(char *secdata, u32 seclen)
  759. {
  760. }
  761. #ifdef CONFIG_KEYS
  762. static inline int dummy_key_alloc(struct key *key, struct task_struct *ctx,
  763. unsigned long flags)
  764. {
  765. return 0;
  766. }
  767. static inline void dummy_key_free(struct key *key)
  768. {
  769. }
  770. static inline int dummy_key_permission(key_ref_t key_ref,
  771. struct task_struct *context,
  772. key_perm_t perm)
  773. {
  774. return 0;
  775. }
  776. #endif /* CONFIG_KEYS */
  777. struct security_operations dummy_security_ops;
  778. #define set_to_dummy_if_null(ops, function) \
  779. do { \
  780. if (!ops->function) { \
  781. ops->function = dummy_##function; \
  782. pr_debug("Had to override the " #function \
  783. " security operation with the dummy one.\n");\
  784. } \
  785. } while (0)
  786. void security_fixup_ops (struct security_operations *ops)
  787. {
  788. set_to_dummy_if_null(ops, ptrace);
  789. set_to_dummy_if_null(ops, capget);
  790. set_to_dummy_if_null(ops, capset_check);
  791. set_to_dummy_if_null(ops, capset_set);
  792. set_to_dummy_if_null(ops, acct);
  793. set_to_dummy_if_null(ops, capable);
  794. set_to_dummy_if_null(ops, quotactl);
  795. set_to_dummy_if_null(ops, quota_on);
  796. set_to_dummy_if_null(ops, sysctl);
  797. set_to_dummy_if_null(ops, syslog);
  798. set_to_dummy_if_null(ops, settime);
  799. set_to_dummy_if_null(ops, vm_enough_memory);
  800. set_to_dummy_if_null(ops, bprm_alloc_security);
  801. set_to_dummy_if_null(ops, bprm_free_security);
  802. set_to_dummy_if_null(ops, bprm_apply_creds);
  803. set_to_dummy_if_null(ops, bprm_post_apply_creds);
  804. set_to_dummy_if_null(ops, bprm_set_security);
  805. set_to_dummy_if_null(ops, bprm_check_security);
  806. set_to_dummy_if_null(ops, bprm_secureexec);
  807. set_to_dummy_if_null(ops, sb_alloc_security);
  808. set_to_dummy_if_null(ops, sb_free_security);
  809. set_to_dummy_if_null(ops, sb_copy_data);
  810. set_to_dummy_if_null(ops, sb_kern_mount);
  811. set_to_dummy_if_null(ops, sb_statfs);
  812. set_to_dummy_if_null(ops, sb_mount);
  813. set_to_dummy_if_null(ops, sb_check_sb);
  814. set_to_dummy_if_null(ops, sb_umount);
  815. set_to_dummy_if_null(ops, sb_umount_close);
  816. set_to_dummy_if_null(ops, sb_umount_busy);
  817. set_to_dummy_if_null(ops, sb_post_remount);
  818. set_to_dummy_if_null(ops, sb_post_mountroot);
  819. set_to_dummy_if_null(ops, sb_post_addmount);
  820. set_to_dummy_if_null(ops, sb_pivotroot);
  821. set_to_dummy_if_null(ops, sb_post_pivotroot);
  822. set_to_dummy_if_null(ops, inode_alloc_security);
  823. set_to_dummy_if_null(ops, inode_free_security);
  824. set_to_dummy_if_null(ops, inode_init_security);
  825. set_to_dummy_if_null(ops, inode_create);
  826. set_to_dummy_if_null(ops, inode_link);
  827. set_to_dummy_if_null(ops, inode_unlink);
  828. set_to_dummy_if_null(ops, inode_symlink);
  829. set_to_dummy_if_null(ops, inode_mkdir);
  830. set_to_dummy_if_null(ops, inode_rmdir);
  831. set_to_dummy_if_null(ops, inode_mknod);
  832. set_to_dummy_if_null(ops, inode_rename);
  833. set_to_dummy_if_null(ops, inode_readlink);
  834. set_to_dummy_if_null(ops, inode_follow_link);
  835. set_to_dummy_if_null(ops, inode_permission);
  836. set_to_dummy_if_null(ops, inode_setattr);
  837. set_to_dummy_if_null(ops, inode_getattr);
  838. set_to_dummy_if_null(ops, inode_delete);
  839. set_to_dummy_if_null(ops, inode_setxattr);
  840. set_to_dummy_if_null(ops, inode_post_setxattr);
  841. set_to_dummy_if_null(ops, inode_getxattr);
  842. set_to_dummy_if_null(ops, inode_listxattr);
  843. set_to_dummy_if_null(ops, inode_removexattr);
  844. set_to_dummy_if_null(ops, inode_xattr_getsuffix);
  845. set_to_dummy_if_null(ops, inode_getsecurity);
  846. set_to_dummy_if_null(ops, inode_setsecurity);
  847. set_to_dummy_if_null(ops, inode_listsecurity);
  848. set_to_dummy_if_null(ops, file_permission);
  849. set_to_dummy_if_null(ops, file_alloc_security);
  850. set_to_dummy_if_null(ops, file_free_security);
  851. set_to_dummy_if_null(ops, file_ioctl);
  852. set_to_dummy_if_null(ops, file_mmap);
  853. set_to_dummy_if_null(ops, file_mprotect);
  854. set_to_dummy_if_null(ops, file_lock);
  855. set_to_dummy_if_null(ops, file_fcntl);
  856. set_to_dummy_if_null(ops, file_set_fowner);
  857. set_to_dummy_if_null(ops, file_send_sigiotask);
  858. set_to_dummy_if_null(ops, file_receive);
  859. set_to_dummy_if_null(ops, task_create);
  860. set_to_dummy_if_null(ops, task_alloc_security);
  861. set_to_dummy_if_null(ops, task_free_security);
  862. set_to_dummy_if_null(ops, task_setuid);
  863. set_to_dummy_if_null(ops, task_post_setuid);
  864. set_to_dummy_if_null(ops, task_setgid);
  865. set_to_dummy_if_null(ops, task_setpgid);
  866. set_to_dummy_if_null(ops, task_getpgid);
  867. set_to_dummy_if_null(ops, task_getsid);
  868. set_to_dummy_if_null(ops, task_getsecid);
  869. set_to_dummy_if_null(ops, task_setgroups);
  870. set_to_dummy_if_null(ops, task_setnice);
  871. set_to_dummy_if_null(ops, task_setioprio);
  872. set_to_dummy_if_null(ops, task_getioprio);
  873. set_to_dummy_if_null(ops, task_setrlimit);
  874. set_to_dummy_if_null(ops, task_setscheduler);
  875. set_to_dummy_if_null(ops, task_getscheduler);
  876. set_to_dummy_if_null(ops, task_movememory);
  877. set_to_dummy_if_null(ops, task_wait);
  878. set_to_dummy_if_null(ops, task_kill);
  879. set_to_dummy_if_null(ops, task_prctl);
  880. set_to_dummy_if_null(ops, task_reparent_to_init);
  881. set_to_dummy_if_null(ops, task_to_inode);
  882. set_to_dummy_if_null(ops, ipc_permission);
  883. set_to_dummy_if_null(ops, msg_msg_alloc_security);
  884. set_to_dummy_if_null(ops, msg_msg_free_security);
  885. set_to_dummy_if_null(ops, msg_queue_alloc_security);
  886. set_to_dummy_if_null(ops, msg_queue_free_security);
  887. set_to_dummy_if_null(ops, msg_queue_associate);
  888. set_to_dummy_if_null(ops, msg_queue_msgctl);
  889. set_to_dummy_if_null(ops, msg_queue_msgsnd);
  890. set_to_dummy_if_null(ops, msg_queue_msgrcv);
  891. set_to_dummy_if_null(ops, shm_alloc_security);
  892. set_to_dummy_if_null(ops, shm_free_security);
  893. set_to_dummy_if_null(ops, shm_associate);
  894. set_to_dummy_if_null(ops, shm_shmctl);
  895. set_to_dummy_if_null(ops, shm_shmat);
  896. set_to_dummy_if_null(ops, sem_alloc_security);
  897. set_to_dummy_if_null(ops, sem_free_security);
  898. set_to_dummy_if_null(ops, sem_associate);
  899. set_to_dummy_if_null(ops, sem_semctl);
  900. set_to_dummy_if_null(ops, sem_semop);
  901. set_to_dummy_if_null(ops, netlink_send);
  902. set_to_dummy_if_null(ops, netlink_recv);
  903. set_to_dummy_if_null(ops, register_security);
  904. set_to_dummy_if_null(ops, unregister_security);
  905. set_to_dummy_if_null(ops, d_instantiate);
  906. set_to_dummy_if_null(ops, getprocattr);
  907. set_to_dummy_if_null(ops, setprocattr);
  908. set_to_dummy_if_null(ops, secid_to_secctx);
  909. set_to_dummy_if_null(ops, release_secctx);
  910. #ifdef CONFIG_SECURITY_NETWORK
  911. set_to_dummy_if_null(ops, unix_stream_connect);
  912. set_to_dummy_if_null(ops, unix_may_send);
  913. set_to_dummy_if_null(ops, socket_create);
  914. set_to_dummy_if_null(ops, socket_post_create);
  915. set_to_dummy_if_null(ops, socket_bind);
  916. set_to_dummy_if_null(ops, socket_connect);
  917. set_to_dummy_if_null(ops, socket_listen);
  918. set_to_dummy_if_null(ops, socket_accept);
  919. set_to_dummy_if_null(ops, socket_post_accept);
  920. set_to_dummy_if_null(ops, socket_sendmsg);
  921. set_to_dummy_if_null(ops, socket_recvmsg);
  922. set_to_dummy_if_null(ops, socket_getsockname);
  923. set_to_dummy_if_null(ops, socket_getpeername);
  924. set_to_dummy_if_null(ops, socket_setsockopt);
  925. set_to_dummy_if_null(ops, socket_getsockopt);
  926. set_to_dummy_if_null(ops, socket_shutdown);
  927. set_to_dummy_if_null(ops, socket_sock_rcv_skb);
  928. set_to_dummy_if_null(ops, socket_getpeersec_stream);
  929. set_to_dummy_if_null(ops, socket_getpeersec_dgram);
  930. set_to_dummy_if_null(ops, sk_alloc_security);
  931. set_to_dummy_if_null(ops, sk_free_security);
  932. set_to_dummy_if_null(ops, sk_clone_security);
  933. set_to_dummy_if_null(ops, sk_getsecid);
  934. set_to_dummy_if_null(ops, sock_graft);
  935. set_to_dummy_if_null(ops, inet_conn_request);
  936. set_to_dummy_if_null(ops, inet_csk_clone);
  937. set_to_dummy_if_null(ops, inet_conn_established);
  938. set_to_dummy_if_null(ops, req_classify_flow);
  939. #endif /* CONFIG_SECURITY_NETWORK */
  940. #ifdef CONFIG_SECURITY_NETWORK_XFRM
  941. set_to_dummy_if_null(ops, xfrm_policy_alloc_security);
  942. set_to_dummy_if_null(ops, xfrm_policy_clone_security);
  943. set_to_dummy_if_null(ops, xfrm_policy_free_security);
  944. set_to_dummy_if_null(ops, xfrm_policy_delete_security);
  945. set_to_dummy_if_null(ops, xfrm_state_alloc_security);
  946. set_to_dummy_if_null(ops, xfrm_state_free_security);
  947. set_to_dummy_if_null(ops, xfrm_state_delete_security);
  948. set_to_dummy_if_null(ops, xfrm_policy_lookup);
  949. set_to_dummy_if_null(ops, xfrm_state_pol_flow_match);
  950. set_to_dummy_if_null(ops, xfrm_decode_session);
  951. #endif /* CONFIG_SECURITY_NETWORK_XFRM */
  952. #ifdef CONFIG_KEYS
  953. set_to_dummy_if_null(ops, key_alloc);
  954. set_to_dummy_if_null(ops, key_free);
  955. set_to_dummy_if_null(ops, key_permission);
  956. #endif /* CONFIG_KEYS */
  957. }