blob: d85b793c9321c5866a2f6bd2ce60cb5aaff42e17 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NSA Security-Enhanced Linux (SELinux) security module
3 *
4 * This file contains the SELinux hook function implementations.
5 *
6 * Authors: Stephen Smalley, <sds@epoch.ncsc.mil>
Eric Paris828dfe12008-04-17 13:17:49 -04007 * Chris Vance, <cvance@nai.com>
8 * Wayne Salamon, <wsalamon@nai.com>
9 * James Morris <jmorris@redhat.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * Copyright (C) 2001,2002 Networks Associates Technology, Inc.
Eric Paris2069f452008-07-04 09:47:13 +100012 * Copyright (C) 2003-2008 Red Hat, Inc., James Morris <jmorris@redhat.com>
13 * Eric Paris <eparis@redhat.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
Eric Paris828dfe12008-04-17 13:17:49 -040015 * <dgoeddel@trustedcs.com>
Paul Mooreed6d76e2009-08-28 18:12:49 -040016 * Copyright (C) 2006, 2007, 2009 Hewlett-Packard Development Company, L.P.
Paul Moore82c21bf2011-08-01 11:10:33 +000017 * Paul Moore <paul@paul-moore.com>
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +090018 * Copyright (C) 2007 Hitachi Software Engineering Co., Ltd.
Eric Paris828dfe12008-04-17 13:17:49 -040019 * Yuichi Nakamura <ynakam@hitachisoft.jp>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 *
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License version 2,
Eric Paris828dfe12008-04-17 13:17:49 -040023 * as published by the Free Software Foundation.
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 */
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/init.h>
Eric Paris0b24dcb2011-02-25 15:39:20 -050027#include <linux/kd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/kernel.h>
Roland McGrath0d094ef2008-07-25 19:45:49 -070029#include <linux/tracehook.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/errno.h>
31#include <linux/sched.h>
32#include <linux/security.h>
33#include <linux/xattr.h>
34#include <linux/capability.h>
35#include <linux/unistd.h>
36#include <linux/mm.h>
37#include <linux/mman.h>
38#include <linux/slab.h>
39#include <linux/pagemap.h>
Eric Paris0b24dcb2011-02-25 15:39:20 -050040#include <linux/proc_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/spinlock.h>
43#include <linux/syscalls.h>
Eric Paris2a7dba32011-02-01 11:05:39 -050044#include <linux/dcache.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040046#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/namei.h>
48#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/netfilter_ipv4.h>
50#include <linux/netfilter_ipv6.h>
51#include <linux/tty.h>
52#include <net/icmp.h>
Stephen Hemminger227b60f2007-10-10 17:30:46 -070053#include <net/ip.h> /* for local_port_range[] */
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <net/tcp.h> /* struct or_callable used in sock_rcv_skb */
Paul Moore220deb92008-01-29 08:38:23 -050055#include <net/net_namespace.h>
Paul Moored621d352008-01-29 08:43:36 -050056#include <net/netlabel.h>
Eric Parisf5269712008-05-14 11:27:45 -040057#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <asm/ioctls.h>
Arun Sharma60063492011-07-26 16:09:06 -070059#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#include <linux/bitops.h>
61#include <linux/interrupt.h>
62#include <linux/netdevice.h> /* for network interface checks */
63#include <linux/netlink.h>
64#include <linux/tcp.h>
65#include <linux/udp.h>
James Morris2ee92d42006-11-13 16:09:01 -080066#include <linux/dccp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/quota.h>
68#include <linux/un.h> /* for Unix socket types */
69#include <net/af_unix.h> /* for Unix socket types */
70#include <linux/parser.h>
71#include <linux/nfs_mount.h>
72#include <net/ipv6.h>
73#include <linux/hugetlb.h>
74#include <linux/personality.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#include <linux/audit.h>
Eric Paris6931dfc2005-06-30 02:58:51 -070076#include <linux/string.h>
Catherine Zhang877ce7c2006-06-29 12:27:47 -070077#include <linux/selinux.h>
Eric Paris23970742006-09-25 23:32:01 -070078#include <linux/mutex.h>
Frank Mayharf06febc2008-09-12 09:54:39 -070079#include <linux/posix-timers.h>
Kees Cook00234592010-02-03 15:36:43 -080080#include <linux/syslog.h>
Serge E. Hallyn34867402011-03-23 16:43:17 -070081#include <linux/user_namespace.h>
Paul Gortmaker44fc7ea2011-05-26 20:52:10 -040082#include <linux/export.h>
Al Viro40401532012-02-13 03:58:52 +000083#include <linux/msg.h>
84#include <linux/shm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86#include "avc.h"
87#include "objsec.h"
88#include "netif.h"
Paul Moore224dfbd2008-01-29 08:38:13 -050089#include "netnode.h"
Paul Moore3e112172008-04-10 10:48:14 -040090#include "netport.h"
Trent Jaegerd28d1e02005-12-13 23:12:40 -080091#include "xfrm.h"
Paul Moorec60475b2007-02-28 15:14:23 -050092#include "netlabel.h"
Ahmed S. Darwish9d57a7f2008-03-01 22:03:14 +020093#include "audit.h"
James Morris7b98a582011-08-30 12:52:32 +100094#include "avc_ss.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
David P. Quigley11689d42009-01-16 09:22:03 -050096#define NUM_SEL_MNT_OPTS 5
Eric Parisc9180a52007-11-30 13:00:35 -050097
James Morris20510f22007-10-16 23:31:32 -070098extern struct security_operations *security_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Paul Moored621d352008-01-29 08:43:36 -0500100/* SECMARK reference count */
James Morris56a4ca92011-08-17 11:08:43 +1000101static atomic_t selinux_secmark_refcount = ATOMIC_INIT(0);
Paul Moored621d352008-01-29 08:43:36 -0500102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103#ifdef CONFIG_SECURITY_SELINUX_DEVELOP
Eric Paris828dfe12008-04-17 13:17:49 -0400104int selinux_enforcing;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106static int __init enforcing_setup(char *str)
107{
Eric Parisf5269712008-05-14 11:27:45 -0400108 unsigned long enforcing;
109 if (!strict_strtoul(str, 0, &enforcing))
110 selinux_enforcing = enforcing ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 return 1;
112}
113__setup("enforcing=", enforcing_setup);
114#endif
115
116#ifdef CONFIG_SECURITY_SELINUX_BOOTPARAM
117int selinux_enabled = CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE;
118
119static int __init selinux_enabled_setup(char *str)
120{
Eric Parisf5269712008-05-14 11:27:45 -0400121 unsigned long enabled;
122 if (!strict_strtoul(str, 0, &enabled))
123 selinux_enabled = enabled ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return 1;
125}
126__setup("selinux=", selinux_enabled_setup);
Stephen Smalley30d55282006-05-03 10:52:36 -0400127#else
128int selinux_enabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129#endif
130
Christoph Lametere18b8902006-12-06 20:33:20 -0800131static struct kmem_cache *sel_inode_cache;
James Morris7cae7e22006-03-22 00:09:22 -0800132
Paul Moored621d352008-01-29 08:43:36 -0500133/**
134 * selinux_secmark_enabled - Check to see if SECMARK is currently enabled
135 *
136 * Description:
137 * This function checks the SECMARK reference counter to see if any SECMARK
138 * targets are currently configured, if the reference counter is greater than
139 * zero SECMARK is considered to be enabled. Returns true (1) if SECMARK is
140 * enabled, false (0) if SECMARK is disabled.
141 *
142 */
143static int selinux_secmark_enabled(void)
144{
145 return (atomic_read(&selinux_secmark_refcount) > 0);
146}
147
David Howellsd84f4f92008-11-14 10:39:23 +1100148/*
149 * initialise the security for the init task
150 */
151static void cred_init_security(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
David Howells3b11a1d2008-11-14 10:39:26 +1100153 struct cred *cred = (struct cred *) current->real_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 struct task_security_struct *tsec;
155
James Morris89d155e2005-10-30 14:59:21 -0800156 tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (!tsec)
David Howellsd84f4f92008-11-14 10:39:23 +1100158 panic("SELinux: Failed to initialize initial task.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
David Howellsd84f4f92008-11-14 10:39:23 +1100160 tsec->osid = tsec->sid = SECINITSID_KERNEL;
David Howellsf1752ee2008-11-14 10:39:17 +1100161 cred->security = tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
David Howells275bb412008-11-14 10:39:19 +1100164/*
David Howells88e67f32008-11-14 10:39:21 +1100165 * get the security ID of a set of credentials
166 */
167static inline u32 cred_sid(const struct cred *cred)
168{
169 const struct task_security_struct *tsec;
170
171 tsec = cred->security;
172 return tsec->sid;
173}
174
175/*
David Howells3b11a1d2008-11-14 10:39:26 +1100176 * get the objective security ID of a task
David Howells275bb412008-11-14 10:39:19 +1100177 */
178static inline u32 task_sid(const struct task_struct *task)
179{
David Howells275bb412008-11-14 10:39:19 +1100180 u32 sid;
181
182 rcu_read_lock();
David Howells88e67f32008-11-14 10:39:21 +1100183 sid = cred_sid(__task_cred(task));
David Howells275bb412008-11-14 10:39:19 +1100184 rcu_read_unlock();
185 return sid;
186}
187
188/*
David Howells3b11a1d2008-11-14 10:39:26 +1100189 * get the subjective security ID of the current task
David Howells275bb412008-11-14 10:39:19 +1100190 */
191static inline u32 current_sid(void)
192{
Paul Moore5fb49872010-04-22 14:46:19 -0400193 const struct task_security_struct *tsec = current_security();
David Howells275bb412008-11-14 10:39:19 +1100194
195 return tsec->sid;
196}
197
David Howells88e67f32008-11-14 10:39:21 +1100198/* Allocate and free functions for each kind of security blob. */
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200static int inode_alloc_security(struct inode *inode)
201{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 struct inode_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +1100203 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Josef Bacika02fe132008-04-04 09:35:05 +1100205 isec = kmem_cache_zalloc(sel_inode_cache, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (!isec)
207 return -ENOMEM;
208
Eric Paris23970742006-09-25 23:32:01 -0700209 mutex_init(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 INIT_LIST_HEAD(&isec->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 isec->inode = inode;
212 isec->sid = SECINITSID_UNLABELED;
213 isec->sclass = SECCLASS_FILE;
David Howells275bb412008-11-14 10:39:19 +1100214 isec->task_sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 inode->i_security = isec;
216
217 return 0;
218}
219
220static void inode_free_security(struct inode *inode)
221{
222 struct inode_security_struct *isec = inode->i_security;
223 struct superblock_security_struct *sbsec = inode->i_sb->s_security;
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 spin_lock(&sbsec->isec_lock);
226 if (!list_empty(&isec->list))
227 list_del_init(&isec->list);
228 spin_unlock(&sbsec->isec_lock);
229
230 inode->i_security = NULL;
James Morris7cae7e22006-03-22 00:09:22 -0800231 kmem_cache_free(sel_inode_cache, isec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
233
234static int file_alloc_security(struct file *file)
235{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 struct file_security_struct *fsec;
David Howells275bb412008-11-14 10:39:19 +1100237 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Stephen Smalley26d2a4b2006-02-01 03:05:55 -0800239 fsec = kzalloc(sizeof(struct file_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 if (!fsec)
241 return -ENOMEM;
242
David Howells275bb412008-11-14 10:39:19 +1100243 fsec->sid = sid;
244 fsec->fown_sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 file->f_security = fsec;
246
247 return 0;
248}
249
250static void file_free_security(struct file *file)
251{
252 struct file_security_struct *fsec = file->f_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 file->f_security = NULL;
254 kfree(fsec);
255}
256
257static int superblock_alloc_security(struct super_block *sb)
258{
259 struct superblock_security_struct *sbsec;
260
James Morris89d155e2005-10-30 14:59:21 -0800261 sbsec = kzalloc(sizeof(struct superblock_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 if (!sbsec)
263 return -ENOMEM;
264
Eric Parisbc7e9822006-09-25 23:32:02 -0700265 mutex_init(&sbsec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 INIT_LIST_HEAD(&sbsec->isec_head);
267 spin_lock_init(&sbsec->isec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 sbsec->sb = sb;
269 sbsec->sid = SECINITSID_UNLABELED;
270 sbsec->def_sid = SECINITSID_FILE;
Eric Parisc312feb2006-07-10 04:43:53 -0700271 sbsec->mntpoint_sid = SECINITSID_UNLABELED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 sb->s_security = sbsec;
273
274 return 0;
275}
276
277static void superblock_free_security(struct super_block *sb)
278{
279 struct superblock_security_struct *sbsec = sb->s_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 sb->s_security = NULL;
281 kfree(sbsec);
282}
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284/* The file system's label must be initialized prior to use. */
285
Stephen Hemminger634a5392010-03-04 21:59:03 -0800286static const char *labeling_behaviors[6] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 "uses xattr",
288 "uses transition SIDs",
289 "uses task SIDs",
290 "uses genfs_contexts",
291 "not configured for labeling",
292 "uses mountpoint labeling",
293};
294
295static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry);
296
297static inline int inode_doinit(struct inode *inode)
298{
299 return inode_doinit_with_dentry(inode, NULL);
300}
301
302enum {
Eric Paris31e87932007-09-19 17:19:12 -0400303 Opt_error = -1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 Opt_context = 1,
305 Opt_fscontext = 2,
Eric Parisc9180a52007-11-30 13:00:35 -0500306 Opt_defcontext = 3,
307 Opt_rootcontext = 4,
David P. Quigley11689d42009-01-16 09:22:03 -0500308 Opt_labelsupport = 5,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309};
310
Steven Whitehousea447c092008-10-13 10:46:57 +0100311static const match_table_t tokens = {
Eric Paris832cbd92008-04-01 13:24:09 -0400312 {Opt_context, CONTEXT_STR "%s"},
313 {Opt_fscontext, FSCONTEXT_STR "%s"},
314 {Opt_defcontext, DEFCONTEXT_STR "%s"},
315 {Opt_rootcontext, ROOTCONTEXT_STR "%s"},
David P. Quigley11689d42009-01-16 09:22:03 -0500316 {Opt_labelsupport, LABELSUPP_STR},
Eric Paris31e87932007-09-19 17:19:12 -0400317 {Opt_error, NULL},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318};
319
320#define SEL_MOUNT_FAIL_MSG "SELinux: duplicate or incompatible mount options\n"
321
Eric Parisc312feb2006-07-10 04:43:53 -0700322static int may_context_mount_sb_relabel(u32 sid,
323 struct superblock_security_struct *sbsec,
David Howells275bb412008-11-14 10:39:19 +1100324 const struct cred *cred)
Eric Parisc312feb2006-07-10 04:43:53 -0700325{
David Howells275bb412008-11-14 10:39:19 +1100326 const struct task_security_struct *tsec = cred->security;
Eric Parisc312feb2006-07-10 04:43:53 -0700327 int rc;
328
329 rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
330 FILESYSTEM__RELABELFROM, NULL);
331 if (rc)
332 return rc;
333
334 rc = avc_has_perm(tsec->sid, sid, SECCLASS_FILESYSTEM,
335 FILESYSTEM__RELABELTO, NULL);
336 return rc;
337}
338
Eric Paris08089252006-07-10 04:43:55 -0700339static int may_context_mount_inode_relabel(u32 sid,
340 struct superblock_security_struct *sbsec,
David Howells275bb412008-11-14 10:39:19 +1100341 const struct cred *cred)
Eric Paris08089252006-07-10 04:43:55 -0700342{
David Howells275bb412008-11-14 10:39:19 +1100343 const struct task_security_struct *tsec = cred->security;
Eric Paris08089252006-07-10 04:43:55 -0700344 int rc;
345 rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
346 FILESYSTEM__RELABELFROM, NULL);
347 if (rc)
348 return rc;
349
350 rc = avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM,
351 FILESYSTEM__ASSOCIATE, NULL);
352 return rc;
353}
354
Eric Parisc9180a52007-11-30 13:00:35 -0500355static int sb_finish_set_opts(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
357 struct superblock_security_struct *sbsec = sb->s_security;
358 struct dentry *root = sb->s_root;
Eric Parisc9180a52007-11-30 13:00:35 -0500359 struct inode *root_inode = root->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 int rc = 0;
361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
363 /* Make sure that the xattr handler exists and that no
364 error other than -ENODATA is returned by getxattr on
365 the root directory. -ENODATA is ok, as this may be
366 the first boot of the SELinux kernel before we have
367 assigned xattr values to the filesystem. */
Eric Parisc9180a52007-11-30 13:00:35 -0500368 if (!root_inode->i_op->getxattr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
370 "xattr support\n", sb->s_id, sb->s_type->name);
371 rc = -EOPNOTSUPP;
372 goto out;
373 }
Eric Parisc9180a52007-11-30 13:00:35 -0500374 rc = root_inode->i_op->getxattr(root, XATTR_NAME_SELINUX, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 if (rc < 0 && rc != -ENODATA) {
376 if (rc == -EOPNOTSUPP)
377 printk(KERN_WARNING "SELinux: (dev %s, type "
378 "%s) has no security xattr handler\n",
379 sb->s_id, sb->s_type->name);
380 else
381 printk(KERN_WARNING "SELinux: (dev %s, type "
382 "%s) getxattr errno %d\n", sb->s_id,
383 sb->s_type->name, -rc);
384 goto out;
385 }
386 }
387
David P. Quigley11689d42009-01-16 09:22:03 -0500388 sbsec->flags |= (SE_SBINITIALIZED | SE_SBLABELSUPP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Eric Parisc9180a52007-11-30 13:00:35 -0500390 if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
Eric Parisfadcdb42007-02-22 18:11:31 -0500391 printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 sb->s_id, sb->s_type->name);
Eric Parisc9180a52007-11-30 13:00:35 -0500393 else
Eric Parisfadcdb42007-02-22 18:11:31 -0500394 printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 sb->s_id, sb->s_type->name,
396 labeling_behaviors[sbsec->behavior-1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
David P. Quigley11689d42009-01-16 09:22:03 -0500398 if (sbsec->behavior == SECURITY_FS_USE_GENFS ||
399 sbsec->behavior == SECURITY_FS_USE_MNTPOINT ||
400 sbsec->behavior == SECURITY_FS_USE_NONE ||
401 sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
402 sbsec->flags &= ~SE_SBLABELSUPP;
403
David P. Quigleyddd29ec2009-09-09 14:25:37 -0400404 /* Special handling for sysfs. Is genfs but also has setxattr handler*/
405 if (strncmp(sb->s_type->name, "sysfs", sizeof("sysfs")) == 0)
406 sbsec->flags |= SE_SBLABELSUPP;
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 /* Initialize the root inode. */
Eric Parisc9180a52007-11-30 13:00:35 -0500409 rc = inode_doinit_with_dentry(root_inode, root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 /* Initialize any other inodes associated with the superblock, e.g.
412 inodes created prior to initial policy load or inodes created
413 during get_sb by a pseudo filesystem that directly
414 populates itself. */
415 spin_lock(&sbsec->isec_lock);
416next_inode:
417 if (!list_empty(&sbsec->isec_head)) {
418 struct inode_security_struct *isec =
419 list_entry(sbsec->isec_head.next,
Eric Parisc9180a52007-11-30 13:00:35 -0500420 struct inode_security_struct, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 struct inode *inode = isec->inode;
422 spin_unlock(&sbsec->isec_lock);
423 inode = igrab(inode);
424 if (inode) {
Eric Parisc9180a52007-11-30 13:00:35 -0500425 if (!IS_PRIVATE(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 inode_doinit(inode);
427 iput(inode);
428 }
429 spin_lock(&sbsec->isec_lock);
430 list_del_init(&isec->list);
431 goto next_inode;
432 }
433 spin_unlock(&sbsec->isec_lock);
434out:
Eric Parisc9180a52007-11-30 13:00:35 -0500435 return rc;
436}
437
438/*
439 * This function should allow an FS to ask what it's mount security
440 * options were so it can use those later for submounts, displaying
441 * mount options, or whatever.
442 */
443static int selinux_get_mnt_opts(const struct super_block *sb,
Eric Parise0007522008-03-05 10:31:54 -0500444 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500445{
446 int rc = 0, i;
447 struct superblock_security_struct *sbsec = sb->s_security;
448 char *context = NULL;
449 u32 len;
450 char tmp;
451
Eric Parise0007522008-03-05 10:31:54 -0500452 security_init_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500453
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500454 if (!(sbsec->flags & SE_SBINITIALIZED))
Eric Parisc9180a52007-11-30 13:00:35 -0500455 return -EINVAL;
456
457 if (!ss_initialized)
458 return -EINVAL;
459
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500460 tmp = sbsec->flags & SE_MNTMASK;
Eric Parisc9180a52007-11-30 13:00:35 -0500461 /* count the number of mount options for this sb */
462 for (i = 0; i < 8; i++) {
463 if (tmp & 0x01)
Eric Parise0007522008-03-05 10:31:54 -0500464 opts->num_mnt_opts++;
Eric Parisc9180a52007-11-30 13:00:35 -0500465 tmp >>= 1;
466 }
David P. Quigley11689d42009-01-16 09:22:03 -0500467 /* Check if the Label support flag is set */
468 if (sbsec->flags & SE_SBLABELSUPP)
469 opts->num_mnt_opts++;
Eric Parisc9180a52007-11-30 13:00:35 -0500470
Eric Parise0007522008-03-05 10:31:54 -0500471 opts->mnt_opts = kcalloc(opts->num_mnt_opts, sizeof(char *), GFP_ATOMIC);
472 if (!opts->mnt_opts) {
Eric Parisc9180a52007-11-30 13:00:35 -0500473 rc = -ENOMEM;
474 goto out_free;
475 }
476
Eric Parise0007522008-03-05 10:31:54 -0500477 opts->mnt_opts_flags = kcalloc(opts->num_mnt_opts, sizeof(int), GFP_ATOMIC);
478 if (!opts->mnt_opts_flags) {
Eric Parisc9180a52007-11-30 13:00:35 -0500479 rc = -ENOMEM;
480 goto out_free;
481 }
482
483 i = 0;
484 if (sbsec->flags & FSCONTEXT_MNT) {
485 rc = security_sid_to_context(sbsec->sid, &context, &len);
486 if (rc)
487 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500488 opts->mnt_opts[i] = context;
489 opts->mnt_opts_flags[i++] = FSCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500490 }
491 if (sbsec->flags & CONTEXT_MNT) {
492 rc = security_sid_to_context(sbsec->mntpoint_sid, &context, &len);
493 if (rc)
494 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500495 opts->mnt_opts[i] = context;
496 opts->mnt_opts_flags[i++] = CONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500497 }
498 if (sbsec->flags & DEFCONTEXT_MNT) {
499 rc = security_sid_to_context(sbsec->def_sid, &context, &len);
500 if (rc)
501 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500502 opts->mnt_opts[i] = context;
503 opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500504 }
505 if (sbsec->flags & ROOTCONTEXT_MNT) {
506 struct inode *root = sbsec->sb->s_root->d_inode;
507 struct inode_security_struct *isec = root->i_security;
508
509 rc = security_sid_to_context(isec->sid, &context, &len);
510 if (rc)
511 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500512 opts->mnt_opts[i] = context;
513 opts->mnt_opts_flags[i++] = ROOTCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500514 }
David P. Quigley11689d42009-01-16 09:22:03 -0500515 if (sbsec->flags & SE_SBLABELSUPP) {
516 opts->mnt_opts[i] = NULL;
517 opts->mnt_opts_flags[i++] = SE_SBLABELSUPP;
518 }
Eric Parisc9180a52007-11-30 13:00:35 -0500519
Eric Parise0007522008-03-05 10:31:54 -0500520 BUG_ON(i != opts->num_mnt_opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500521
522 return 0;
523
524out_free:
Eric Parise0007522008-03-05 10:31:54 -0500525 security_free_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500526 return rc;
527}
528
529static int bad_option(struct superblock_security_struct *sbsec, char flag,
530 u32 old_sid, u32 new_sid)
531{
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500532 char mnt_flags = sbsec->flags & SE_MNTMASK;
533
Eric Parisc9180a52007-11-30 13:00:35 -0500534 /* check if the old mount command had the same options */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500535 if (sbsec->flags & SE_SBINITIALIZED)
Eric Parisc9180a52007-11-30 13:00:35 -0500536 if (!(sbsec->flags & flag) ||
537 (old_sid != new_sid))
538 return 1;
539
540 /* check if we were passed the same options twice,
541 * aka someone passed context=a,context=b
542 */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500543 if (!(sbsec->flags & SE_SBINITIALIZED))
544 if (mnt_flags & flag)
Eric Parisc9180a52007-11-30 13:00:35 -0500545 return 1;
546 return 0;
547}
Eric Parise0007522008-03-05 10:31:54 -0500548
Eric Parisc9180a52007-11-30 13:00:35 -0500549/*
550 * Allow filesystems with binary mount data to explicitly set mount point
551 * labeling information.
552 */
Eric Parise0007522008-03-05 10:31:54 -0500553static int selinux_set_mnt_opts(struct super_block *sb,
554 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500555{
David Howells275bb412008-11-14 10:39:19 +1100556 const struct cred *cred = current_cred();
Eric Parisc9180a52007-11-30 13:00:35 -0500557 int rc = 0, i;
Eric Parisc9180a52007-11-30 13:00:35 -0500558 struct superblock_security_struct *sbsec = sb->s_security;
559 const char *name = sb->s_type->name;
James Morris089be432008-07-15 18:32:49 +1000560 struct inode *inode = sbsec->sb->s_root->d_inode;
561 struct inode_security_struct *root_isec = inode->i_security;
Eric Parisc9180a52007-11-30 13:00:35 -0500562 u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
563 u32 defcontext_sid = 0;
Eric Parise0007522008-03-05 10:31:54 -0500564 char **mount_options = opts->mnt_opts;
565 int *flags = opts->mnt_opts_flags;
566 int num_opts = opts->num_mnt_opts;
Eric Parisc9180a52007-11-30 13:00:35 -0500567
568 mutex_lock(&sbsec->lock);
569
570 if (!ss_initialized) {
571 if (!num_opts) {
572 /* Defer initialization until selinux_complete_init,
573 after the initial policy is loaded and the security
574 server is ready to handle calls. */
Eric Parisc9180a52007-11-30 13:00:35 -0500575 goto out;
576 }
577 rc = -EINVAL;
Eric Paris744ba352008-04-17 11:52:44 -0400578 printk(KERN_WARNING "SELinux: Unable to set superblock options "
579 "before the security server is initialized\n");
Eric Parisc9180a52007-11-30 13:00:35 -0500580 goto out;
581 }
582
583 /*
Eric Parise0007522008-03-05 10:31:54 -0500584 * Binary mount data FS will come through this function twice. Once
585 * from an explicit call and once from the generic calls from the vfs.
586 * Since the generic VFS calls will not contain any security mount data
587 * we need to skip the double mount verification.
588 *
589 * This does open a hole in which we will not notice if the first
590 * mount using this sb set explict options and a second mount using
591 * this sb does not set any security options. (The first options
592 * will be used for both mounts)
593 */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500594 if ((sbsec->flags & SE_SBINITIALIZED) && (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
Eric Parise0007522008-03-05 10:31:54 -0500595 && (num_opts == 0))
Eric Parisf5269712008-05-14 11:27:45 -0400596 goto out;
Eric Parise0007522008-03-05 10:31:54 -0500597
598 /*
Eric Parisc9180a52007-11-30 13:00:35 -0500599 * parse the mount options, check if they are valid sids.
600 * also check if someone is trying to mount the same sb more
601 * than once with different security options.
602 */
603 for (i = 0; i < num_opts; i++) {
604 u32 sid;
David P. Quigley11689d42009-01-16 09:22:03 -0500605
606 if (flags[i] == SE_SBLABELSUPP)
607 continue;
Eric Parisc9180a52007-11-30 13:00:35 -0500608 rc = security_context_to_sid(mount_options[i],
609 strlen(mount_options[i]), &sid);
610 if (rc) {
611 printk(KERN_WARNING "SELinux: security_context_to_sid"
612 "(%s) failed for (dev %s, type %s) errno=%d\n",
613 mount_options[i], sb->s_id, name, rc);
614 goto out;
615 }
616 switch (flags[i]) {
617 case FSCONTEXT_MNT:
618 fscontext_sid = sid;
619
620 if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid,
621 fscontext_sid))
622 goto out_double_mount;
623
624 sbsec->flags |= FSCONTEXT_MNT;
625 break;
626 case CONTEXT_MNT:
627 context_sid = sid;
628
629 if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid,
630 context_sid))
631 goto out_double_mount;
632
633 sbsec->flags |= CONTEXT_MNT;
634 break;
635 case ROOTCONTEXT_MNT:
636 rootcontext_sid = sid;
637
638 if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid,
639 rootcontext_sid))
640 goto out_double_mount;
641
642 sbsec->flags |= ROOTCONTEXT_MNT;
643
644 break;
645 case DEFCONTEXT_MNT:
646 defcontext_sid = sid;
647
648 if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid,
649 defcontext_sid))
650 goto out_double_mount;
651
652 sbsec->flags |= DEFCONTEXT_MNT;
653
654 break;
655 default:
656 rc = -EINVAL;
657 goto out;
658 }
659 }
660
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500661 if (sbsec->flags & SE_SBINITIALIZED) {
Eric Parisc9180a52007-11-30 13:00:35 -0500662 /* previously mounted with options, but not on this attempt? */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500663 if ((sbsec->flags & SE_MNTMASK) && !num_opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500664 goto out_double_mount;
665 rc = 0;
666 goto out;
667 }
668
James Morris089be432008-07-15 18:32:49 +1000669 if (strcmp(sb->s_type->name, "proc") == 0)
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500670 sbsec->flags |= SE_SBPROC;
Eric Parisc9180a52007-11-30 13:00:35 -0500671
672 /* Determine the labeling behavior to use for this filesystem type. */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500673 rc = security_fs_use((sbsec->flags & SE_SBPROC) ? "proc" : sb->s_type->name, &sbsec->behavior, &sbsec->sid);
Eric Parisc9180a52007-11-30 13:00:35 -0500674 if (rc) {
675 printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n",
James Morris089be432008-07-15 18:32:49 +1000676 __func__, sb->s_type->name, rc);
Eric Parisc9180a52007-11-30 13:00:35 -0500677 goto out;
678 }
679
680 /* sets the context of the superblock for the fs being mounted. */
681 if (fscontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100682 rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500683 if (rc)
684 goto out;
685
686 sbsec->sid = fscontext_sid;
687 }
688
689 /*
690 * Switch to using mount point labeling behavior.
691 * sets the label used on all file below the mountpoint, and will set
692 * the superblock context if not already set.
693 */
694 if (context_sid) {
695 if (!fscontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100696 rc = may_context_mount_sb_relabel(context_sid, sbsec,
697 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500698 if (rc)
699 goto out;
700 sbsec->sid = context_sid;
701 } else {
David Howells275bb412008-11-14 10:39:19 +1100702 rc = may_context_mount_inode_relabel(context_sid, sbsec,
703 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500704 if (rc)
705 goto out;
706 }
707 if (!rootcontext_sid)
708 rootcontext_sid = context_sid;
709
710 sbsec->mntpoint_sid = context_sid;
711 sbsec->behavior = SECURITY_FS_USE_MNTPOINT;
712 }
713
714 if (rootcontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100715 rc = may_context_mount_inode_relabel(rootcontext_sid, sbsec,
716 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500717 if (rc)
718 goto out;
719
720 root_isec->sid = rootcontext_sid;
721 root_isec->initialized = 1;
722 }
723
724 if (defcontext_sid) {
725 if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
726 rc = -EINVAL;
727 printk(KERN_WARNING "SELinux: defcontext option is "
728 "invalid for this filesystem type\n");
729 goto out;
730 }
731
732 if (defcontext_sid != sbsec->def_sid) {
733 rc = may_context_mount_inode_relabel(defcontext_sid,
David Howells275bb412008-11-14 10:39:19 +1100734 sbsec, cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500735 if (rc)
736 goto out;
737 }
738
739 sbsec->def_sid = defcontext_sid;
740 }
741
742 rc = sb_finish_set_opts(sb);
743out:
Eric Parisbc7e9822006-09-25 23:32:02 -0700744 mutex_unlock(&sbsec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 return rc;
Eric Parisc9180a52007-11-30 13:00:35 -0500746out_double_mount:
747 rc = -EINVAL;
748 printk(KERN_WARNING "SELinux: mount invalid. Same superblock, different "
749 "security settings for (dev %s, type %s)\n", sb->s_id, name);
750 goto out;
751}
752
753static void selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
754 struct super_block *newsb)
755{
756 const struct superblock_security_struct *oldsbsec = oldsb->s_security;
757 struct superblock_security_struct *newsbsec = newsb->s_security;
758
759 int set_fscontext = (oldsbsec->flags & FSCONTEXT_MNT);
760 int set_context = (oldsbsec->flags & CONTEXT_MNT);
761 int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT);
762
Eric Paris0f5e6422008-04-21 16:24:11 -0400763 /*
764 * if the parent was able to be mounted it clearly had no special lsm
Al Viroe8c26252010-03-23 06:36:54 -0400765 * mount options. thus we can safely deal with this superblock later
Eric Paris0f5e6422008-04-21 16:24:11 -0400766 */
Al Viroe8c26252010-03-23 06:36:54 -0400767 if (!ss_initialized)
Eric Paris0f5e6422008-04-21 16:24:11 -0400768 return;
Eric Parisc9180a52007-11-30 13:00:35 -0500769
Eric Parisc9180a52007-11-30 13:00:35 -0500770 /* how can we clone if the old one wasn't set up?? */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500771 BUG_ON(!(oldsbsec->flags & SE_SBINITIALIZED));
Eric Parisc9180a52007-11-30 13:00:35 -0500772
Eric Paris5a552612008-04-09 14:08:35 -0400773 /* if fs is reusing a sb, just let its options stand... */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500774 if (newsbsec->flags & SE_SBINITIALIZED)
Eric Paris5a552612008-04-09 14:08:35 -0400775 return;
776
Eric Parisc9180a52007-11-30 13:00:35 -0500777 mutex_lock(&newsbsec->lock);
778
779 newsbsec->flags = oldsbsec->flags;
780
781 newsbsec->sid = oldsbsec->sid;
782 newsbsec->def_sid = oldsbsec->def_sid;
783 newsbsec->behavior = oldsbsec->behavior;
784
785 if (set_context) {
786 u32 sid = oldsbsec->mntpoint_sid;
787
788 if (!set_fscontext)
789 newsbsec->sid = sid;
790 if (!set_rootcontext) {
791 struct inode *newinode = newsb->s_root->d_inode;
792 struct inode_security_struct *newisec = newinode->i_security;
793 newisec->sid = sid;
794 }
795 newsbsec->mntpoint_sid = sid;
796 }
797 if (set_rootcontext) {
798 const struct inode *oldinode = oldsb->s_root->d_inode;
799 const struct inode_security_struct *oldisec = oldinode->i_security;
800 struct inode *newinode = newsb->s_root->d_inode;
801 struct inode_security_struct *newisec = newinode->i_security;
802
803 newisec->sid = oldisec->sid;
804 }
805
806 sb_finish_set_opts(newsb);
807 mutex_unlock(&newsbsec->lock);
808}
809
Adrian Bunk2e1479d2008-03-17 22:29:23 +0200810static int selinux_parse_opts_str(char *options,
811 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500812{
Eric Parise0007522008-03-05 10:31:54 -0500813 char *p;
Eric Parisc9180a52007-11-30 13:00:35 -0500814 char *context = NULL, *defcontext = NULL;
815 char *fscontext = NULL, *rootcontext = NULL;
Eric Parise0007522008-03-05 10:31:54 -0500816 int rc, num_mnt_opts = 0;
Eric Parisc9180a52007-11-30 13:00:35 -0500817
Eric Parise0007522008-03-05 10:31:54 -0500818 opts->num_mnt_opts = 0;
Eric Parisc9180a52007-11-30 13:00:35 -0500819
820 /* Standard string-based options. */
821 while ((p = strsep(&options, "|")) != NULL) {
822 int token;
823 substring_t args[MAX_OPT_ARGS];
824
825 if (!*p)
826 continue;
827
828 token = match_token(p, tokens, args);
829
830 switch (token) {
831 case Opt_context:
832 if (context || defcontext) {
833 rc = -EINVAL;
834 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
835 goto out_err;
836 }
837 context = match_strdup(&args[0]);
838 if (!context) {
839 rc = -ENOMEM;
840 goto out_err;
841 }
842 break;
843
844 case Opt_fscontext:
845 if (fscontext) {
846 rc = -EINVAL;
847 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
848 goto out_err;
849 }
850 fscontext = match_strdup(&args[0]);
851 if (!fscontext) {
852 rc = -ENOMEM;
853 goto out_err;
854 }
855 break;
856
857 case Opt_rootcontext:
858 if (rootcontext) {
859 rc = -EINVAL;
860 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
861 goto out_err;
862 }
863 rootcontext = match_strdup(&args[0]);
864 if (!rootcontext) {
865 rc = -ENOMEM;
866 goto out_err;
867 }
868 break;
869
870 case Opt_defcontext:
871 if (context || defcontext) {
872 rc = -EINVAL;
873 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
874 goto out_err;
875 }
876 defcontext = match_strdup(&args[0]);
877 if (!defcontext) {
878 rc = -ENOMEM;
879 goto out_err;
880 }
881 break;
David P. Quigley11689d42009-01-16 09:22:03 -0500882 case Opt_labelsupport:
883 break;
Eric Parisc9180a52007-11-30 13:00:35 -0500884 default:
885 rc = -EINVAL;
886 printk(KERN_WARNING "SELinux: unknown mount option\n");
887 goto out_err;
888
889 }
890 }
891
Eric Parise0007522008-03-05 10:31:54 -0500892 rc = -ENOMEM;
893 opts->mnt_opts = kcalloc(NUM_SEL_MNT_OPTS, sizeof(char *), GFP_ATOMIC);
894 if (!opts->mnt_opts)
895 goto out_err;
896
897 opts->mnt_opts_flags = kcalloc(NUM_SEL_MNT_OPTS, sizeof(int), GFP_ATOMIC);
898 if (!opts->mnt_opts_flags) {
899 kfree(opts->mnt_opts);
900 goto out_err;
Eric Parisc9180a52007-11-30 13:00:35 -0500901 }
902
Eric Parise0007522008-03-05 10:31:54 -0500903 if (fscontext) {
904 opts->mnt_opts[num_mnt_opts] = fscontext;
905 opts->mnt_opts_flags[num_mnt_opts++] = FSCONTEXT_MNT;
906 }
907 if (context) {
908 opts->mnt_opts[num_mnt_opts] = context;
909 opts->mnt_opts_flags[num_mnt_opts++] = CONTEXT_MNT;
910 }
911 if (rootcontext) {
912 opts->mnt_opts[num_mnt_opts] = rootcontext;
913 opts->mnt_opts_flags[num_mnt_opts++] = ROOTCONTEXT_MNT;
914 }
915 if (defcontext) {
916 opts->mnt_opts[num_mnt_opts] = defcontext;
917 opts->mnt_opts_flags[num_mnt_opts++] = DEFCONTEXT_MNT;
918 }
919
920 opts->num_mnt_opts = num_mnt_opts;
921 return 0;
922
Eric Parisc9180a52007-11-30 13:00:35 -0500923out_err:
924 kfree(context);
925 kfree(defcontext);
926 kfree(fscontext);
927 kfree(rootcontext);
928 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929}
Eric Parise0007522008-03-05 10:31:54 -0500930/*
931 * string mount options parsing and call set the sbsec
932 */
933static int superblock_doinit(struct super_block *sb, void *data)
934{
935 int rc = 0;
936 char *options = data;
937 struct security_mnt_opts opts;
938
939 security_init_mnt_opts(&opts);
940
941 if (!data)
942 goto out;
943
944 BUG_ON(sb->s_type->fs_flags & FS_BINARY_MOUNTDATA);
945
946 rc = selinux_parse_opts_str(options, &opts);
947 if (rc)
948 goto out_err;
949
950out:
951 rc = selinux_set_mnt_opts(sb, &opts);
952
953out_err:
954 security_free_mnt_opts(&opts);
955 return rc;
956}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
Adrian Bunk3583a712008-07-22 20:21:23 +0300958static void selinux_write_opts(struct seq_file *m,
959 struct security_mnt_opts *opts)
Eric Paris2069f452008-07-04 09:47:13 +1000960{
961 int i;
962 char *prefix;
963
964 for (i = 0; i < opts->num_mnt_opts; i++) {
David P. Quigley11689d42009-01-16 09:22:03 -0500965 char *has_comma;
966
967 if (opts->mnt_opts[i])
968 has_comma = strchr(opts->mnt_opts[i], ',');
969 else
970 has_comma = NULL;
Eric Paris2069f452008-07-04 09:47:13 +1000971
972 switch (opts->mnt_opts_flags[i]) {
973 case CONTEXT_MNT:
974 prefix = CONTEXT_STR;
975 break;
976 case FSCONTEXT_MNT:
977 prefix = FSCONTEXT_STR;
978 break;
979 case ROOTCONTEXT_MNT:
980 prefix = ROOTCONTEXT_STR;
981 break;
982 case DEFCONTEXT_MNT:
983 prefix = DEFCONTEXT_STR;
984 break;
David P. Quigley11689d42009-01-16 09:22:03 -0500985 case SE_SBLABELSUPP:
986 seq_putc(m, ',');
987 seq_puts(m, LABELSUPP_STR);
988 continue;
Eric Paris2069f452008-07-04 09:47:13 +1000989 default:
990 BUG();
Eric Parisa35c6c82011-04-20 10:21:28 -0400991 return;
Eric Paris2069f452008-07-04 09:47:13 +1000992 };
993 /* we need a comma before each option */
994 seq_putc(m, ',');
995 seq_puts(m, prefix);
996 if (has_comma)
997 seq_putc(m, '\"');
998 seq_puts(m, opts->mnt_opts[i]);
999 if (has_comma)
1000 seq_putc(m, '\"');
1001 }
1002}
1003
1004static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb)
1005{
1006 struct security_mnt_opts opts;
1007 int rc;
1008
1009 rc = selinux_get_mnt_opts(sb, &opts);
Eric Paris383795c2008-07-29 17:07:26 -04001010 if (rc) {
1011 /* before policy load we may get EINVAL, don't show anything */
1012 if (rc == -EINVAL)
1013 rc = 0;
Eric Paris2069f452008-07-04 09:47:13 +10001014 return rc;
Eric Paris383795c2008-07-29 17:07:26 -04001015 }
Eric Paris2069f452008-07-04 09:47:13 +10001016
1017 selinux_write_opts(m, &opts);
1018
1019 security_free_mnt_opts(&opts);
1020
1021 return rc;
1022}
1023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024static inline u16 inode_mode_to_security_class(umode_t mode)
1025{
1026 switch (mode & S_IFMT) {
1027 case S_IFSOCK:
1028 return SECCLASS_SOCK_FILE;
1029 case S_IFLNK:
1030 return SECCLASS_LNK_FILE;
1031 case S_IFREG:
1032 return SECCLASS_FILE;
1033 case S_IFBLK:
1034 return SECCLASS_BLK_FILE;
1035 case S_IFDIR:
1036 return SECCLASS_DIR;
1037 case S_IFCHR:
1038 return SECCLASS_CHR_FILE;
1039 case S_IFIFO:
1040 return SECCLASS_FIFO_FILE;
1041
1042 }
1043
1044 return SECCLASS_FILE;
1045}
1046
James Morris13402582005-09-30 14:24:34 -04001047static inline int default_protocol_stream(int protocol)
1048{
1049 return (protocol == IPPROTO_IP || protocol == IPPROTO_TCP);
1050}
1051
1052static inline int default_protocol_dgram(int protocol)
1053{
1054 return (protocol == IPPROTO_IP || protocol == IPPROTO_UDP);
1055}
1056
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057static inline u16 socket_type_to_security_class(int family, int type, int protocol)
1058{
1059 switch (family) {
1060 case PF_UNIX:
1061 switch (type) {
1062 case SOCK_STREAM:
1063 case SOCK_SEQPACKET:
1064 return SECCLASS_UNIX_STREAM_SOCKET;
1065 case SOCK_DGRAM:
1066 return SECCLASS_UNIX_DGRAM_SOCKET;
1067 }
1068 break;
1069 case PF_INET:
1070 case PF_INET6:
1071 switch (type) {
1072 case SOCK_STREAM:
James Morris13402582005-09-30 14:24:34 -04001073 if (default_protocol_stream(protocol))
1074 return SECCLASS_TCP_SOCKET;
1075 else
1076 return SECCLASS_RAWIP_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 case SOCK_DGRAM:
James Morris13402582005-09-30 14:24:34 -04001078 if (default_protocol_dgram(protocol))
1079 return SECCLASS_UDP_SOCKET;
1080 else
1081 return SECCLASS_RAWIP_SOCKET;
James Morris2ee92d42006-11-13 16:09:01 -08001082 case SOCK_DCCP:
1083 return SECCLASS_DCCP_SOCKET;
James Morris13402582005-09-30 14:24:34 -04001084 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 return SECCLASS_RAWIP_SOCKET;
1086 }
1087 break;
1088 case PF_NETLINK:
1089 switch (protocol) {
1090 case NETLINK_ROUTE:
1091 return SECCLASS_NETLINK_ROUTE_SOCKET;
1092 case NETLINK_FIREWALL:
1093 return SECCLASS_NETLINK_FIREWALL_SOCKET;
Pavel Emelyanov7f1fb602011-12-06 07:56:43 +00001094 case NETLINK_SOCK_DIAG:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 return SECCLASS_NETLINK_TCPDIAG_SOCKET;
1096 case NETLINK_NFLOG:
1097 return SECCLASS_NETLINK_NFLOG_SOCKET;
1098 case NETLINK_XFRM:
1099 return SECCLASS_NETLINK_XFRM_SOCKET;
1100 case NETLINK_SELINUX:
1101 return SECCLASS_NETLINK_SELINUX_SOCKET;
1102 case NETLINK_AUDIT:
1103 return SECCLASS_NETLINK_AUDIT_SOCKET;
1104 case NETLINK_IP6_FW:
1105 return SECCLASS_NETLINK_IP6FW_SOCKET;
1106 case NETLINK_DNRTMSG:
1107 return SECCLASS_NETLINK_DNRT_SOCKET;
James Morris0c9b7942005-04-16 15:24:13 -07001108 case NETLINK_KOBJECT_UEVENT:
1109 return SECCLASS_NETLINK_KOBJECT_UEVENT_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 default:
1111 return SECCLASS_NETLINK_SOCKET;
1112 }
1113 case PF_PACKET:
1114 return SECCLASS_PACKET_SOCKET;
1115 case PF_KEY:
1116 return SECCLASS_KEY_SOCKET;
Christopher J. PeBenito3e3ff152006-06-09 00:25:03 -07001117 case PF_APPLETALK:
1118 return SECCLASS_APPLETALK_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 }
1120
1121 return SECCLASS_SOCKET;
1122}
1123
1124#ifdef CONFIG_PROC_FS
Lucian Adrian Grijincu8e6c9692011-02-01 18:42:22 +02001125static int selinux_proc_get_sid(struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 u16 tclass,
1127 u32 *sid)
1128{
Lucian Adrian Grijincu8e6c9692011-02-01 18:42:22 +02001129 int rc;
1130 char *buffer, *path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Eric Paris828dfe12008-04-17 13:17:49 -04001132 buffer = (char *)__get_free_page(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 if (!buffer)
1134 return -ENOMEM;
1135
Lucian Adrian Grijincu8e6c9692011-02-01 18:42:22 +02001136 path = dentry_path_raw(dentry, buffer, PAGE_SIZE);
1137 if (IS_ERR(path))
1138 rc = PTR_ERR(path);
1139 else {
1140 /* each process gets a /proc/PID/ entry. Strip off the
1141 * PID part to get a valid selinux labeling.
1142 * e.g. /proc/1/net/rpc/nfs -> /net/rpc/nfs */
1143 while (path[1] >= '0' && path[1] <= '9') {
1144 path[1] = '/';
1145 path++;
1146 }
1147 rc = security_genfs_sid("proc", path, tclass, sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 free_page((unsigned long)buffer);
1150 return rc;
1151}
1152#else
Lucian Adrian Grijincu8e6c9692011-02-01 18:42:22 +02001153static int selinux_proc_get_sid(struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 u16 tclass,
1155 u32 *sid)
1156{
1157 return -EINVAL;
1158}
1159#endif
1160
1161/* The inode's security attributes must be initialized before first use. */
1162static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry)
1163{
1164 struct superblock_security_struct *sbsec = NULL;
1165 struct inode_security_struct *isec = inode->i_security;
1166 u32 sid;
1167 struct dentry *dentry;
1168#define INITCONTEXTLEN 255
1169 char *context = NULL;
1170 unsigned len = 0;
1171 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
1173 if (isec->initialized)
1174 goto out;
1175
Eric Paris23970742006-09-25 23:32:01 -07001176 mutex_lock(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 if (isec->initialized)
Eric Paris23970742006-09-25 23:32:01 -07001178 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180 sbsec = inode->i_sb->s_security;
David P. Quigley0d90a7e2009-01-16 09:22:02 -05001181 if (!(sbsec->flags & SE_SBINITIALIZED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 /* Defer initialization until selinux_complete_init,
1183 after the initial policy is loaded and the security
1184 server is ready to handle calls. */
1185 spin_lock(&sbsec->isec_lock);
1186 if (list_empty(&isec->list))
1187 list_add(&isec->list, &sbsec->isec_head);
1188 spin_unlock(&sbsec->isec_lock);
Eric Paris23970742006-09-25 23:32:01 -07001189 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 }
1191
1192 switch (sbsec->behavior) {
1193 case SECURITY_FS_USE_XATTR:
1194 if (!inode->i_op->getxattr) {
1195 isec->sid = sbsec->def_sid;
1196 break;
1197 }
1198
1199 /* Need a dentry, since the xattr API requires one.
1200 Life would be simpler if we could just pass the inode. */
1201 if (opt_dentry) {
1202 /* Called from d_instantiate or d_splice_alias. */
1203 dentry = dget(opt_dentry);
1204 } else {
1205 /* Called from selinux_complete_init, try to find a dentry. */
1206 dentry = d_find_alias(inode);
1207 }
1208 if (!dentry) {
Eric Parisdf7f54c2009-03-09 14:35:58 -04001209 /*
1210 * this is can be hit on boot when a file is accessed
1211 * before the policy is loaded. When we load policy we
1212 * may find inodes that have no dentry on the
1213 * sbsec->isec_head list. No reason to complain as these
1214 * will get fixed up the next time we go through
1215 * inode_doinit with a dentry, before these inodes could
1216 * be used again by userspace.
1217 */
Eric Paris23970742006-09-25 23:32:01 -07001218 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 }
1220
1221 len = INITCONTEXTLEN;
Eric Paris4cb912f2009-02-12 14:50:05 -05001222 context = kmalloc(len+1, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 if (!context) {
1224 rc = -ENOMEM;
1225 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001226 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 }
Eric Paris4cb912f2009-02-12 14:50:05 -05001228 context[len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1230 context, len);
1231 if (rc == -ERANGE) {
James Morris314dabb2009-08-10 22:00:13 +10001232 kfree(context);
1233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 /* Need a larger buffer. Query for the right size. */
1235 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1236 NULL, 0);
1237 if (rc < 0) {
1238 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001239 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 len = rc;
Eric Paris4cb912f2009-02-12 14:50:05 -05001242 context = kmalloc(len+1, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 if (!context) {
1244 rc = -ENOMEM;
1245 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001246 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 }
Eric Paris4cb912f2009-02-12 14:50:05 -05001248 context[len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 rc = inode->i_op->getxattr(dentry,
1250 XATTR_NAME_SELINUX,
1251 context, len);
1252 }
1253 dput(dentry);
1254 if (rc < 0) {
1255 if (rc != -ENODATA) {
Eric Paris744ba352008-04-17 11:52:44 -04001256 printk(KERN_WARNING "SELinux: %s: getxattr returned "
Harvey Harrisondd6f9532008-03-06 10:03:59 +11001257 "%d for dev=%s ino=%ld\n", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 -rc, inode->i_sb->s_id, inode->i_ino);
1259 kfree(context);
Eric Paris23970742006-09-25 23:32:01 -07001260 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 }
1262 /* Map ENODATA to the default file SID */
1263 sid = sbsec->def_sid;
1264 rc = 0;
1265 } else {
James Morrisf5c1d5b2005-07-28 01:07:37 -07001266 rc = security_context_to_sid_default(context, rc, &sid,
Stephen Smalley869ab512008-04-04 08:46:05 -04001267 sbsec->def_sid,
1268 GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 if (rc) {
Eric Paris4ba0a8a2009-02-12 15:01:10 -05001270 char *dev = inode->i_sb->s_id;
1271 unsigned long ino = inode->i_ino;
1272
1273 if (rc == -EINVAL) {
1274 if (printk_ratelimit())
1275 printk(KERN_NOTICE "SELinux: inode=%lu on dev=%s was found to have an invalid "
1276 "context=%s. This indicates you may need to relabel the inode or the "
1277 "filesystem in question.\n", ino, dev, context);
1278 } else {
1279 printk(KERN_WARNING "SELinux: %s: context_to_sid(%s) "
1280 "returned %d for dev=%s ino=%ld\n",
1281 __func__, context, -rc, dev, ino);
1282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 kfree(context);
1284 /* Leave with the unlabeled SID */
1285 rc = 0;
1286 break;
1287 }
1288 }
1289 kfree(context);
1290 isec->sid = sid;
1291 break;
1292 case SECURITY_FS_USE_TASK:
1293 isec->sid = isec->task_sid;
1294 break;
1295 case SECURITY_FS_USE_TRANS:
1296 /* Default to the fs SID. */
1297 isec->sid = sbsec->sid;
1298
1299 /* Try to obtain a transition SID. */
1300 isec->sclass = inode_mode_to_security_class(inode->i_mode);
Eric Paris652bb9b2011-02-01 11:05:40 -05001301 rc = security_transition_sid(isec->task_sid, sbsec->sid,
1302 isec->sclass, NULL, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 if (rc)
Eric Paris23970742006-09-25 23:32:01 -07001304 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 isec->sid = sid;
1306 break;
Eric Parisc312feb2006-07-10 04:43:53 -07001307 case SECURITY_FS_USE_MNTPOINT:
1308 isec->sid = sbsec->mntpoint_sid;
1309 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 default:
Eric Parisc312feb2006-07-10 04:43:53 -07001311 /* Default to the fs superblock SID. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 isec->sid = sbsec->sid;
1313
David P. Quigley0d90a7e2009-01-16 09:22:02 -05001314 if ((sbsec->flags & SE_SBPROC) && !S_ISLNK(inode->i_mode)) {
Lucian Adrian Grijincu8e6c9692011-02-01 18:42:22 +02001315 if (opt_dentry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 isec->sclass = inode_mode_to_security_class(inode->i_mode);
Lucian Adrian Grijincu8e6c9692011-02-01 18:42:22 +02001317 rc = selinux_proc_get_sid(opt_dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 isec->sclass,
1319 &sid);
1320 if (rc)
Eric Paris23970742006-09-25 23:32:01 -07001321 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 isec->sid = sid;
1323 }
1324 }
1325 break;
1326 }
1327
1328 isec->initialized = 1;
1329
Eric Paris23970742006-09-25 23:32:01 -07001330out_unlock:
1331 mutex_unlock(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332out:
1333 if (isec->sclass == SECCLASS_FILE)
1334 isec->sclass = inode_mode_to_security_class(inode->i_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 return rc;
1336}
1337
1338/* Convert a Linux signal to an access vector. */
1339static inline u32 signal_to_av(int sig)
1340{
1341 u32 perm = 0;
1342
1343 switch (sig) {
1344 case SIGCHLD:
1345 /* Commonly granted from child to parent. */
1346 perm = PROCESS__SIGCHLD;
1347 break;
1348 case SIGKILL:
1349 /* Cannot be caught or ignored */
1350 perm = PROCESS__SIGKILL;
1351 break;
1352 case SIGSTOP:
1353 /* Cannot be caught or ignored */
1354 perm = PROCESS__SIGSTOP;
1355 break;
1356 default:
1357 /* All other signals. */
1358 perm = PROCESS__SIGNAL;
1359 break;
1360 }
1361
1362 return perm;
1363}
1364
David Howells275bb412008-11-14 10:39:19 +11001365/*
David Howellsd84f4f92008-11-14 10:39:23 +11001366 * Check permission between a pair of credentials
1367 * fork check, ptrace check, etc.
1368 */
1369static int cred_has_perm(const struct cred *actor,
1370 const struct cred *target,
1371 u32 perms)
1372{
1373 u32 asid = cred_sid(actor), tsid = cred_sid(target);
1374
1375 return avc_has_perm(asid, tsid, SECCLASS_PROCESS, perms, NULL);
1376}
1377
1378/*
David Howells88e67f32008-11-14 10:39:21 +11001379 * Check permission between a pair of tasks, e.g. signal checks,
David Howells275bb412008-11-14 10:39:19 +11001380 * fork check, ptrace check, etc.
1381 * tsk1 is the actor and tsk2 is the target
David Howells3b11a1d2008-11-14 10:39:26 +11001382 * - this uses the default subjective creds of tsk1
David Howells275bb412008-11-14 10:39:19 +11001383 */
1384static int task_has_perm(const struct task_struct *tsk1,
1385 const struct task_struct *tsk2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 u32 perms)
1387{
David Howells275bb412008-11-14 10:39:19 +11001388 const struct task_security_struct *__tsec1, *__tsec2;
1389 u32 sid1, sid2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390
David Howells275bb412008-11-14 10:39:19 +11001391 rcu_read_lock();
1392 __tsec1 = __task_cred(tsk1)->security; sid1 = __tsec1->sid;
1393 __tsec2 = __task_cred(tsk2)->security; sid2 = __tsec2->sid;
1394 rcu_read_unlock();
1395 return avc_has_perm(sid1, sid2, SECCLASS_PROCESS, perms, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396}
1397
David Howells3b11a1d2008-11-14 10:39:26 +11001398/*
1399 * Check permission between current and another task, e.g. signal checks,
1400 * fork check, ptrace check, etc.
1401 * current is the actor and tsk2 is the target
1402 * - this uses current's subjective creds
1403 */
1404static int current_has_perm(const struct task_struct *tsk,
1405 u32 perms)
1406{
1407 u32 sid, tsid;
1408
1409 sid = current_sid();
1410 tsid = task_sid(tsk);
1411 return avc_has_perm(sid, tsid, SECCLASS_PROCESS, perms, NULL);
1412}
1413
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001414#if CAP_LAST_CAP > 63
1415#error Fix SELinux to handle capabilities > 63.
1416#endif
1417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418/* Check whether a task is allowed to use a capability. */
Eric Paris6a9de492012-01-03 12:25:14 -05001419static int cred_has_capability(const struct cred *cred,
Eric Paris06112162008-11-11 22:02:50 +11001420 int cap, int audit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421{
Thomas Liu2bf49692009-07-14 12:14:09 -04001422 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001423 struct selinux_audit_data sad = {0,};
Eric Paris06112162008-11-11 22:02:50 +11001424 struct av_decision avd;
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001425 u16 sclass;
David Howells3699c532009-01-06 22:27:01 +00001426 u32 sid = cred_sid(cred);
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001427 u32 av = CAP_TO_MASK(cap);
Eric Paris06112162008-11-11 22:02:50 +11001428 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Thomas Liu2bf49692009-07-14 12:14:09 -04001430 COMMON_AUDIT_DATA_INIT(&ad, CAP);
Eric Paris3b3b0e42012-04-03 09:37:02 -07001431 ad.selinux_audit_data = &sad;
Eric Paris6a9de492012-01-03 12:25:14 -05001432 ad.tsk = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 ad.u.cap = cap;
1434
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001435 switch (CAP_TO_INDEX(cap)) {
1436 case 0:
1437 sclass = SECCLASS_CAPABILITY;
1438 break;
1439 case 1:
1440 sclass = SECCLASS_CAPABILITY2;
1441 break;
1442 default:
1443 printk(KERN_ERR
1444 "SELinux: out of range capability %d\n", cap);
1445 BUG();
Eric Parisa35c6c82011-04-20 10:21:28 -04001446 return -EINVAL;
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001447 }
Eric Paris06112162008-11-11 22:02:50 +11001448
David Howells275bb412008-11-14 10:39:19 +11001449 rc = avc_has_perm_noaudit(sid, sid, sclass, av, 0, &avd);
Eric Paris9ade0cf2011-04-25 16:26:29 -04001450 if (audit == SECURITY_CAP_AUDIT) {
1451 int rc2 = avc_audit(sid, sid, sclass, av, &avd, rc, &ad, 0);
1452 if (rc2)
1453 return rc2;
1454 }
Eric Paris06112162008-11-11 22:02:50 +11001455 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456}
1457
1458/* Check whether a task is allowed to use a system operation. */
1459static int task_has_system(struct task_struct *tsk,
1460 u32 perms)
1461{
David Howells275bb412008-11-14 10:39:19 +11001462 u32 sid = task_sid(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
David Howells275bb412008-11-14 10:39:19 +11001464 return avc_has_perm(sid, SECINITSID_KERNEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 SECCLASS_SYSTEM, perms, NULL);
1466}
1467
1468/* Check whether a task has a particular permission to an inode.
1469 The 'adp' parameter is optional and allows other audit
1470 data to be passed (e.g. the dentry). */
David Howells88e67f32008-11-14 10:39:21 +11001471static int inode_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 struct inode *inode,
1473 u32 perms,
Eric Paris9ade0cf2011-04-25 16:26:29 -04001474 struct common_audit_data *adp,
1475 unsigned flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 struct inode_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +11001478 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
David Howellse0e81732009-09-02 09:13:40 +01001480 validate_creds(cred);
1481
Eric Paris828dfe12008-04-17 13:17:49 -04001482 if (unlikely(IS_PRIVATE(inode)))
Stephen Smalleybbaca6c2007-02-14 00:34:16 -08001483 return 0;
1484
David Howells88e67f32008-11-14 10:39:21 +11001485 sid = cred_sid(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 isec = inode->i_security;
1487
Eric Paris9ade0cf2011-04-25 16:26:29 -04001488 return avc_has_perm_flags(sid, isec->sid, isec->sclass, perms, adp, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489}
1490
Linus Torvalds95f4efb2011-06-08 15:11:56 -07001491static int inode_has_perm_noadp(const struct cred *cred,
1492 struct inode *inode,
1493 u32 perms,
1494 unsigned flags)
1495{
1496 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001497 struct selinux_audit_data sad = {0,};
Linus Torvalds95f4efb2011-06-08 15:11:56 -07001498
1499 COMMON_AUDIT_DATA_INIT(&ad, INODE);
1500 ad.u.inode = inode;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001501 ad.selinux_audit_data = &sad;
Linus Torvalds95f4efb2011-06-08 15:11:56 -07001502 return inode_has_perm(cred, inode, perms, &ad, flags);
1503}
1504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505/* Same as inode_has_perm, but pass explicit audit data containing
1506 the dentry to help the auditing code to more easily generate the
1507 pathname if needed. */
David Howells88e67f32008-11-14 10:39:21 +11001508static inline int dentry_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 struct dentry *dentry,
1510 u32 av)
1511{
1512 struct inode *inode = dentry->d_inode;
Thomas Liu2bf49692009-07-14 12:14:09 -04001513 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001514 struct selinux_audit_data sad = {0,};
David Howells88e67f32008-11-14 10:39:21 +11001515
Eric Paris2875fa02011-04-28 16:04:24 -04001516 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1517 ad.u.dentry = dentry;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001518 ad.selinux_audit_data = &sad;
Eric Paris2875fa02011-04-28 16:04:24 -04001519 return inode_has_perm(cred, inode, av, &ad, 0);
1520}
1521
1522/* Same as inode_has_perm, but pass explicit audit data containing
1523 the path to help the auditing code to more easily generate the
1524 pathname if needed. */
1525static inline int path_has_perm(const struct cred *cred,
1526 struct path *path,
1527 u32 av)
1528{
1529 struct inode *inode = path->dentry->d_inode;
1530 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001531 struct selinux_audit_data sad = {0,};
Eric Paris2875fa02011-04-28 16:04:24 -04001532
Eric Parisf48b7392011-04-25 12:54:27 -04001533 COMMON_AUDIT_DATA_INIT(&ad, PATH);
Eric Paris2875fa02011-04-28 16:04:24 -04001534 ad.u.path = *path;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001535 ad.selinux_audit_data = &sad;
Eric Paris9ade0cf2011-04-25 16:26:29 -04001536 return inode_has_perm(cred, inode, av, &ad, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537}
1538
1539/* Check whether a task can use an open file descriptor to
1540 access an inode in a given way. Check access to the
1541 descriptor itself, and then use dentry_has_perm to
1542 check a particular permission to the file.
1543 Access to the descriptor is implicitly granted if it
1544 has the same SID as the process. If av is zero, then
1545 access to the file is not checked, e.g. for cases
1546 where only the descriptor is affected like seek. */
David Howells88e67f32008-11-14 10:39:21 +11001547static int file_has_perm(const struct cred *cred,
1548 struct file *file,
1549 u32 av)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 struct file_security_struct *fsec = file->f_security;
Jan Blunck44707fd2008-02-14 19:38:33 -08001552 struct inode *inode = file->f_path.dentry->d_inode;
Thomas Liu2bf49692009-07-14 12:14:09 -04001553 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001554 struct selinux_audit_data sad = {0,};
David Howells88e67f32008-11-14 10:39:21 +11001555 u32 sid = cred_sid(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 int rc;
1557
Eric Parisf48b7392011-04-25 12:54:27 -04001558 COMMON_AUDIT_DATA_INIT(&ad, PATH);
1559 ad.u.path = file->f_path;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001560 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
David Howells275bb412008-11-14 10:39:19 +11001562 if (sid != fsec->sid) {
1563 rc = avc_has_perm(sid, fsec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 SECCLASS_FD,
1565 FD__USE,
1566 &ad);
1567 if (rc)
David Howells88e67f32008-11-14 10:39:21 +11001568 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 }
1570
1571 /* av is zero if only checking access to the descriptor. */
David Howells88e67f32008-11-14 10:39:21 +11001572 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 if (av)
Eric Paris9ade0cf2011-04-25 16:26:29 -04001574 rc = inode_has_perm(cred, inode, av, &ad, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
David Howells88e67f32008-11-14 10:39:21 +11001576out:
1577 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578}
1579
1580/* Check whether a task can create a file. */
1581static int may_create(struct inode *dir,
1582 struct dentry *dentry,
1583 u16 tclass)
1584{
Paul Moore5fb49872010-04-22 14:46:19 -04001585 const struct task_security_struct *tsec = current_security();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 struct inode_security_struct *dsec;
1587 struct superblock_security_struct *sbsec;
David Howells275bb412008-11-14 10:39:19 +11001588 u32 sid, newsid;
Thomas Liu2bf49692009-07-14 12:14:09 -04001589 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001590 struct selinux_audit_data sad = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 int rc;
1592
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 dsec = dir->i_security;
1594 sbsec = dir->i_sb->s_security;
1595
David Howells275bb412008-11-14 10:39:19 +11001596 sid = tsec->sid;
1597 newsid = tsec->create_sid;
1598
Eric Parisa2694342011-04-25 13:10:27 -04001599 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1600 ad.u.dentry = dentry;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001601 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
David Howells275bb412008-11-14 10:39:19 +11001603 rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 DIR__ADD_NAME | DIR__SEARCH,
1605 &ad);
1606 if (rc)
1607 return rc;
1608
David P. Quigleycd895962009-01-16 09:22:04 -05001609 if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
Eric Pariscb1e9222011-04-28 15:11:21 -04001610 rc = security_transition_sid(sid, dsec->sid, tclass,
1611 &dentry->d_name, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 if (rc)
1613 return rc;
1614 }
1615
David Howells275bb412008-11-14 10:39:19 +11001616 rc = avc_has_perm(sid, newsid, tclass, FILE__CREATE, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 if (rc)
1618 return rc;
1619
1620 return avc_has_perm(newsid, sbsec->sid,
1621 SECCLASS_FILESYSTEM,
1622 FILESYSTEM__ASSOCIATE, &ad);
1623}
1624
Michael LeMay4eb582c2006-06-26 00:24:57 -07001625/* Check whether a task can create a key. */
1626static int may_create_key(u32 ksid,
1627 struct task_struct *ctx)
1628{
David Howells275bb412008-11-14 10:39:19 +11001629 u32 sid = task_sid(ctx);
Michael LeMay4eb582c2006-06-26 00:24:57 -07001630
David Howells275bb412008-11-14 10:39:19 +11001631 return avc_has_perm(sid, ksid, SECCLASS_KEY, KEY__CREATE, NULL);
Michael LeMay4eb582c2006-06-26 00:24:57 -07001632}
1633
Eric Paris828dfe12008-04-17 13:17:49 -04001634#define MAY_LINK 0
1635#define MAY_UNLINK 1
1636#define MAY_RMDIR 2
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
1638/* Check whether a task can link, unlink, or rmdir a file/directory. */
1639static int may_link(struct inode *dir,
1640 struct dentry *dentry,
1641 int kind)
1642
1643{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 struct inode_security_struct *dsec, *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04001645 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001646 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11001647 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 u32 av;
1649 int rc;
1650
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 dsec = dir->i_security;
1652 isec = dentry->d_inode->i_security;
1653
Eric Parisa2694342011-04-25 13:10:27 -04001654 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1655 ad.u.dentry = dentry;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001656 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
1658 av = DIR__SEARCH;
1659 av |= (kind ? DIR__REMOVE_NAME : DIR__ADD_NAME);
David Howells275bb412008-11-14 10:39:19 +11001660 rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 if (rc)
1662 return rc;
1663
1664 switch (kind) {
1665 case MAY_LINK:
1666 av = FILE__LINK;
1667 break;
1668 case MAY_UNLINK:
1669 av = FILE__UNLINK;
1670 break;
1671 case MAY_RMDIR:
1672 av = DIR__RMDIR;
1673 break;
1674 default:
Eric Paris744ba352008-04-17 11:52:44 -04001675 printk(KERN_WARNING "SELinux: %s: unrecognized kind %d\n",
1676 __func__, kind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 return 0;
1678 }
1679
David Howells275bb412008-11-14 10:39:19 +11001680 rc = avc_has_perm(sid, isec->sid, isec->sclass, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return rc;
1682}
1683
1684static inline int may_rename(struct inode *old_dir,
1685 struct dentry *old_dentry,
1686 struct inode *new_dir,
1687 struct dentry *new_dentry)
1688{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 struct inode_security_struct *old_dsec, *new_dsec, *old_isec, *new_isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04001690 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001691 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11001692 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 u32 av;
1694 int old_is_dir, new_is_dir;
1695 int rc;
1696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 old_dsec = old_dir->i_security;
1698 old_isec = old_dentry->d_inode->i_security;
1699 old_is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
1700 new_dsec = new_dir->i_security;
1701
Eric Parisa2694342011-04-25 13:10:27 -04001702 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
Eric Paris3b3b0e42012-04-03 09:37:02 -07001703 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704
Eric Parisa2694342011-04-25 13:10:27 -04001705 ad.u.dentry = old_dentry;
David Howells275bb412008-11-14 10:39:19 +11001706 rc = avc_has_perm(sid, old_dsec->sid, SECCLASS_DIR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 DIR__REMOVE_NAME | DIR__SEARCH, &ad);
1708 if (rc)
1709 return rc;
David Howells275bb412008-11-14 10:39:19 +11001710 rc = avc_has_perm(sid, old_isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 old_isec->sclass, FILE__RENAME, &ad);
1712 if (rc)
1713 return rc;
1714 if (old_is_dir && new_dir != old_dir) {
David Howells275bb412008-11-14 10:39:19 +11001715 rc = avc_has_perm(sid, old_isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 old_isec->sclass, DIR__REPARENT, &ad);
1717 if (rc)
1718 return rc;
1719 }
1720
Eric Parisa2694342011-04-25 13:10:27 -04001721 ad.u.dentry = new_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 av = DIR__ADD_NAME | DIR__SEARCH;
1723 if (new_dentry->d_inode)
1724 av |= DIR__REMOVE_NAME;
David Howells275bb412008-11-14 10:39:19 +11001725 rc = avc_has_perm(sid, new_dsec->sid, SECCLASS_DIR, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 if (rc)
1727 return rc;
1728 if (new_dentry->d_inode) {
1729 new_isec = new_dentry->d_inode->i_security;
1730 new_is_dir = S_ISDIR(new_dentry->d_inode->i_mode);
David Howells275bb412008-11-14 10:39:19 +11001731 rc = avc_has_perm(sid, new_isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 new_isec->sclass,
1733 (new_is_dir ? DIR__RMDIR : FILE__UNLINK), &ad);
1734 if (rc)
1735 return rc;
1736 }
1737
1738 return 0;
1739}
1740
1741/* Check whether a task can perform a filesystem operation. */
David Howells88e67f32008-11-14 10:39:21 +11001742static int superblock_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 struct super_block *sb,
1744 u32 perms,
Thomas Liu2bf49692009-07-14 12:14:09 -04001745 struct common_audit_data *ad)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 struct superblock_security_struct *sbsec;
David Howells88e67f32008-11-14 10:39:21 +11001748 u32 sid = cred_sid(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 sbsec = sb->s_security;
David Howells275bb412008-11-14 10:39:19 +11001751 return avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM, perms, ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752}
1753
1754/* Convert a Linux mode and permission mask to an access vector. */
1755static inline u32 file_mask_to_av(int mode, int mask)
1756{
1757 u32 av = 0;
1758
Al Virodba19c62011-07-25 20:49:29 -04001759 if (!S_ISDIR(mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 if (mask & MAY_EXEC)
1761 av |= FILE__EXECUTE;
1762 if (mask & MAY_READ)
1763 av |= FILE__READ;
1764
1765 if (mask & MAY_APPEND)
1766 av |= FILE__APPEND;
1767 else if (mask & MAY_WRITE)
1768 av |= FILE__WRITE;
1769
1770 } else {
1771 if (mask & MAY_EXEC)
1772 av |= DIR__SEARCH;
1773 if (mask & MAY_WRITE)
1774 av |= DIR__WRITE;
1775 if (mask & MAY_READ)
1776 av |= DIR__READ;
1777 }
1778
1779 return av;
1780}
1781
1782/* Convert a Linux file to an access vector. */
1783static inline u32 file_to_av(struct file *file)
1784{
1785 u32 av = 0;
1786
1787 if (file->f_mode & FMODE_READ)
1788 av |= FILE__READ;
1789 if (file->f_mode & FMODE_WRITE) {
1790 if (file->f_flags & O_APPEND)
1791 av |= FILE__APPEND;
1792 else
1793 av |= FILE__WRITE;
1794 }
Stephen Smalley0794c662008-03-17 08:55:18 -04001795 if (!av) {
1796 /*
1797 * Special file opened with flags 3 for ioctl-only use.
1798 */
1799 av = FILE__IOCTL;
1800 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
1802 return av;
1803}
1804
Eric Paris8b6a5a32008-10-29 17:06:46 -04001805/*
1806 * Convert a file to an access vector and include the correct open
1807 * open permission.
1808 */
1809static inline u32 open_file_to_av(struct file *file)
1810{
1811 u32 av = file_to_av(file);
1812
Eric Paris49b7b8d2010-07-23 11:44:09 -04001813 if (selinux_policycap_openperm)
1814 av |= FILE__OPEN;
1815
Eric Paris8b6a5a32008-10-29 17:06:46 -04001816 return av;
1817}
1818
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819/* Hook functions begin here. */
1820
Ingo Molnar9e488582009-05-07 19:26:19 +10001821static int selinux_ptrace_access_check(struct task_struct *child,
David Howells5cd9c582008-08-14 11:37:28 +01001822 unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 int rc;
1825
Ingo Molnar9e488582009-05-07 19:26:19 +10001826 rc = cap_ptrace_access_check(child, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 if (rc)
1828 return rc;
1829
Eric Paris69f594a2012-01-03 12:25:15 -05001830 if (mode & PTRACE_MODE_READ) {
David Howells275bb412008-11-14 10:39:19 +11001831 u32 sid = current_sid();
1832 u32 csid = task_sid(child);
1833 return avc_has_perm(sid, csid, SECCLASS_FILE, FILE__READ, NULL);
Stephen Smalley006ebb42008-05-19 08:32:49 -04001834 }
1835
David Howells3b11a1d2008-11-14 10:39:26 +11001836 return current_has_perm(child, PROCESS__PTRACE);
David Howells5cd9c582008-08-14 11:37:28 +01001837}
1838
1839static int selinux_ptrace_traceme(struct task_struct *parent)
1840{
1841 int rc;
1842
Eric Paris200ac532009-02-12 15:01:04 -05001843 rc = cap_ptrace_traceme(parent);
David Howells5cd9c582008-08-14 11:37:28 +01001844 if (rc)
1845 return rc;
1846
1847 return task_has_perm(parent, current, PROCESS__PTRACE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848}
1849
1850static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
Eric Paris828dfe12008-04-17 13:17:49 -04001851 kernel_cap_t *inheritable, kernel_cap_t *permitted)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852{
1853 int error;
1854
David Howells3b11a1d2008-11-14 10:39:26 +11001855 error = current_has_perm(target, PROCESS__GETCAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 if (error)
1857 return error;
1858
Eric Paris200ac532009-02-12 15:01:04 -05001859 return cap_capget(target, effective, inheritable, permitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860}
1861
David Howellsd84f4f92008-11-14 10:39:23 +11001862static int selinux_capset(struct cred *new, const struct cred *old,
1863 const kernel_cap_t *effective,
1864 const kernel_cap_t *inheritable,
1865 const kernel_cap_t *permitted)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866{
1867 int error;
1868
Eric Paris200ac532009-02-12 15:01:04 -05001869 error = cap_capset(new, old,
David Howellsd84f4f92008-11-14 10:39:23 +11001870 effective, inheritable, permitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 if (error)
1872 return error;
1873
David Howellsd84f4f92008-11-14 10:39:23 +11001874 return cred_has_perm(old, new, PROCESS__SETCAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875}
1876
James Morris5626d3e2009-01-30 10:05:06 +11001877/*
1878 * (This comment used to live with the selinux_task_setuid hook,
1879 * which was removed).
1880 *
1881 * Since setuid only affects the current process, and since the SELinux
1882 * controls are not based on the Linux identity attributes, SELinux does not
1883 * need to control this operation. However, SELinux does control the use of
1884 * the CAP_SETUID and CAP_SETGID capabilities using the capable hook.
1885 */
1886
Eric Paris6a9de492012-01-03 12:25:14 -05001887static int selinux_capable(const struct cred *cred, struct user_namespace *ns,
1888 int cap, int audit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889{
1890 int rc;
1891
Eric Paris6a9de492012-01-03 12:25:14 -05001892 rc = cap_capable(cred, ns, cap, audit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 if (rc)
1894 return rc;
1895
Eric Paris6a9de492012-01-03 12:25:14 -05001896 return cred_has_capability(cred, cap, audit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897}
1898
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
1900{
David Howells88e67f32008-11-14 10:39:21 +11001901 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 int rc = 0;
1903
1904 if (!sb)
1905 return 0;
1906
1907 switch (cmds) {
Eric Paris828dfe12008-04-17 13:17:49 -04001908 case Q_SYNC:
1909 case Q_QUOTAON:
1910 case Q_QUOTAOFF:
1911 case Q_SETINFO:
1912 case Q_SETQUOTA:
David Howells88e67f32008-11-14 10:39:21 +11001913 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAMOD, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04001914 break;
1915 case Q_GETFMT:
1916 case Q_GETINFO:
1917 case Q_GETQUOTA:
David Howells88e67f32008-11-14 10:39:21 +11001918 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAGET, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04001919 break;
1920 default:
1921 rc = 0; /* let the kernel handle invalid cmds */
1922 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 }
1924 return rc;
1925}
1926
1927static int selinux_quota_on(struct dentry *dentry)
1928{
David Howells88e67f32008-11-14 10:39:21 +11001929 const struct cred *cred = current_cred();
1930
Eric Paris2875fa02011-04-28 16:04:24 -04001931 return dentry_has_perm(cred, dentry, FILE__QUOTAON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932}
1933
Eric Paris12b30522010-11-15 18:36:29 -05001934static int selinux_syslog(int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935{
1936 int rc;
1937
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 switch (type) {
Kees Cookd78ca3c2010-02-03 15:37:13 -08001939 case SYSLOG_ACTION_READ_ALL: /* Read last kernel messages */
1940 case SYSLOG_ACTION_SIZE_BUFFER: /* Return size of the log buffer */
Eric Paris828dfe12008-04-17 13:17:49 -04001941 rc = task_has_system(current, SYSTEM__SYSLOG_READ);
1942 break;
Kees Cookd78ca3c2010-02-03 15:37:13 -08001943 case SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging to console */
1944 case SYSLOG_ACTION_CONSOLE_ON: /* Enable logging to console */
1945 /* Set level of messages printed to console */
1946 case SYSLOG_ACTION_CONSOLE_LEVEL:
Eric Paris828dfe12008-04-17 13:17:49 -04001947 rc = task_has_system(current, SYSTEM__SYSLOG_CONSOLE);
1948 break;
Kees Cookd78ca3c2010-02-03 15:37:13 -08001949 case SYSLOG_ACTION_CLOSE: /* Close log */
1950 case SYSLOG_ACTION_OPEN: /* Open log */
1951 case SYSLOG_ACTION_READ: /* Read from log */
1952 case SYSLOG_ACTION_READ_CLEAR: /* Read/clear last kernel messages */
1953 case SYSLOG_ACTION_CLEAR: /* Clear ring buffer */
Eric Paris828dfe12008-04-17 13:17:49 -04001954 default:
1955 rc = task_has_system(current, SYSTEM__SYSLOG_MOD);
1956 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 }
1958 return rc;
1959}
1960
1961/*
1962 * Check that a process has enough memory to allocate a new virtual
1963 * mapping. 0 means there is enough memory for the allocation to
1964 * succeed and -ENOMEM implies there is not.
1965 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 * Do not audit the selinux permission check, as this is applied to all
1967 * processes that allocate mappings.
1968 */
Alan Cox34b4e4a2007-08-22 14:01:28 -07001969static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970{
1971 int rc, cap_sys_admin = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
Eric Paris6a9de492012-01-03 12:25:14 -05001973 rc = selinux_capable(current_cred(), &init_user_ns, CAP_SYS_ADMIN,
David Howells3699c532009-01-06 22:27:01 +00001974 SECURITY_CAP_NOAUDIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 if (rc == 0)
1976 cap_sys_admin = 1;
1977
Alan Cox34b4e4a2007-08-22 14:01:28 -07001978 return __vm_enough_memory(mm, pages, cap_sys_admin);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979}
1980
1981/* binprm security operations */
1982
David Howellsa6f76f22008-11-14 10:39:24 +11001983static int selinux_bprm_set_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984{
David Howellsa6f76f22008-11-14 10:39:24 +11001985 const struct task_security_struct *old_tsec;
1986 struct task_security_struct *new_tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 struct inode_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04001988 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07001989 struct selinux_audit_data sad = {0,};
David Howellsa6f76f22008-11-14 10:39:24 +11001990 struct inode *inode = bprm->file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 int rc;
1992
Eric Paris200ac532009-02-12 15:01:04 -05001993 rc = cap_bprm_set_creds(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 if (rc)
1995 return rc;
1996
David Howellsa6f76f22008-11-14 10:39:24 +11001997 /* SELinux context only depends on initial program or script and not
1998 * the script interpreter */
1999 if (bprm->cred_prepared)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 return 0;
2001
David Howellsa6f76f22008-11-14 10:39:24 +11002002 old_tsec = current_security();
2003 new_tsec = bprm->cred->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 isec = inode->i_security;
2005
2006 /* Default to the current task SID. */
David Howellsa6f76f22008-11-14 10:39:24 +11002007 new_tsec->sid = old_tsec->sid;
2008 new_tsec->osid = old_tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009
Michael LeMay28eba5b2006-06-27 02:53:42 -07002010 /* Reset fs, key, and sock SIDs on execve. */
David Howellsa6f76f22008-11-14 10:39:24 +11002011 new_tsec->create_sid = 0;
2012 new_tsec->keycreate_sid = 0;
2013 new_tsec->sockcreate_sid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014
David Howellsa6f76f22008-11-14 10:39:24 +11002015 if (old_tsec->exec_sid) {
2016 new_tsec->sid = old_tsec->exec_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 /* Reset exec SID on execve. */
David Howellsa6f76f22008-11-14 10:39:24 +11002018 new_tsec->exec_sid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 } else {
2020 /* Check for a default transition on this program. */
David Howellsa6f76f22008-11-14 10:39:24 +11002021 rc = security_transition_sid(old_tsec->sid, isec->sid,
Eric Paris652bb9b2011-02-01 11:05:40 -05002022 SECCLASS_PROCESS, NULL,
2023 &new_tsec->sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 if (rc)
2025 return rc;
2026 }
2027
Eric Parisf48b7392011-04-25 12:54:27 -04002028 COMMON_AUDIT_DATA_INIT(&ad, PATH);
Eric Paris3b3b0e42012-04-03 09:37:02 -07002029 ad.selinux_audit_data = &sad;
Eric Parisf48b7392011-04-25 12:54:27 -04002030 ad.u.path = bprm->file->f_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031
Josef Sipek3d5ff522006-12-08 02:37:38 -08002032 if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
David Howellsa6f76f22008-11-14 10:39:24 +11002033 new_tsec->sid = old_tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
David Howellsa6f76f22008-11-14 10:39:24 +11002035 if (new_tsec->sid == old_tsec->sid) {
2036 rc = avc_has_perm(old_tsec->sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 SECCLASS_FILE, FILE__EXECUTE_NO_TRANS, &ad);
2038 if (rc)
2039 return rc;
2040 } else {
2041 /* Check permissions for the transition. */
David Howellsa6f76f22008-11-14 10:39:24 +11002042 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 SECCLASS_PROCESS, PROCESS__TRANSITION, &ad);
2044 if (rc)
2045 return rc;
2046
David Howellsa6f76f22008-11-14 10:39:24 +11002047 rc = avc_has_perm(new_tsec->sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 SECCLASS_FILE, FILE__ENTRYPOINT, &ad);
2049 if (rc)
2050 return rc;
2051
David Howellsa6f76f22008-11-14 10:39:24 +11002052 /* Check for shared state */
2053 if (bprm->unsafe & LSM_UNSAFE_SHARE) {
2054 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2055 SECCLASS_PROCESS, PROCESS__SHARE,
2056 NULL);
2057 if (rc)
2058 return -EPERM;
2059 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
David Howellsa6f76f22008-11-14 10:39:24 +11002061 /* Make sure that anyone attempting to ptrace over a task that
2062 * changes its SID has the appropriate permit */
2063 if (bprm->unsafe &
2064 (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
2065 struct task_struct *tracer;
2066 struct task_security_struct *sec;
2067 u32 ptsid = 0;
2068
2069 rcu_read_lock();
Tejun Heo06d98472011-06-17 16:50:40 +02002070 tracer = ptrace_parent(current);
David Howellsa6f76f22008-11-14 10:39:24 +11002071 if (likely(tracer != NULL)) {
2072 sec = __task_cred(tracer)->security;
2073 ptsid = sec->sid;
2074 }
2075 rcu_read_unlock();
2076
2077 if (ptsid != 0) {
2078 rc = avc_has_perm(ptsid, new_tsec->sid,
2079 SECCLASS_PROCESS,
2080 PROCESS__PTRACE, NULL);
2081 if (rc)
2082 return -EPERM;
2083 }
2084 }
2085
2086 /* Clear any possibly unsafe personality bits on exec: */
2087 bprm->per_clear |= PER_CLEAR_ON_SETID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 }
2089
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 return 0;
2091}
2092
Eric Paris828dfe12008-04-17 13:17:49 -04002093static int selinux_bprm_secureexec(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094{
Paul Moore5fb49872010-04-22 14:46:19 -04002095 const struct task_security_struct *tsec = current_security();
David Howells275bb412008-11-14 10:39:19 +11002096 u32 sid, osid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 int atsecure = 0;
2098
David Howells275bb412008-11-14 10:39:19 +11002099 sid = tsec->sid;
2100 osid = tsec->osid;
2101
2102 if (osid != sid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 /* Enable secure mode for SIDs transitions unless
2104 the noatsecure permission is granted between
2105 the two SIDs, i.e. ahp returns 0. */
David Howells275bb412008-11-14 10:39:19 +11002106 atsecure = avc_has_perm(osid, sid,
David Howellsa6f76f22008-11-14 10:39:24 +11002107 SECCLASS_PROCESS,
2108 PROCESS__NOATSECURE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 }
2110
Eric Paris200ac532009-02-12 15:01:04 -05002111 return (atsecure || cap_bprm_secureexec(bprm));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112}
2113
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114/* Derived from fs/exec.c:flush_old_files. */
David Howells745ca242008-11-14 10:39:22 +11002115static inline void flush_unauthorized_files(const struct cred *cred,
2116 struct files_struct *files)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117{
Thomas Liu2bf49692009-07-14 12:14:09 -04002118 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07002119 struct selinux_audit_data sad = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 struct file *file, *devnull = NULL;
Stephen Smalleyb20c8122006-09-25 23:32:03 -07002121 struct tty_struct *tty;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002122 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 long j = -1;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002124 int drop_tty = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002126 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 if (tty) {
Nick Pigginee2ffa02010-08-18 04:37:35 +10002128 spin_lock(&tty_files_lock);
Eric Paris37dd0bd2008-10-31 17:40:00 -04002129 if (!list_empty(&tty->tty_files)) {
Nick Piggind996b622010-08-18 04:37:36 +10002130 struct tty_file_private *file_priv;
Eric Paris37dd0bd2008-10-31 17:40:00 -04002131 struct inode *inode;
2132
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 /* Revalidate access to controlling tty.
2134 Use inode_has_perm on the tty inode directly rather
2135 than using file_has_perm, as this particular open
2136 file may belong to another process and we are only
2137 interested in the inode-based check here. */
Nick Piggind996b622010-08-18 04:37:36 +10002138 file_priv = list_first_entry(&tty->tty_files,
2139 struct tty_file_private, list);
2140 file = file_priv->file;
Eric Paris37dd0bd2008-10-31 17:40:00 -04002141 inode = file->f_path.dentry->d_inode;
Linus Torvalds95f4efb2011-06-08 15:11:56 -07002142 if (inode_has_perm_noadp(cred, inode,
2143 FILE__READ | FILE__WRITE, 0)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002144 drop_tty = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 }
2146 }
Nick Pigginee2ffa02010-08-18 04:37:35 +10002147 spin_unlock(&tty_files_lock);
Alan Cox452a00d2008-10-13 10:39:13 +01002148 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 }
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07002150 /* Reset controlling tty. */
2151 if (drop_tty)
2152 no_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
2154 /* Revalidate access to inherited open files. */
2155
Eric Parisf48b7392011-04-25 12:54:27 -04002156 COMMON_AUDIT_DATA_INIT(&ad, INODE);
Eric Paris3b3b0e42012-04-03 09:37:02 -07002157 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158
2159 spin_lock(&files->file_lock);
2160 for (;;) {
2161 unsigned long set, i;
2162 int fd;
2163
2164 j++;
2165 i = j * __NFDBITS;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002166 fdt = files_fdtable(files);
Vadim Lobanovbbea9f62006-12-10 02:21:12 -08002167 if (i >= fdt->max_fds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 break;
David Howells1fd36ad2012-02-16 17:49:54 +00002169 set = fdt->open_fds[j];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 if (!set)
2171 continue;
2172 spin_unlock(&files->file_lock);
Eric Paris828dfe12008-04-17 13:17:49 -04002173 for ( ; set ; i++, set >>= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 if (set & 1) {
2175 file = fget(i);
2176 if (!file)
2177 continue;
David Howells88e67f32008-11-14 10:39:21 +11002178 if (file_has_perm(cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 file,
2180 file_to_av(file))) {
2181 sys_close(i);
2182 fd = get_unused_fd();
2183 if (fd != i) {
2184 if (fd >= 0)
2185 put_unused_fd(fd);
2186 fput(file);
2187 continue;
2188 }
2189 if (devnull) {
Nick Piggin095975d2006-01-08 01:02:19 -08002190 get_file(devnull);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 } else {
David Howells745ca242008-11-14 10:39:22 +11002192 devnull = dentry_open(
2193 dget(selinux_null),
2194 mntget(selinuxfs_mount),
2195 O_RDWR, cred);
Akinobu Mitafc5d81e2006-11-27 15:16:48 +09002196 if (IS_ERR(devnull)) {
2197 devnull = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 put_unused_fd(fd);
2199 fput(file);
2200 continue;
2201 }
2202 }
2203 fd_install(fd, devnull);
2204 }
2205 fput(file);
2206 }
2207 }
2208 spin_lock(&files->file_lock);
2209
2210 }
2211 spin_unlock(&files->file_lock);
2212}
2213
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214/*
David Howellsa6f76f22008-11-14 10:39:24 +11002215 * Prepare a process for imminent new credential changes due to exec
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 */
David Howellsa6f76f22008-11-14 10:39:24 +11002217static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218{
David Howellsa6f76f22008-11-14 10:39:24 +11002219 struct task_security_struct *new_tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 struct rlimit *rlim, *initrlim;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 int rc, i;
2222
David Howellsa6f76f22008-11-14 10:39:24 +11002223 new_tsec = bprm->cred->security;
2224 if (new_tsec->sid == new_tsec->osid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 return;
2226
2227 /* Close files for which the new task SID is not authorized. */
David Howellsa6f76f22008-11-14 10:39:24 +11002228 flush_unauthorized_files(bprm->cred, current->files);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229
David Howellsa6f76f22008-11-14 10:39:24 +11002230 /* Always clear parent death signal on SID transitions. */
2231 current->pdeath_signal = 0;
2232
2233 /* Check whether the new SID can inherit resource limits from the old
2234 * SID. If not, reset all soft limits to the lower of the current
2235 * task's hard limit and the init task's soft limit.
2236 *
2237 * Note that the setting of hard limits (even to lower them) can be
2238 * controlled by the setrlimit check. The inclusion of the init task's
2239 * soft limit into the computation is to avoid resetting soft limits
2240 * higher than the default soft limit for cases where the default is
2241 * lower than the hard limit, e.g. RLIMIT_CORE or RLIMIT_STACK.
2242 */
2243 rc = avc_has_perm(new_tsec->osid, new_tsec->sid, SECCLASS_PROCESS,
2244 PROCESS__RLIMITINH, NULL);
2245 if (rc) {
Oleg Nesteroveb2d55a2010-06-23 22:43:32 +02002246 /* protect against do_prlimit() */
2247 task_lock(current);
David Howellsa6f76f22008-11-14 10:39:24 +11002248 for (i = 0; i < RLIM_NLIMITS; i++) {
2249 rlim = current->signal->rlim + i;
2250 initrlim = init_task.signal->rlim + i;
2251 rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
2252 }
Oleg Nesteroveb2d55a2010-06-23 22:43:32 +02002253 task_unlock(current);
2254 update_rlimit_cpu(current, rlimit(RLIMIT_CPU));
David Howellsa6f76f22008-11-14 10:39:24 +11002255 }
2256}
2257
2258/*
2259 * Clean up the process immediately after the installation of new credentials
2260 * due to exec
2261 */
2262static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
2263{
2264 const struct task_security_struct *tsec = current_security();
2265 struct itimerval itimer;
David Howellsa6f76f22008-11-14 10:39:24 +11002266 u32 osid, sid;
2267 int rc, i;
David Howellsa6f76f22008-11-14 10:39:24 +11002268
David Howellsa6f76f22008-11-14 10:39:24 +11002269 osid = tsec->osid;
2270 sid = tsec->sid;
2271
2272 if (sid == osid)
2273 return;
2274
2275 /* Check whether the new SID can inherit signal state from the old SID.
2276 * If not, clear itimers to avoid subsequent signal generation and
2277 * flush and unblock signals.
2278 *
2279 * This must occur _after_ the task SID has been updated so that any
2280 * kill done after the flush will be checked against the new SID.
2281 */
2282 rc = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__SIGINH, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 if (rc) {
2284 memset(&itimer, 0, sizeof itimer);
2285 for (i = 0; i < 3; i++)
2286 do_setitimer(i, &itimer, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 spin_lock_irq(&current->sighand->siglock);
David Howells3bcac022009-04-29 13:45:05 +01002288 if (!(current->signal->flags & SIGNAL_GROUP_EXIT)) {
2289 __flush_signals(current);
2290 flush_signal_handlers(current, 1);
2291 sigemptyset(&current->blocked);
2292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 spin_unlock_irq(&current->sighand->siglock);
2294 }
2295
David Howellsa6f76f22008-11-14 10:39:24 +11002296 /* Wake up the parent if it is waiting so that it can recheck
2297 * wait permission to the new task SID. */
Oleg Nesterovecd6de32009-04-29 16:02:24 +02002298 read_lock(&tasklist_lock);
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07002299 __wake_up_parent(current, current->real_parent);
Oleg Nesterovecd6de32009-04-29 16:02:24 +02002300 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301}
2302
2303/* superblock security operations */
2304
2305static int selinux_sb_alloc_security(struct super_block *sb)
2306{
2307 return superblock_alloc_security(sb);
2308}
2309
2310static void selinux_sb_free_security(struct super_block *sb)
2311{
2312 superblock_free_security(sb);
2313}
2314
2315static inline int match_prefix(char *prefix, int plen, char *option, int olen)
2316{
2317 if (plen > olen)
2318 return 0;
2319
2320 return !memcmp(prefix, option, plen);
2321}
2322
2323static inline int selinux_option(char *option, int len)
2324{
Eric Paris832cbd92008-04-01 13:24:09 -04002325 return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) ||
2326 match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) ||
2327 match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) ||
David P. Quigley11689d42009-01-16 09:22:03 -05002328 match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) ||
2329 match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330}
2331
2332static inline void take_option(char **to, char *from, int *first, int len)
2333{
2334 if (!*first) {
2335 **to = ',';
2336 *to += 1;
Cory Olmo3528a952006-09-29 01:58:44 -07002337 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 *first = 0;
2339 memcpy(*to, from, len);
2340 *to += len;
2341}
2342
Eric Paris828dfe12008-04-17 13:17:49 -04002343static inline void take_selinux_option(char **to, char *from, int *first,
2344 int len)
Cory Olmo3528a952006-09-29 01:58:44 -07002345{
2346 int current_size = 0;
2347
2348 if (!*first) {
2349 **to = '|';
2350 *to += 1;
Eric Paris828dfe12008-04-17 13:17:49 -04002351 } else
Cory Olmo3528a952006-09-29 01:58:44 -07002352 *first = 0;
2353
2354 while (current_size < len) {
2355 if (*from != '"') {
2356 **to = *from;
2357 *to += 1;
2358 }
2359 from += 1;
2360 current_size += 1;
2361 }
2362}
2363
Eric Parise0007522008-03-05 10:31:54 -05002364static int selinux_sb_copy_data(char *orig, char *copy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365{
2366 int fnosec, fsec, rc = 0;
2367 char *in_save, *in_curr, *in_end;
2368 char *sec_curr, *nosec_save, *nosec;
Cory Olmo3528a952006-09-29 01:58:44 -07002369 int open_quote = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370
2371 in_curr = orig;
2372 sec_curr = copy;
2373
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 nosec = (char *)get_zeroed_page(GFP_KERNEL);
2375 if (!nosec) {
2376 rc = -ENOMEM;
2377 goto out;
2378 }
2379
2380 nosec_save = nosec;
2381 fnosec = fsec = 1;
2382 in_save = in_end = orig;
2383
2384 do {
Cory Olmo3528a952006-09-29 01:58:44 -07002385 if (*in_end == '"')
2386 open_quote = !open_quote;
2387 if ((*in_end == ',' && open_quote == 0) ||
2388 *in_end == '\0') {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 int len = in_end - in_curr;
2390
2391 if (selinux_option(in_curr, len))
Cory Olmo3528a952006-09-29 01:58:44 -07002392 take_selinux_option(&sec_curr, in_curr, &fsec, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 else
2394 take_option(&nosec, in_curr, &fnosec, len);
2395
2396 in_curr = in_end + 1;
2397 }
2398 } while (*in_end++);
2399
Eric Paris6931dfc2005-06-30 02:58:51 -07002400 strcpy(in_save, nosec_save);
Gerald Schaeferda3caa22005-06-21 17:15:18 -07002401 free_page((unsigned long)nosec_save);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402out:
2403 return rc;
2404}
2405
Eric Paris026eb162011-03-03 16:09:14 -05002406static int selinux_sb_remount(struct super_block *sb, void *data)
2407{
2408 int rc, i, *flags;
2409 struct security_mnt_opts opts;
2410 char *secdata, **mount_options;
2411 struct superblock_security_struct *sbsec = sb->s_security;
2412
2413 if (!(sbsec->flags & SE_SBINITIALIZED))
2414 return 0;
2415
2416 if (!data)
2417 return 0;
2418
2419 if (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
2420 return 0;
2421
2422 security_init_mnt_opts(&opts);
2423 secdata = alloc_secdata();
2424 if (!secdata)
2425 return -ENOMEM;
2426 rc = selinux_sb_copy_data(data, secdata);
2427 if (rc)
2428 goto out_free_secdata;
2429
2430 rc = selinux_parse_opts_str(secdata, &opts);
2431 if (rc)
2432 goto out_free_secdata;
2433
2434 mount_options = opts.mnt_opts;
2435 flags = opts.mnt_opts_flags;
2436
2437 for (i = 0; i < opts.num_mnt_opts; i++) {
2438 u32 sid;
2439 size_t len;
2440
2441 if (flags[i] == SE_SBLABELSUPP)
2442 continue;
2443 len = strlen(mount_options[i]);
2444 rc = security_context_to_sid(mount_options[i], len, &sid);
2445 if (rc) {
2446 printk(KERN_WARNING "SELinux: security_context_to_sid"
2447 "(%s) failed for (dev %s, type %s) errno=%d\n",
2448 mount_options[i], sb->s_id, sb->s_type->name, rc);
2449 goto out_free_opts;
2450 }
2451 rc = -EINVAL;
2452 switch (flags[i]) {
2453 case FSCONTEXT_MNT:
2454 if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid, sid))
2455 goto out_bad_option;
2456 break;
2457 case CONTEXT_MNT:
2458 if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid, sid))
2459 goto out_bad_option;
2460 break;
2461 case ROOTCONTEXT_MNT: {
2462 struct inode_security_struct *root_isec;
2463 root_isec = sb->s_root->d_inode->i_security;
2464
2465 if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, sid))
2466 goto out_bad_option;
2467 break;
2468 }
2469 case DEFCONTEXT_MNT:
2470 if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid, sid))
2471 goto out_bad_option;
2472 break;
2473 default:
2474 goto out_free_opts;
2475 }
2476 }
2477
2478 rc = 0;
2479out_free_opts:
2480 security_free_mnt_opts(&opts);
2481out_free_secdata:
2482 free_secdata(secdata);
2483 return rc;
2484out_bad_option:
2485 printk(KERN_WARNING "SELinux: unable to change security options "
2486 "during remount (dev %s, type=%s)\n", sb->s_id,
2487 sb->s_type->name);
2488 goto out_free_opts;
2489}
2490
James Morris12204e22008-12-19 10:44:42 +11002491static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492{
David Howells88e67f32008-11-14 10:39:21 +11002493 const struct cred *cred = current_cred();
Thomas Liu2bf49692009-07-14 12:14:09 -04002494 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07002495 struct selinux_audit_data sad = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 int rc;
2497
2498 rc = superblock_doinit(sb, data);
2499 if (rc)
2500 return rc;
2501
James Morris74192242008-12-19 11:41:10 +11002502 /* Allow all mounts performed by the kernel */
2503 if (flags & MS_KERNMOUNT)
2504 return 0;
2505
Eric Parisa2694342011-04-25 13:10:27 -04002506 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
Eric Paris3b3b0e42012-04-03 09:37:02 -07002507 ad.selinux_audit_data = &sad;
Eric Parisa2694342011-04-25 13:10:27 -04002508 ad.u.dentry = sb->s_root;
David Howells88e67f32008-11-14 10:39:21 +11002509 return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510}
2511
David Howells726c3342006-06-23 02:02:58 -07002512static int selinux_sb_statfs(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513{
David Howells88e67f32008-11-14 10:39:21 +11002514 const struct cred *cred = current_cred();
Thomas Liu2bf49692009-07-14 12:14:09 -04002515 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07002516 struct selinux_audit_data sad = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517
Eric Parisa2694342011-04-25 13:10:27 -04002518 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
Eric Paris3b3b0e42012-04-03 09:37:02 -07002519 ad.selinux_audit_data = &sad;
Eric Parisa2694342011-04-25 13:10:27 -04002520 ad.u.dentry = dentry->d_sb->s_root;
David Howells88e67f32008-11-14 10:39:21 +11002521 return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522}
2523
Eric Paris828dfe12008-04-17 13:17:49 -04002524static int selinux_mount(char *dev_name,
Al Virob5266eb2008-03-22 17:48:24 -04002525 struct path *path,
Eric Paris828dfe12008-04-17 13:17:49 -04002526 char *type,
2527 unsigned long flags,
2528 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529{
David Howells88e67f32008-11-14 10:39:21 +11002530 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531
2532 if (flags & MS_REMOUNT)
Al Virod8c95842011-12-07 18:16:57 -05002533 return superblock_has_perm(cred, path->dentry->d_sb,
Eric Paris828dfe12008-04-17 13:17:49 -04002534 FILESYSTEM__REMOUNT, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 else
Eric Paris2875fa02011-04-28 16:04:24 -04002536 return path_has_perm(cred, path, FILE__MOUNTON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537}
2538
2539static int selinux_umount(struct vfsmount *mnt, int flags)
2540{
David Howells88e67f32008-11-14 10:39:21 +11002541 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542
David Howells88e67f32008-11-14 10:39:21 +11002543 return superblock_has_perm(cred, mnt->mnt_sb,
Eric Paris828dfe12008-04-17 13:17:49 -04002544 FILESYSTEM__UNMOUNT, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545}
2546
2547/* inode security operations */
2548
2549static int selinux_inode_alloc_security(struct inode *inode)
2550{
2551 return inode_alloc_security(inode);
2552}
2553
2554static void selinux_inode_free_security(struct inode *inode)
2555{
2556 inode_free_security(inode);
2557}
2558
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002559static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
Eric Paris2a7dba32011-02-01 11:05:39 -05002560 const struct qstr *qstr, char **name,
2561 void **value, size_t *len)
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002562{
Paul Moore5fb49872010-04-22 14:46:19 -04002563 const struct task_security_struct *tsec = current_security();
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002564 struct inode_security_struct *dsec;
2565 struct superblock_security_struct *sbsec;
David Howells275bb412008-11-14 10:39:19 +11002566 u32 sid, newsid, clen;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002567 int rc;
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002568 char *namep = NULL, *context;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002569
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002570 dsec = dir->i_security;
2571 sbsec = dir->i_sb->s_security;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002572
David Howells275bb412008-11-14 10:39:19 +11002573 sid = tsec->sid;
2574 newsid = tsec->create_sid;
2575
Eric Paris415103f2010-12-02 16:13:40 -05002576 if ((sbsec->flags & SE_SBINITIALIZED) &&
2577 (sbsec->behavior == SECURITY_FS_USE_MNTPOINT))
2578 newsid = sbsec->mntpoint_sid;
2579 else if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
David Howells275bb412008-11-14 10:39:19 +11002580 rc = security_transition_sid(sid, dsec->sid,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002581 inode_mode_to_security_class(inode->i_mode),
Eric Paris652bb9b2011-02-01 11:05:40 -05002582 qstr, &newsid);
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002583 if (rc) {
2584 printk(KERN_WARNING "%s: "
2585 "security_transition_sid failed, rc=%d (dev=%s "
2586 "ino=%ld)\n",
Harvey Harrisondd6f9532008-03-06 10:03:59 +11002587 __func__,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002588 -rc, inode->i_sb->s_id, inode->i_ino);
2589 return rc;
2590 }
2591 }
2592
Eric Paris296fddf2006-09-25 23:32:00 -07002593 /* Possibly defer initialization to selinux_complete_init. */
David P. Quigley0d90a7e2009-01-16 09:22:02 -05002594 if (sbsec->flags & SE_SBINITIALIZED) {
Eric Paris296fddf2006-09-25 23:32:00 -07002595 struct inode_security_struct *isec = inode->i_security;
2596 isec->sclass = inode_mode_to_security_class(inode->i_mode);
2597 isec->sid = newsid;
2598 isec->initialized = 1;
2599 }
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002600
David P. Quigleycd895962009-01-16 09:22:04 -05002601 if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
Stephen Smalley25a74f32005-11-08 21:34:33 -08002602 return -EOPNOTSUPP;
2603
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002604 if (name) {
Josef Bacika02fe132008-04-04 09:35:05 +11002605 namep = kstrdup(XATTR_SELINUX_SUFFIX, GFP_NOFS);
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002606 if (!namep)
2607 return -ENOMEM;
2608 *name = namep;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002609 }
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002610
2611 if (value && len) {
Stephen Smalley12b29f32008-05-07 13:03:20 -04002612 rc = security_sid_to_context_force(newsid, &context, &clen);
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002613 if (rc) {
2614 kfree(namep);
2615 return rc;
2616 }
2617 *value = context;
2618 *len = clen;
2619 }
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002620
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002621 return 0;
2622}
2623
Al Viro4acdaf22011-07-26 01:42:34 -04002624static int selinux_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625{
2626 return may_create(dir, dentry, SECCLASS_FILE);
2627}
2628
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2630{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 return may_link(dir, old_dentry, MAY_LINK);
2632}
2633
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry)
2635{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 return may_link(dir, dentry, MAY_UNLINK);
2637}
2638
2639static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name)
2640{
2641 return may_create(dir, dentry, SECCLASS_LNK_FILE);
2642}
2643
Al Viro18bb1db2011-07-26 01:41:39 -04002644static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645{
2646 return may_create(dir, dentry, SECCLASS_DIR);
2647}
2648
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry)
2650{
2651 return may_link(dir, dentry, MAY_RMDIR);
2652}
2653
Al Viro1a67aaf2011-07-26 01:52:52 -04002654static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 return may_create(dir, dentry, inode_mode_to_security_class(mode));
2657}
2658
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry,
Eric Paris828dfe12008-04-17 13:17:49 -04002660 struct inode *new_inode, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661{
2662 return may_rename(old_inode, old_dentry, new_inode, new_dentry);
2663}
2664
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665static int selinux_inode_readlink(struct dentry *dentry)
2666{
David Howells88e67f32008-11-14 10:39:21 +11002667 const struct cred *cred = current_cred();
2668
Eric Paris2875fa02011-04-28 16:04:24 -04002669 return dentry_has_perm(cred, dentry, FILE__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670}
2671
2672static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *nameidata)
2673{
David Howells88e67f32008-11-14 10:39:21 +11002674 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675
Eric Paris2875fa02011-04-28 16:04:24 -04002676 return dentry_has_perm(cred, dentry, FILE__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677}
2678
Al Viroe74f71e2011-06-20 19:38:15 -04002679static int selinux_inode_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680{
David Howells88e67f32008-11-14 10:39:21 +11002681 const struct cred *cred = current_cred();
Eric Parisb782e0a2010-07-23 11:44:03 -04002682 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07002683 struct selinux_audit_data sad = {0,};
Eric Parisb782e0a2010-07-23 11:44:03 -04002684 u32 perms;
2685 bool from_access;
Al Virocf1dd1d2011-06-20 19:44:08 -04002686 unsigned flags = mask & MAY_NOT_BLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687
Eric Parisb782e0a2010-07-23 11:44:03 -04002688 from_access = mask & MAY_ACCESS;
Eric Parisd09ca732010-07-23 11:43:57 -04002689 mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
2690
Eric Parisb782e0a2010-07-23 11:44:03 -04002691 /* No permission to check. Existence test. */
2692 if (!mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694
Eric Parisf48b7392011-04-25 12:54:27 -04002695 COMMON_AUDIT_DATA_INIT(&ad, INODE);
Eric Paris3b3b0e42012-04-03 09:37:02 -07002696 ad.selinux_audit_data = &sad;
Eric Parisf48b7392011-04-25 12:54:27 -04002697 ad.u.inode = inode;
Eric Parisb782e0a2010-07-23 11:44:03 -04002698
2699 if (from_access)
Eric Paris3b3b0e42012-04-03 09:37:02 -07002700 ad.selinux_audit_data->auditdeny |= FILE__AUDIT_ACCESS;
Eric Parisb782e0a2010-07-23 11:44:03 -04002701
2702 perms = file_mask_to_av(inode->i_mode, mask);
2703
Eric Paris9ade0cf2011-04-25 16:26:29 -04002704 return inode_has_perm(cred, inode, perms, &ad, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705}
2706
2707static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
2708{
David Howells88e67f32008-11-14 10:39:21 +11002709 const struct cred *cred = current_cred();
Amerigo Wangbc6a6002009-08-20 19:29:02 -07002710 unsigned int ia_valid = iattr->ia_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711
Amerigo Wangbc6a6002009-08-20 19:29:02 -07002712 /* ATTR_FORCE is just used for ATTR_KILL_S[UG]ID. */
2713 if (ia_valid & ATTR_FORCE) {
2714 ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_MODE |
2715 ATTR_FORCE);
2716 if (!ia_valid)
2717 return 0;
2718 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719
Amerigo Wangbc6a6002009-08-20 19:29:02 -07002720 if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID |
2721 ATTR_ATIME_SET | ATTR_MTIME_SET | ATTR_TIMES_SET))
Eric Paris2875fa02011-04-28 16:04:24 -04002722 return dentry_has_perm(cred, dentry, FILE__SETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723
Eric Paris2875fa02011-04-28 16:04:24 -04002724 return dentry_has_perm(cred, dentry, FILE__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725}
2726
2727static int selinux_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
2728{
David Howells88e67f32008-11-14 10:39:21 +11002729 const struct cred *cred = current_cred();
Eric Paris2875fa02011-04-28 16:04:24 -04002730 struct path path;
David Howells88e67f32008-11-14 10:39:21 +11002731
Eric Paris2875fa02011-04-28 16:04:24 -04002732 path.dentry = dentry;
2733 path.mnt = mnt;
2734
2735 return path_has_perm(cred, &path, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736}
2737
David Howells8f0cfa52008-04-29 00:59:41 -07002738static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name)
Serge E. Hallynb5376772007-10-16 23:31:36 -07002739{
David Howells88e67f32008-11-14 10:39:21 +11002740 const struct cred *cred = current_cred();
2741
Serge E. Hallynb5376772007-10-16 23:31:36 -07002742 if (!strncmp(name, XATTR_SECURITY_PREFIX,
2743 sizeof XATTR_SECURITY_PREFIX - 1)) {
2744 if (!strcmp(name, XATTR_NAME_CAPS)) {
2745 if (!capable(CAP_SETFCAP))
2746 return -EPERM;
2747 } else if (!capable(CAP_SYS_ADMIN)) {
2748 /* A different attribute in the security namespace.
2749 Restrict to administrator. */
2750 return -EPERM;
2751 }
2752 }
2753
2754 /* Not an attribute we recognize, so just check the
2755 ordinary setattr permission. */
Eric Paris2875fa02011-04-28 16:04:24 -04002756 return dentry_has_perm(cred, dentry, FILE__SETATTR);
Serge E. Hallynb5376772007-10-16 23:31:36 -07002757}
2758
David Howells8f0cfa52008-04-29 00:59:41 -07002759static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
2760 const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 struct inode *inode = dentry->d_inode;
2763 struct inode_security_struct *isec = inode->i_security;
2764 struct superblock_security_struct *sbsec;
Thomas Liu2bf49692009-07-14 12:14:09 -04002765 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07002766 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11002767 u32 newsid, sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 int rc = 0;
2769
Serge E. Hallynb5376772007-10-16 23:31:36 -07002770 if (strcmp(name, XATTR_NAME_SELINUX))
2771 return selinux_inode_setotherxattr(dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772
2773 sbsec = inode->i_sb->s_security;
David P. Quigleycd895962009-01-16 09:22:04 -05002774 if (!(sbsec->flags & SE_SBLABELSUPP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775 return -EOPNOTSUPP;
2776
Serge E. Hallyn2e149672011-03-23 16:43:26 -07002777 if (!inode_owner_or_capable(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 return -EPERM;
2779
Eric Parisa2694342011-04-25 13:10:27 -04002780 COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
Eric Paris3b3b0e42012-04-03 09:37:02 -07002781 ad.selinux_audit_data = &sad;
Eric Parisa2694342011-04-25 13:10:27 -04002782 ad.u.dentry = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783
David Howells275bb412008-11-14 10:39:19 +11002784 rc = avc_has_perm(sid, isec->sid, isec->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 FILE__RELABELFROM, &ad);
2786 if (rc)
2787 return rc;
2788
2789 rc = security_context_to_sid(value, size, &newsid);
Stephen Smalley12b29f32008-05-07 13:03:20 -04002790 if (rc == -EINVAL) {
2791 if (!capable(CAP_MAC_ADMIN))
2792 return rc;
2793 rc = security_context_to_sid_force(value, size, &newsid);
2794 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 if (rc)
2796 return rc;
2797
David Howells275bb412008-11-14 10:39:19 +11002798 rc = avc_has_perm(sid, newsid, isec->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799 FILE__RELABELTO, &ad);
2800 if (rc)
2801 return rc;
2802
David Howells275bb412008-11-14 10:39:19 +11002803 rc = security_validate_transition(isec->sid, newsid, sid,
Eric Paris828dfe12008-04-17 13:17:49 -04002804 isec->sclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 if (rc)
2806 return rc;
2807
2808 return avc_has_perm(newsid,
2809 sbsec->sid,
2810 SECCLASS_FILESYSTEM,
2811 FILESYSTEM__ASSOCIATE,
2812 &ad);
2813}
2814
David Howells8f0cfa52008-04-29 00:59:41 -07002815static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
Eric Parisf5269712008-05-14 11:27:45 -04002816 const void *value, size_t size,
David Howells8f0cfa52008-04-29 00:59:41 -07002817 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818{
2819 struct inode *inode = dentry->d_inode;
2820 struct inode_security_struct *isec = inode->i_security;
2821 u32 newsid;
2822 int rc;
2823
2824 if (strcmp(name, XATTR_NAME_SELINUX)) {
2825 /* Not an attribute we recognize, so nothing to do. */
2826 return;
2827 }
2828
Stephen Smalley12b29f32008-05-07 13:03:20 -04002829 rc = security_context_to_sid_force(value, size, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 if (rc) {
Stephen Smalley12b29f32008-05-07 13:03:20 -04002831 printk(KERN_ERR "SELinux: unable to map context to SID"
2832 "for (%s, %lu), rc=%d\n",
2833 inode->i_sb->s_id, inode->i_ino, -rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 return;
2835 }
2836
2837 isec->sid = newsid;
2838 return;
2839}
2840
David Howells8f0cfa52008-04-29 00:59:41 -07002841static int selinux_inode_getxattr(struct dentry *dentry, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842{
David Howells88e67f32008-11-14 10:39:21 +11002843 const struct cred *cred = current_cred();
2844
Eric Paris2875fa02011-04-28 16:04:24 -04002845 return dentry_has_perm(cred, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846}
2847
Eric Paris828dfe12008-04-17 13:17:49 -04002848static int selinux_inode_listxattr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849{
David Howells88e67f32008-11-14 10:39:21 +11002850 const struct cred *cred = current_cred();
2851
Eric Paris2875fa02011-04-28 16:04:24 -04002852 return dentry_has_perm(cred, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853}
2854
David Howells8f0cfa52008-04-29 00:59:41 -07002855static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856{
Serge E. Hallynb5376772007-10-16 23:31:36 -07002857 if (strcmp(name, XATTR_NAME_SELINUX))
2858 return selinux_inode_setotherxattr(dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859
2860 /* No one is allowed to remove a SELinux security label.
2861 You can change the label, but all data must be labeled. */
2862 return -EACCES;
2863}
2864
James Morrisd381d8a2005-10-30 14:59:22 -08002865/*
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002866 * Copy the inode security context value to the user.
James Morrisd381d8a2005-10-30 14:59:22 -08002867 *
2868 * Permission check is handled by selinux_inode_getxattr hook.
2869 */
David P. Quigley42492592008-02-04 22:29:39 -08002870static int selinux_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871{
David P. Quigley42492592008-02-04 22:29:39 -08002872 u32 size;
2873 int error;
2874 char *context = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875 struct inode_security_struct *isec = inode->i_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876
Dustin Kirkland8c8570f2005-11-03 17:15:16 +00002877 if (strcmp(name, XATTR_SELINUX_SUFFIX))
2878 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002880 /*
2881 * If the caller has CAP_MAC_ADMIN, then get the raw context
2882 * value even if it is not defined by current policy; otherwise,
2883 * use the in-core value under current policy.
2884 * Use the non-auditing forms of the permission checks since
2885 * getxattr may be called by unprivileged processes commonly
2886 * and lack of permission just means that we fall back to the
2887 * in-core context value, not a denial.
2888 */
Eric Paris6a9de492012-01-03 12:25:14 -05002889 error = selinux_capable(current_cred(), &init_user_ns, CAP_MAC_ADMIN,
David Howells3699c532009-01-06 22:27:01 +00002890 SECURITY_CAP_NOAUDIT);
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002891 if (!error)
2892 error = security_sid_to_context_force(isec->sid, &context,
2893 &size);
2894 else
2895 error = security_sid_to_context(isec->sid, &context, &size);
David P. Quigley42492592008-02-04 22:29:39 -08002896 if (error)
2897 return error;
2898 error = size;
2899 if (alloc) {
2900 *buffer = context;
2901 goto out_nofree;
2902 }
2903 kfree(context);
2904out_nofree:
2905 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906}
2907
2908static int selinux_inode_setsecurity(struct inode *inode, const char *name,
Eric Paris828dfe12008-04-17 13:17:49 -04002909 const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910{
2911 struct inode_security_struct *isec = inode->i_security;
2912 u32 newsid;
2913 int rc;
2914
2915 if (strcmp(name, XATTR_SELINUX_SUFFIX))
2916 return -EOPNOTSUPP;
2917
2918 if (!value || !size)
2919 return -EACCES;
2920
Eric Paris828dfe12008-04-17 13:17:49 -04002921 rc = security_context_to_sid((void *)value, size, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922 if (rc)
2923 return rc;
2924
2925 isec->sid = newsid;
David P. Quigleyddd29ec2009-09-09 14:25:37 -04002926 isec->initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 return 0;
2928}
2929
2930static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
2931{
2932 const int len = sizeof(XATTR_NAME_SELINUX);
2933 if (buffer && len <= buffer_size)
2934 memcpy(buffer, XATTR_NAME_SELINUX, len);
2935 return len;
2936}
2937
Ahmed S. Darwish713a04a2008-03-01 21:52:30 +02002938static void selinux_inode_getsecid(const struct inode *inode, u32 *secid)
2939{
2940 struct inode_security_struct *isec = inode->i_security;
2941 *secid = isec->sid;
2942}
2943
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944/* file security operations */
2945
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002946static int selinux_revalidate_file_permission(struct file *file, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947{
David Howells88e67f32008-11-14 10:39:21 +11002948 const struct cred *cred = current_cred();
Josef Sipek3d5ff522006-12-08 02:37:38 -08002949 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 /* file_mask_to_av won't add FILE__WRITE if MAY_APPEND is set */
2952 if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE))
2953 mask |= MAY_APPEND;
2954
Paul Moore389fb802009-03-27 17:10:34 -04002955 return file_has_perm(cred, file,
2956 file_mask_to_av(inode->i_mode, mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957}
2958
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002959static int selinux_file_permission(struct file *file, int mask)
2960{
Stephen Smalley20dda182009-06-22 14:54:53 -04002961 struct inode *inode = file->f_path.dentry->d_inode;
2962 struct file_security_struct *fsec = file->f_security;
2963 struct inode_security_struct *isec = inode->i_security;
2964 u32 sid = current_sid();
2965
Paul Moore389fb802009-03-27 17:10:34 -04002966 if (!mask)
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002967 /* No permission to check. Existence test. */
2968 return 0;
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002969
Stephen Smalley20dda182009-06-22 14:54:53 -04002970 if (sid == fsec->sid && fsec->isid == isec->sid &&
2971 fsec->pseqno == avc_policy_seqno())
2972 /* No change since dentry_open check. */
2973 return 0;
2974
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002975 return selinux_revalidate_file_permission(file, mask);
2976}
2977
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978static int selinux_file_alloc_security(struct file *file)
2979{
2980 return file_alloc_security(file);
2981}
2982
2983static void selinux_file_free_security(struct file *file)
2984{
2985 file_free_security(file);
2986}
2987
2988static int selinux_file_ioctl(struct file *file, unsigned int cmd,
2989 unsigned long arg)
2990{
David Howells88e67f32008-11-14 10:39:21 +11002991 const struct cred *cred = current_cred();
Eric Paris0b24dcb2011-02-25 15:39:20 -05002992 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993
Eric Paris0b24dcb2011-02-25 15:39:20 -05002994 switch (cmd) {
2995 case FIONREAD:
2996 /* fall through */
2997 case FIBMAP:
2998 /* fall through */
2999 case FIGETBSZ:
3000 /* fall through */
Al Viro2f99c362012-03-23 16:04:05 -04003001 case FS_IOC_GETFLAGS:
Eric Paris0b24dcb2011-02-25 15:39:20 -05003002 /* fall through */
Al Viro2f99c362012-03-23 16:04:05 -04003003 case FS_IOC_GETVERSION:
Eric Paris0b24dcb2011-02-25 15:39:20 -05003004 error = file_has_perm(cred, file, FILE__GETATTR);
3005 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006
Al Viro2f99c362012-03-23 16:04:05 -04003007 case FS_IOC_SETFLAGS:
Eric Paris0b24dcb2011-02-25 15:39:20 -05003008 /* fall through */
Al Viro2f99c362012-03-23 16:04:05 -04003009 case FS_IOC_SETVERSION:
Eric Paris0b24dcb2011-02-25 15:39:20 -05003010 error = file_has_perm(cred, file, FILE__SETATTR);
3011 break;
3012
3013 /* sys_ioctl() checks */
3014 case FIONBIO:
3015 /* fall through */
3016 case FIOASYNC:
3017 error = file_has_perm(cred, file, 0);
3018 break;
3019
3020 case KDSKBENT:
3021 case KDSKBSENT:
Eric Paris6a9de492012-01-03 12:25:14 -05003022 error = cred_has_capability(cred, CAP_SYS_TTY_CONFIG,
3023 SECURITY_CAP_AUDIT);
Eric Paris0b24dcb2011-02-25 15:39:20 -05003024 break;
3025
3026 /* default case assumes that the command will go
3027 * to the file's ioctl() function.
3028 */
3029 default:
3030 error = file_has_perm(cred, file, FILE__IOCTL);
3031 }
3032 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003033}
3034
Stephen Smalleyfcaaade2010-04-28 15:57:57 -04003035static int default_noexec;
3036
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037static int file_map_prot_check(struct file *file, unsigned long prot, int shared)
3038{
David Howells88e67f32008-11-14 10:39:21 +11003039 const struct cred *cred = current_cred();
David Howellsd84f4f92008-11-14 10:39:23 +11003040 int rc = 0;
David Howells88e67f32008-11-14 10:39:21 +11003041
Stephen Smalleyfcaaade2010-04-28 15:57:57 -04003042 if (default_noexec &&
3043 (prot & PROT_EXEC) && (!file || (!shared && (prot & PROT_WRITE)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 /*
3045 * We are making executable an anonymous mapping or a
3046 * private file mapping that will also be writable.
3047 * This has an additional check.
3048 */
David Howellsd84f4f92008-11-14 10:39:23 +11003049 rc = cred_has_perm(cred, cred, PROCESS__EXECMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 if (rc)
David Howellsd84f4f92008-11-14 10:39:23 +11003051 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053
3054 if (file) {
3055 /* read access is always possible with a mapping */
3056 u32 av = FILE__READ;
3057
3058 /* write access only matters if the mapping is shared */
3059 if (shared && (prot & PROT_WRITE))
3060 av |= FILE__WRITE;
3061
3062 if (prot & PROT_EXEC)
3063 av |= FILE__EXECUTE;
3064
David Howells88e67f32008-11-14 10:39:21 +11003065 return file_has_perm(cred, file, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003066 }
David Howellsd84f4f92008-11-14 10:39:23 +11003067
3068error:
3069 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070}
3071
3072static int selinux_file_mmap(struct file *file, unsigned long reqprot,
Eric Parised032182007-06-28 15:55:21 -04003073 unsigned long prot, unsigned long flags,
3074 unsigned long addr, unsigned long addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075{
Eric Parised032182007-06-28 15:55:21 -04003076 int rc = 0;
David Howells275bb412008-11-14 10:39:19 +11003077 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078
Eric Paris84336d1a2009-07-31 12:54:05 -04003079 /*
3080 * notice that we are intentionally putting the SELinux check before
3081 * the secondary cap_file_mmap check. This is such a likely attempt
3082 * at bad behaviour/exploit that we always want to get the AVC, even
3083 * if DAC would have also denied the operation.
3084 */
Eric Parisa2551df2009-07-31 12:54:11 -04003085 if (addr < CONFIG_LSM_MMAP_MIN_ADDR) {
Eric Parised032182007-06-28 15:55:21 -04003086 rc = avc_has_perm(sid, sid, SECCLASS_MEMPROTECT,
3087 MEMPROTECT__MMAP_ZERO, NULL);
Eric Paris84336d1a2009-07-31 12:54:05 -04003088 if (rc)
3089 return rc;
3090 }
3091
3092 /* do DAC check on address space usage */
3093 rc = cap_file_mmap(file, reqprot, prot, flags, addr, addr_only);
Eric Parised032182007-06-28 15:55:21 -04003094 if (rc || addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 return rc;
3096
3097 if (selinux_checkreqprot)
3098 prot = reqprot;
3099
3100 return file_map_prot_check(file, prot,
3101 (flags & MAP_TYPE) == MAP_SHARED);
3102}
3103
3104static int selinux_file_mprotect(struct vm_area_struct *vma,
3105 unsigned long reqprot,
3106 unsigned long prot)
3107{
David Howells88e67f32008-11-14 10:39:21 +11003108 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109
3110 if (selinux_checkreqprot)
3111 prot = reqprot;
3112
Stephen Smalleyfcaaade2010-04-28 15:57:57 -04003113 if (default_noexec &&
3114 (prot & PROT_EXEC) && !(vma->vm_flags & VM_EXEC)) {
James Morrisd541bbe2009-01-29 12:19:51 +11003115 int rc = 0;
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003116 if (vma->vm_start >= vma->vm_mm->start_brk &&
3117 vma->vm_end <= vma->vm_mm->brk) {
David Howellsd84f4f92008-11-14 10:39:23 +11003118 rc = cred_has_perm(cred, cred, PROCESS__EXECHEAP);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003119 } else if (!vma->vm_file &&
3120 vma->vm_start <= vma->vm_mm->start_stack &&
3121 vma->vm_end >= vma->vm_mm->start_stack) {
David Howells3b11a1d2008-11-14 10:39:26 +11003122 rc = current_has_perm(current, PROCESS__EXECSTACK);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003123 } else if (vma->vm_file && vma->anon_vma) {
3124 /*
3125 * We are making executable a file mapping that has
3126 * had some COW done. Since pages might have been
3127 * written, check ability to execute the possibly
3128 * modified content. This typically should only
3129 * occur for text relocations.
3130 */
David Howellsd84f4f92008-11-14 10:39:23 +11003131 rc = file_has_perm(cred, vma->vm_file, FILE__EXECMOD);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003132 }
Lorenzo Hernandez García-Hierro6b992192005-06-25 14:54:34 -07003133 if (rc)
3134 return rc;
3135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003136
3137 return file_map_prot_check(vma->vm_file, prot, vma->vm_flags&VM_SHARED);
3138}
3139
3140static int selinux_file_lock(struct file *file, unsigned int cmd)
3141{
David Howells88e67f32008-11-14 10:39:21 +11003142 const struct cred *cred = current_cred();
3143
3144 return file_has_perm(cred, file, FILE__LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145}
3146
3147static int selinux_file_fcntl(struct file *file, unsigned int cmd,
3148 unsigned long arg)
3149{
David Howells88e67f32008-11-14 10:39:21 +11003150 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 int err = 0;
3152
3153 switch (cmd) {
Eric Paris828dfe12008-04-17 13:17:49 -04003154 case F_SETFL:
3155 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3156 err = -EINVAL;
3157 break;
3158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159
Eric Paris828dfe12008-04-17 13:17:49 -04003160 if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) {
David Howells88e67f32008-11-14 10:39:21 +11003161 err = file_has_perm(cred, file, FILE__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003163 }
3164 /* fall through */
3165 case F_SETOWN:
3166 case F_SETSIG:
3167 case F_GETFL:
3168 case F_GETOWN:
3169 case F_GETSIG:
3170 /* Just check FD__USE permission */
David Howells88e67f32008-11-14 10:39:21 +11003171 err = file_has_perm(cred, file, 0);
Eric Paris828dfe12008-04-17 13:17:49 -04003172 break;
3173 case F_GETLK:
3174 case F_SETLK:
3175 case F_SETLKW:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176#if BITS_PER_LONG == 32
Eric Paris828dfe12008-04-17 13:17:49 -04003177 case F_GETLK64:
3178 case F_SETLK64:
3179 case F_SETLKW64:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180#endif
Eric Paris828dfe12008-04-17 13:17:49 -04003181 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3182 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003184 }
David Howells88e67f32008-11-14 10:39:21 +11003185 err = file_has_perm(cred, file, FILE__LOCK);
Eric Paris828dfe12008-04-17 13:17:49 -04003186 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 }
3188
3189 return err;
3190}
3191
3192static int selinux_file_set_fowner(struct file *file)
3193{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194 struct file_security_struct *fsec;
3195
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196 fsec = file->f_security;
David Howells275bb412008-11-14 10:39:19 +11003197 fsec->fown_sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198
3199 return 0;
3200}
3201
3202static int selinux_file_send_sigiotask(struct task_struct *tsk,
3203 struct fown_struct *fown, int signum)
3204{
Eric Paris828dfe12008-04-17 13:17:49 -04003205 struct file *file;
Stephen Smalley65c90bc2009-05-04 15:43:18 -04003206 u32 sid = task_sid(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 u32 perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 struct file_security_struct *fsec;
3209
3210 /* struct fown_struct is never outside the context of a struct file */
Eric Paris828dfe12008-04-17 13:17:49 -04003211 file = container_of(fown, struct file, f_owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213 fsec = file->f_security;
3214
3215 if (!signum)
3216 perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */
3217 else
3218 perm = signal_to_av(signum);
3219
David Howells275bb412008-11-14 10:39:19 +11003220 return avc_has_perm(fsec->fown_sid, sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221 SECCLASS_PROCESS, perm, NULL);
3222}
3223
3224static int selinux_file_receive(struct file *file)
3225{
David Howells88e67f32008-11-14 10:39:21 +11003226 const struct cred *cred = current_cred();
3227
3228 return file_has_perm(cred, file, file_to_av(file));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229}
3230
David Howells745ca242008-11-14 10:39:22 +11003231static int selinux_dentry_open(struct file *file, const struct cred *cred)
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003232{
3233 struct file_security_struct *fsec;
3234 struct inode *inode;
3235 struct inode_security_struct *isec;
David Howellsd84f4f92008-11-14 10:39:23 +11003236
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003237 inode = file->f_path.dentry->d_inode;
3238 fsec = file->f_security;
3239 isec = inode->i_security;
3240 /*
3241 * Save inode label and policy sequence number
3242 * at open-time so that selinux_file_permission
3243 * can determine whether revalidation is necessary.
3244 * Task label is already saved in the file security
3245 * struct as its SID.
3246 */
3247 fsec->isid = isec->sid;
3248 fsec->pseqno = avc_policy_seqno();
3249 /*
3250 * Since the inode label or policy seqno may have changed
3251 * between the selinux_inode_permission check and the saving
3252 * of state above, recheck that access is still permitted.
3253 * Otherwise, access might never be revalidated against the
3254 * new inode label or new policy.
3255 * This check is not redundant - do not remove.
3256 */
Linus Torvalds95f4efb2011-06-08 15:11:56 -07003257 return inode_has_perm_noadp(cred, inode, open_file_to_av(file), 0);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003258}
3259
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260/* task security operations */
3261
3262static int selinux_task_create(unsigned long clone_flags)
3263{
David Howells3b11a1d2008-11-14 10:39:26 +11003264 return current_has_perm(current, PROCESS__FORK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265}
3266
David Howellsf1752ee2008-11-14 10:39:17 +11003267/*
David Howellsee18d642009-09-02 09:14:21 +01003268 * allocate the SELinux part of blank credentials
3269 */
3270static int selinux_cred_alloc_blank(struct cred *cred, gfp_t gfp)
3271{
3272 struct task_security_struct *tsec;
3273
3274 tsec = kzalloc(sizeof(struct task_security_struct), gfp);
3275 if (!tsec)
3276 return -ENOMEM;
3277
3278 cred->security = tsec;
3279 return 0;
3280}
3281
3282/*
David Howellsf1752ee2008-11-14 10:39:17 +11003283 * detach and free the LSM part of a set of credentials
3284 */
3285static void selinux_cred_free(struct cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003286{
David Howellsf1752ee2008-11-14 10:39:17 +11003287 struct task_security_struct *tsec = cred->security;
David Howellse0e81732009-09-02 09:13:40 +01003288
Tetsuo Handa2edeaa32011-02-07 13:36:10 +00003289 /*
3290 * cred->security == NULL if security_cred_alloc_blank() or
3291 * security_prepare_creds() returned an error.
3292 */
3293 BUG_ON(cred->security && (unsigned long) cred->security < PAGE_SIZE);
David Howellse0e81732009-09-02 09:13:40 +01003294 cred->security = (void *) 0x7UL;
David Howellsf1752ee2008-11-14 10:39:17 +11003295 kfree(tsec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296}
3297
David Howellsd84f4f92008-11-14 10:39:23 +11003298/*
3299 * prepare a new set of credentials for modification
3300 */
3301static int selinux_cred_prepare(struct cred *new, const struct cred *old,
3302 gfp_t gfp)
3303{
3304 const struct task_security_struct *old_tsec;
3305 struct task_security_struct *tsec;
3306
3307 old_tsec = old->security;
3308
3309 tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp);
3310 if (!tsec)
3311 return -ENOMEM;
3312
3313 new->security = tsec;
3314 return 0;
3315}
3316
3317/*
David Howellsee18d642009-09-02 09:14:21 +01003318 * transfer the SELinux data to a blank set of creds
3319 */
3320static void selinux_cred_transfer(struct cred *new, const struct cred *old)
3321{
3322 const struct task_security_struct *old_tsec = old->security;
3323 struct task_security_struct *tsec = new->security;
3324
3325 *tsec = *old_tsec;
3326}
3327
3328/*
David Howells3a3b7ce2008-11-14 10:39:28 +11003329 * set the security data for a kernel service
3330 * - all the creation contexts are set to unlabelled
3331 */
3332static int selinux_kernel_act_as(struct cred *new, u32 secid)
3333{
3334 struct task_security_struct *tsec = new->security;
3335 u32 sid = current_sid();
3336 int ret;
3337
3338 ret = avc_has_perm(sid, secid,
3339 SECCLASS_KERNEL_SERVICE,
3340 KERNEL_SERVICE__USE_AS_OVERRIDE,
3341 NULL);
3342 if (ret == 0) {
3343 tsec->sid = secid;
3344 tsec->create_sid = 0;
3345 tsec->keycreate_sid = 0;
3346 tsec->sockcreate_sid = 0;
3347 }
3348 return ret;
3349}
3350
3351/*
3352 * set the file creation context in a security record to the same as the
3353 * objective context of the specified inode
3354 */
3355static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
3356{
3357 struct inode_security_struct *isec = inode->i_security;
3358 struct task_security_struct *tsec = new->security;
3359 u32 sid = current_sid();
3360 int ret;
3361
3362 ret = avc_has_perm(sid, isec->sid,
3363 SECCLASS_KERNEL_SERVICE,
3364 KERNEL_SERVICE__CREATE_FILES_AS,
3365 NULL);
3366
3367 if (ret == 0)
3368 tsec->create_sid = isec->sid;
David Howellsef574712010-02-26 01:56:16 +00003369 return ret;
David Howells3a3b7ce2008-11-14 10:39:28 +11003370}
3371
Eric Parisdd8dbf22009-11-03 16:35:32 +11003372static int selinux_kernel_module_request(char *kmod_name)
Eric Paris25354c42009-08-13 09:45:03 -04003373{
Eric Parisdd8dbf22009-11-03 16:35:32 +11003374 u32 sid;
3375 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07003376 struct selinux_audit_data sad = {0,};
Eric Parisdd8dbf22009-11-03 16:35:32 +11003377
3378 sid = task_sid(current);
3379
3380 COMMON_AUDIT_DATA_INIT(&ad, KMOD);
Eric Paris3b3b0e42012-04-03 09:37:02 -07003381 ad.selinux_audit_data = &sad;
Eric Parisdd8dbf22009-11-03 16:35:32 +11003382 ad.u.kmod_name = kmod_name;
3383
3384 return avc_has_perm(sid, SECINITSID_KERNEL, SECCLASS_SYSTEM,
3385 SYSTEM__MODULE_REQUEST, &ad);
Eric Paris25354c42009-08-13 09:45:03 -04003386}
3387
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
3389{
David Howells3b11a1d2008-11-14 10:39:26 +11003390 return current_has_perm(p, PROCESS__SETPGID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391}
3392
3393static int selinux_task_getpgid(struct task_struct *p)
3394{
David Howells3b11a1d2008-11-14 10:39:26 +11003395 return current_has_perm(p, PROCESS__GETPGID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003396}
3397
3398static int selinux_task_getsid(struct task_struct *p)
3399{
David Howells3b11a1d2008-11-14 10:39:26 +11003400 return current_has_perm(p, PROCESS__GETSESSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401}
3402
David Quigleyf9008e42006-06-30 01:55:46 -07003403static void selinux_task_getsecid(struct task_struct *p, u32 *secid)
3404{
David Howells275bb412008-11-14 10:39:19 +11003405 *secid = task_sid(p);
David Quigleyf9008e42006-06-30 01:55:46 -07003406}
3407
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408static int selinux_task_setnice(struct task_struct *p, int nice)
3409{
3410 int rc;
3411
Eric Paris200ac532009-02-12 15:01:04 -05003412 rc = cap_task_setnice(p, nice);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413 if (rc)
3414 return rc;
3415
David Howells3b11a1d2008-11-14 10:39:26 +11003416 return current_has_perm(p, PROCESS__SETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417}
3418
James Morris03e68062006-06-23 02:03:58 -07003419static int selinux_task_setioprio(struct task_struct *p, int ioprio)
3420{
Serge E. Hallynb5376772007-10-16 23:31:36 -07003421 int rc;
3422
Eric Paris200ac532009-02-12 15:01:04 -05003423 rc = cap_task_setioprio(p, ioprio);
Serge E. Hallynb5376772007-10-16 23:31:36 -07003424 if (rc)
3425 return rc;
3426
David Howells3b11a1d2008-11-14 10:39:26 +11003427 return current_has_perm(p, PROCESS__SETSCHED);
James Morris03e68062006-06-23 02:03:58 -07003428}
3429
David Quigleya1836a42006-06-30 01:55:49 -07003430static int selinux_task_getioprio(struct task_struct *p)
3431{
David Howells3b11a1d2008-11-14 10:39:26 +11003432 return current_has_perm(p, PROCESS__GETSCHED);
David Quigleya1836a42006-06-30 01:55:49 -07003433}
3434
Jiri Slaby8fd00b42009-08-26 18:41:16 +02003435static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource,
3436 struct rlimit *new_rlim)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437{
Jiri Slaby8fd00b42009-08-26 18:41:16 +02003438 struct rlimit *old_rlim = p->signal->rlim + resource;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003439
3440 /* Control the ability to change the hard limit (whether
3441 lowering or raising it), so that the hard limit can
3442 later be used as a safe reset point for the soft limit
David Howellsd84f4f92008-11-14 10:39:23 +11003443 upon context transitions. See selinux_bprm_committing_creds. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 if (old_rlim->rlim_max != new_rlim->rlim_max)
Jiri Slaby8fd00b42009-08-26 18:41:16 +02003445 return current_has_perm(p, PROCESS__SETRLIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446
3447 return 0;
3448}
3449
KOSAKI Motohirob0ae1982010-10-15 04:21:18 +09003450static int selinux_task_setscheduler(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451{
Serge E. Hallynb5376772007-10-16 23:31:36 -07003452 int rc;
3453
KOSAKI Motohirob0ae1982010-10-15 04:21:18 +09003454 rc = cap_task_setscheduler(p);
Serge E. Hallynb5376772007-10-16 23:31:36 -07003455 if (rc)
3456 return rc;
3457
David Howells3b11a1d2008-11-14 10:39:26 +11003458 return current_has_perm(p, PROCESS__SETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459}
3460
3461static int selinux_task_getscheduler(struct task_struct *p)
3462{
David Howells3b11a1d2008-11-14 10:39:26 +11003463 return current_has_perm(p, PROCESS__GETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464}
3465
David Quigley35601542006-06-23 02:04:01 -07003466static int selinux_task_movememory(struct task_struct *p)
3467{
David Howells3b11a1d2008-11-14 10:39:26 +11003468 return current_has_perm(p, PROCESS__SETSCHED);
David Quigley35601542006-06-23 02:04:01 -07003469}
3470
David Quigleyf9008e42006-06-30 01:55:46 -07003471static int selinux_task_kill(struct task_struct *p, struct siginfo *info,
3472 int sig, u32 secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473{
3474 u32 perm;
3475 int rc;
3476
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 if (!sig)
3478 perm = PROCESS__SIGNULL; /* null signal; existence test */
3479 else
3480 perm = signal_to_av(sig);
David Quigleyf9008e42006-06-30 01:55:46 -07003481 if (secid)
David Howells275bb412008-11-14 10:39:19 +11003482 rc = avc_has_perm(secid, task_sid(p),
3483 SECCLASS_PROCESS, perm, NULL);
David Quigleyf9008e42006-06-30 01:55:46 -07003484 else
David Howells3b11a1d2008-11-14 10:39:26 +11003485 rc = current_has_perm(p, perm);
David Quigleyf9008e42006-06-30 01:55:46 -07003486 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487}
3488
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489static int selinux_task_wait(struct task_struct *p)
3490{
Eric Paris8a535142007-10-22 16:10:31 -04003491 return task_has_perm(p, current, PROCESS__SIGCHLD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492}
3493
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494static void selinux_task_to_inode(struct task_struct *p,
3495 struct inode *inode)
3496{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497 struct inode_security_struct *isec = inode->i_security;
David Howells275bb412008-11-14 10:39:19 +11003498 u32 sid = task_sid(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499
David Howells275bb412008-11-14 10:39:19 +11003500 isec->sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501 isec->initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502}
3503
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504/* Returns error only if unable to parse addresses */
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003505static int selinux_parse_skb_ipv4(struct sk_buff *skb,
Thomas Liu2bf49692009-07-14 12:14:09 -04003506 struct common_audit_data *ad, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507{
3508 int offset, ihlen, ret = -EINVAL;
3509 struct iphdr _iph, *ih;
3510
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03003511 offset = skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
3513 if (ih == NULL)
3514 goto out;
3515
3516 ihlen = ih->ihl * 4;
3517 if (ihlen < sizeof(_iph))
3518 goto out;
3519
Eric Paris48c62af2012-04-02 13:15:44 -04003520 ad->u.net->v4info.saddr = ih->saddr;
3521 ad->u.net->v4info.daddr = ih->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 ret = 0;
3523
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003524 if (proto)
3525 *proto = ih->protocol;
3526
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 switch (ih->protocol) {
Eric Paris828dfe12008-04-17 13:17:49 -04003528 case IPPROTO_TCP: {
3529 struct tcphdr _tcph, *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530
Eric Paris828dfe12008-04-17 13:17:49 -04003531 if (ntohs(ih->frag_off) & IP_OFFSET)
3532 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003533
3534 offset += ihlen;
3535 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3536 if (th == NULL)
3537 break;
3538
Eric Paris48c62af2012-04-02 13:15:44 -04003539 ad->u.net->sport = th->source;
3540 ad->u.net->dport = th->dest;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003541 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003542 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003543
Eric Paris828dfe12008-04-17 13:17:49 -04003544 case IPPROTO_UDP: {
3545 struct udphdr _udph, *uh;
3546
3547 if (ntohs(ih->frag_off) & IP_OFFSET)
3548 break;
3549
3550 offset += ihlen;
3551 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3552 if (uh == NULL)
3553 break;
3554
Eric Paris48c62af2012-04-02 13:15:44 -04003555 ad->u.net->sport = uh->source;
3556 ad->u.net->dport = uh->dest;
Eric Paris828dfe12008-04-17 13:17:49 -04003557 break;
3558 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559
James Morris2ee92d42006-11-13 16:09:01 -08003560 case IPPROTO_DCCP: {
3561 struct dccp_hdr _dccph, *dh;
3562
3563 if (ntohs(ih->frag_off) & IP_OFFSET)
3564 break;
3565
3566 offset += ihlen;
3567 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3568 if (dh == NULL)
3569 break;
3570
Eric Paris48c62af2012-04-02 13:15:44 -04003571 ad->u.net->sport = dh->dccph_sport;
3572 ad->u.net->dport = dh->dccph_dport;
James Morris2ee92d42006-11-13 16:09:01 -08003573 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003574 }
James Morris2ee92d42006-11-13 16:09:01 -08003575
Eric Paris828dfe12008-04-17 13:17:49 -04003576 default:
3577 break;
3578 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579out:
3580 return ret;
3581}
3582
3583#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3584
3585/* Returns error only if unable to parse addresses */
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003586static int selinux_parse_skb_ipv6(struct sk_buff *skb,
Thomas Liu2bf49692009-07-14 12:14:09 -04003587 struct common_audit_data *ad, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588{
3589 u8 nexthdr;
3590 int ret = -EINVAL, offset;
3591 struct ipv6hdr _ipv6h, *ip6;
Jesse Gross75f28112011-11-30 17:05:51 -08003592 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03003594 offset = skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595 ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3596 if (ip6 == NULL)
3597 goto out;
3598
Eric Paris48c62af2012-04-02 13:15:44 -04003599 ad->u.net->v6info.saddr = ip6->saddr;
3600 ad->u.net->v6info.daddr = ip6->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 ret = 0;
3602
3603 nexthdr = ip6->nexthdr;
3604 offset += sizeof(_ipv6h);
Jesse Gross75f28112011-11-30 17:05:51 -08003605 offset = ipv6_skip_exthdr(skb, offset, &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606 if (offset < 0)
3607 goto out;
3608
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003609 if (proto)
3610 *proto = nexthdr;
3611
Linus Torvalds1da177e2005-04-16 15:20:36 -07003612 switch (nexthdr) {
3613 case IPPROTO_TCP: {
Eric Paris828dfe12008-04-17 13:17:49 -04003614 struct tcphdr _tcph, *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615
3616 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3617 if (th == NULL)
3618 break;
3619
Eric Paris48c62af2012-04-02 13:15:44 -04003620 ad->u.net->sport = th->source;
3621 ad->u.net->dport = th->dest;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003622 break;
3623 }
3624
3625 case IPPROTO_UDP: {
3626 struct udphdr _udph, *uh;
3627
3628 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3629 if (uh == NULL)
3630 break;
3631
Eric Paris48c62af2012-04-02 13:15:44 -04003632 ad->u.net->sport = uh->source;
3633 ad->u.net->dport = uh->dest;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003634 break;
3635 }
3636
James Morris2ee92d42006-11-13 16:09:01 -08003637 case IPPROTO_DCCP: {
3638 struct dccp_hdr _dccph, *dh;
3639
3640 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3641 if (dh == NULL)
3642 break;
3643
Eric Paris48c62af2012-04-02 13:15:44 -04003644 ad->u.net->sport = dh->dccph_sport;
3645 ad->u.net->dport = dh->dccph_dport;
James Morris2ee92d42006-11-13 16:09:01 -08003646 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003647 }
James Morris2ee92d42006-11-13 16:09:01 -08003648
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649 /* includes fragments */
3650 default:
3651 break;
3652 }
3653out:
3654 return ret;
3655}
3656
3657#endif /* IPV6 */
3658
Thomas Liu2bf49692009-07-14 12:14:09 -04003659static int selinux_parse_skb(struct sk_buff *skb, struct common_audit_data *ad,
David Howellscf9481e2008-07-27 21:31:07 +10003660 char **_addrp, int src, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003661{
David Howellscf9481e2008-07-27 21:31:07 +10003662 char *addrp;
3663 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664
Eric Paris48c62af2012-04-02 13:15:44 -04003665 switch (ad->u.net->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666 case PF_INET:
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003667 ret = selinux_parse_skb_ipv4(skb, ad, proto);
David Howellscf9481e2008-07-27 21:31:07 +10003668 if (ret)
3669 goto parse_error;
Eric Paris48c62af2012-04-02 13:15:44 -04003670 addrp = (char *)(src ? &ad->u.net->v4info.saddr :
3671 &ad->u.net->v4info.daddr);
David Howellscf9481e2008-07-27 21:31:07 +10003672 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673
3674#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3675 case PF_INET6:
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003676 ret = selinux_parse_skb_ipv6(skb, ad, proto);
David Howellscf9481e2008-07-27 21:31:07 +10003677 if (ret)
3678 goto parse_error;
Eric Paris48c62af2012-04-02 13:15:44 -04003679 addrp = (char *)(src ? &ad->u.net->v6info.saddr :
3680 &ad->u.net->v6info.daddr);
David Howellscf9481e2008-07-27 21:31:07 +10003681 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003682#endif /* IPV6 */
3683 default:
David Howellscf9481e2008-07-27 21:31:07 +10003684 addrp = NULL;
3685 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 }
3687
David Howellscf9481e2008-07-27 21:31:07 +10003688parse_error:
3689 printk(KERN_WARNING
3690 "SELinux: failure in selinux_parse_skb(),"
3691 " unable to parse packet\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003692 return ret;
David Howellscf9481e2008-07-27 21:31:07 +10003693
3694okay:
3695 if (_addrp)
3696 *_addrp = addrp;
3697 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003698}
3699
Paul Moore4f6a9932007-03-01 14:35:22 -05003700/**
Paul Moore220deb92008-01-29 08:38:23 -05003701 * selinux_skb_peerlbl_sid - Determine the peer label of a packet
Paul Moore4f6a9932007-03-01 14:35:22 -05003702 * @skb: the packet
Paul Moore75e22912008-01-29 08:38:04 -05003703 * @family: protocol family
Paul Moore220deb92008-01-29 08:38:23 -05003704 * @sid: the packet's peer label SID
Paul Moore4f6a9932007-03-01 14:35:22 -05003705 *
3706 * Description:
Paul Moore220deb92008-01-29 08:38:23 -05003707 * Check the various different forms of network peer labeling and determine
3708 * the peer label/SID for the packet; most of the magic actually occurs in
3709 * the security server function security_net_peersid_cmp(). The function
3710 * returns zero if the value in @sid is valid (although it may be SECSID_NULL)
3711 * or -EACCES if @sid is invalid due to inconsistencies with the different
3712 * peer labels.
Paul Moore4f6a9932007-03-01 14:35:22 -05003713 *
3714 */
Paul Moore220deb92008-01-29 08:38:23 -05003715static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid)
Paul Moore4f6a9932007-03-01 14:35:22 -05003716{
Paul Moore71f1cb02008-01-29 08:51:16 -05003717 int err;
Paul Moore4f6a9932007-03-01 14:35:22 -05003718 u32 xfrm_sid;
3719 u32 nlbl_sid;
Paul Moore220deb92008-01-29 08:38:23 -05003720 u32 nlbl_type;
Paul Moore4f6a9932007-03-01 14:35:22 -05003721
3722 selinux_skb_xfrm_sid(skb, &xfrm_sid);
Paul Moore5dbe1eb2008-01-29 08:44:18 -05003723 selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
Paul Moore220deb92008-01-29 08:38:23 -05003724
Paul Moore71f1cb02008-01-29 08:51:16 -05003725 err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid);
3726 if (unlikely(err)) {
3727 printk(KERN_WARNING
3728 "SELinux: failure in selinux_skb_peerlbl_sid(),"
3729 " unable to determine packet's peer label\n");
Paul Moore220deb92008-01-29 08:38:23 -05003730 return -EACCES;
Paul Moore71f1cb02008-01-29 08:51:16 -05003731 }
Paul Moore220deb92008-01-29 08:38:23 -05003732
3733 return 0;
Paul Moore4f6a9932007-03-01 14:35:22 -05003734}
3735
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736/* socket security operations */
Paul Moored4f2d972010-04-22 14:46:18 -04003737
Harry Ciao2ad18bd2011-03-02 13:32:34 +08003738static int socket_sockcreate_sid(const struct task_security_struct *tsec,
3739 u16 secclass, u32 *socksid)
Paul Moored4f2d972010-04-22 14:46:18 -04003740{
Harry Ciao2ad18bd2011-03-02 13:32:34 +08003741 if (tsec->sockcreate_sid > SECSID_NULL) {
3742 *socksid = tsec->sockcreate_sid;
3743 return 0;
3744 }
3745
3746 return security_transition_sid(tsec->sid, tsec->sid, secclass, NULL,
3747 socksid);
Paul Moored4f2d972010-04-22 14:46:18 -04003748}
3749
Paul Moore253bfae2010-04-22 14:46:19 -04003750static int sock_has_perm(struct task_struct *task, struct sock *sk, u32 perms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751{
Paul Moore253bfae2010-04-22 14:46:19 -04003752 struct sk_security_struct *sksec = sk->sk_security;
Thomas Liu2bf49692009-07-14 12:14:09 -04003753 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07003754 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04003755 struct lsm_network_audit net = {0,};
Paul Moore253bfae2010-04-22 14:46:19 -04003756 u32 tsid = task_sid(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003757
Paul Moore253bfae2010-04-22 14:46:19 -04003758 if (sksec->sid == SECINITSID_KERNEL)
3759 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003760
Thomas Liu2bf49692009-07-14 12:14:09 -04003761 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07003762 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04003763 ad.u.net = &net;
3764 ad.u.net->sk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003765
Paul Moore253bfae2010-04-22 14:46:19 -04003766 return avc_has_perm(tsid, sksec->sid, sksec->sclass, perms, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003767}
3768
3769static int selinux_socket_create(int family, int type,
3770 int protocol, int kern)
3771{
Paul Moore5fb49872010-04-22 14:46:19 -04003772 const struct task_security_struct *tsec = current_security();
Paul Moored4f2d972010-04-22 14:46:18 -04003773 u32 newsid;
David Howells275bb412008-11-14 10:39:19 +11003774 u16 secclass;
Harry Ciao2ad18bd2011-03-02 13:32:34 +08003775 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776
3777 if (kern)
Paul Moored4f2d972010-04-22 14:46:18 -04003778 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003779
David Howells275bb412008-11-14 10:39:19 +11003780 secclass = socket_type_to_security_class(family, type, protocol);
Harry Ciao2ad18bd2011-03-02 13:32:34 +08003781 rc = socket_sockcreate_sid(tsec, secclass, &newsid);
3782 if (rc)
3783 return rc;
3784
Paul Moored4f2d972010-04-22 14:46:18 -04003785 return avc_has_perm(tsec->sid, newsid, secclass, SOCKET__CREATE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003786}
3787
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07003788static int selinux_socket_post_create(struct socket *sock, int family,
3789 int type, int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003790{
Paul Moore5fb49872010-04-22 14:46:19 -04003791 const struct task_security_struct *tsec = current_security();
Paul Moored4f2d972010-04-22 14:46:18 -04003792 struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003793 struct sk_security_struct *sksec;
David Howells275bb412008-11-14 10:39:19 +11003794 int err = 0;
3795
Harry Ciao2ad18bd2011-03-02 13:32:34 +08003796 isec->sclass = socket_type_to_security_class(family, type, protocol);
3797
David Howells275bb412008-11-14 10:39:19 +11003798 if (kern)
3799 isec->sid = SECINITSID_KERNEL;
Harry Ciao2ad18bd2011-03-02 13:32:34 +08003800 else {
3801 err = socket_sockcreate_sid(tsec, isec->sclass, &(isec->sid));
3802 if (err)
3803 return err;
3804 }
David Howells275bb412008-11-14 10:39:19 +11003805
Linus Torvalds1da177e2005-04-16 15:20:36 -07003806 isec->initialized = 1;
3807
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003808 if (sock->sk) {
3809 sksec = sock->sk->sk_security;
3810 sksec->sid = isec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05003811 sksec->sclass = isec->sclass;
Paul Moore389fb802009-03-27 17:10:34 -04003812 err = selinux_netlbl_socket_post_create(sock->sk, family);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003813 }
3814
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07003815 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816}
3817
3818/* Range of port numbers used to automatically bind.
3819 Need to determine whether we should perform a name_bind
3820 permission check between the socket and the port number. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003821
3822static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
3823{
Paul Moore253bfae2010-04-22 14:46:19 -04003824 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003825 u16 family;
3826 int err;
3827
Paul Moore253bfae2010-04-22 14:46:19 -04003828 err = sock_has_perm(current, sk, SOCKET__BIND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003829 if (err)
3830 goto out;
3831
3832 /*
3833 * If PF_INET or PF_INET6, check name_bind permission for the port.
James Morris13402582005-09-30 14:24:34 -04003834 * Multiple address binding for SCTP is not supported yet: we just
3835 * check the first address now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003836 */
Paul Moore253bfae2010-04-22 14:46:19 -04003837 family = sk->sk_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 if (family == PF_INET || family == PF_INET6) {
3839 char *addrp;
Paul Moore253bfae2010-04-22 14:46:19 -04003840 struct sk_security_struct *sksec = sk->sk_security;
Thomas Liu2bf49692009-07-14 12:14:09 -04003841 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07003842 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04003843 struct lsm_network_audit net = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844 struct sockaddr_in *addr4 = NULL;
3845 struct sockaddr_in6 *addr6 = NULL;
3846 unsigned short snum;
James Morrise399f982008-06-12 01:39:58 +10003847 u32 sid, node_perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 if (family == PF_INET) {
3850 addr4 = (struct sockaddr_in *)address;
3851 snum = ntohs(addr4->sin_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003852 addrp = (char *)&addr4->sin_addr.s_addr;
3853 } else {
3854 addr6 = (struct sockaddr_in6 *)address;
3855 snum = ntohs(addr6->sin6_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856 addrp = (char *)&addr6->sin6_addr.s6_addr;
3857 }
3858
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003859 if (snum) {
3860 int low, high;
3861
3862 inet_get_local_port_range(&low, &high);
3863
3864 if (snum < max(PROT_SOCK, low) || snum > high) {
Paul Moore3e112172008-04-10 10:48:14 -04003865 err = sel_netport_sid(sk->sk_protocol,
3866 snum, &sid);
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003867 if (err)
3868 goto out;
Thomas Liu2bf49692009-07-14 12:14:09 -04003869 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07003870 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04003871 ad.u.net = &net;
3872 ad.u.net->sport = htons(snum);
3873 ad.u.net->family = family;
Paul Moore253bfae2010-04-22 14:46:19 -04003874 err = avc_has_perm(sksec->sid, sid,
3875 sksec->sclass,
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003876 SOCKET__NAME_BIND, &ad);
3877 if (err)
3878 goto out;
3879 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003880 }
Eric Paris828dfe12008-04-17 13:17:49 -04003881
Paul Moore253bfae2010-04-22 14:46:19 -04003882 switch (sksec->sclass) {
James Morris13402582005-09-30 14:24:34 -04003883 case SECCLASS_TCP_SOCKET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003884 node_perm = TCP_SOCKET__NODE_BIND;
3885 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003886
James Morris13402582005-09-30 14:24:34 -04003887 case SECCLASS_UDP_SOCKET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003888 node_perm = UDP_SOCKET__NODE_BIND;
3889 break;
James Morris2ee92d42006-11-13 16:09:01 -08003890
3891 case SECCLASS_DCCP_SOCKET:
3892 node_perm = DCCP_SOCKET__NODE_BIND;
3893 break;
3894
Linus Torvalds1da177e2005-04-16 15:20:36 -07003895 default:
3896 node_perm = RAWIP_SOCKET__NODE_BIND;
3897 break;
3898 }
Eric Paris828dfe12008-04-17 13:17:49 -04003899
Paul Moore224dfbd2008-01-29 08:38:13 -05003900 err = sel_netnode_sid(addrp, family, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003901 if (err)
3902 goto out;
Eric Paris828dfe12008-04-17 13:17:49 -04003903
Thomas Liu2bf49692009-07-14 12:14:09 -04003904 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07003905 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04003906 ad.u.net = &net;
3907 ad.u.net->sport = htons(snum);
3908 ad.u.net->family = family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003909
3910 if (family == PF_INET)
Eric Paris48c62af2012-04-02 13:15:44 -04003911 ad.u.net->v4info.saddr = addr4->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003912 else
Eric Paris48c62af2012-04-02 13:15:44 -04003913 ad.u.net->v6info.saddr = addr6->sin6_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003914
Paul Moore253bfae2010-04-22 14:46:19 -04003915 err = avc_has_perm(sksec->sid, sid,
3916 sksec->sclass, node_perm, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917 if (err)
3918 goto out;
3919 }
3920out:
3921 return err;
3922}
3923
3924static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
3925{
Paul Moore014ab192008-10-10 10:16:33 -04003926 struct sock *sk = sock->sk;
Paul Moore253bfae2010-04-22 14:46:19 -04003927 struct sk_security_struct *sksec = sk->sk_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003928 int err;
3929
Paul Moore253bfae2010-04-22 14:46:19 -04003930 err = sock_has_perm(current, sk, SOCKET__CONNECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003931 if (err)
3932 return err;
3933
3934 /*
James Morris2ee92d42006-11-13 16:09:01 -08003935 * If a TCP or DCCP socket, check name_connect permission for the port.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003936 */
Paul Moore253bfae2010-04-22 14:46:19 -04003937 if (sksec->sclass == SECCLASS_TCP_SOCKET ||
3938 sksec->sclass == SECCLASS_DCCP_SOCKET) {
Thomas Liu2bf49692009-07-14 12:14:09 -04003939 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07003940 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04003941 struct lsm_network_audit net = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003942 struct sockaddr_in *addr4 = NULL;
3943 struct sockaddr_in6 *addr6 = NULL;
3944 unsigned short snum;
James Morris2ee92d42006-11-13 16:09:01 -08003945 u32 sid, perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003946
3947 if (sk->sk_family == PF_INET) {
3948 addr4 = (struct sockaddr_in *)address;
Stephen Smalley911656f2005-07-28 21:16:21 -07003949 if (addrlen < sizeof(struct sockaddr_in))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003950 return -EINVAL;
3951 snum = ntohs(addr4->sin_port);
3952 } else {
3953 addr6 = (struct sockaddr_in6 *)address;
Stephen Smalley911656f2005-07-28 21:16:21 -07003954 if (addrlen < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003955 return -EINVAL;
3956 snum = ntohs(addr6->sin6_port);
3957 }
3958
Paul Moore3e112172008-04-10 10:48:14 -04003959 err = sel_netport_sid(sk->sk_protocol, snum, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003960 if (err)
3961 goto out;
3962
Paul Moore253bfae2010-04-22 14:46:19 -04003963 perm = (sksec->sclass == SECCLASS_TCP_SOCKET) ?
James Morris2ee92d42006-11-13 16:09:01 -08003964 TCP_SOCKET__NAME_CONNECT : DCCP_SOCKET__NAME_CONNECT;
3965
Thomas Liu2bf49692009-07-14 12:14:09 -04003966 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07003967 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04003968 ad.u.net = &net;
3969 ad.u.net->dport = htons(snum);
3970 ad.u.net->family = sk->sk_family;
Paul Moore253bfae2010-04-22 14:46:19 -04003971 err = avc_has_perm(sksec->sid, sid, sksec->sclass, perm, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 if (err)
3973 goto out;
3974 }
3975
Paul Moore014ab192008-10-10 10:16:33 -04003976 err = selinux_netlbl_socket_connect(sk, address);
3977
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978out:
3979 return err;
3980}
3981
3982static int selinux_socket_listen(struct socket *sock, int backlog)
3983{
Paul Moore253bfae2010-04-22 14:46:19 -04003984 return sock_has_perm(current, sock->sk, SOCKET__LISTEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985}
3986
3987static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
3988{
3989 int err;
3990 struct inode_security_struct *isec;
3991 struct inode_security_struct *newisec;
3992
Paul Moore253bfae2010-04-22 14:46:19 -04003993 err = sock_has_perm(current, sock->sk, SOCKET__ACCEPT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003994 if (err)
3995 return err;
3996
3997 newisec = SOCK_INODE(newsock)->i_security;
3998
3999 isec = SOCK_INODE(sock)->i_security;
4000 newisec->sclass = isec->sclass;
4001 newisec->sid = isec->sid;
4002 newisec->initialized = 1;
4003
4004 return 0;
4005}
4006
4007static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
Eric Paris828dfe12008-04-17 13:17:49 -04004008 int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009{
Paul Moore253bfae2010-04-22 14:46:19 -04004010 return sock_has_perm(current, sock->sk, SOCKET__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004011}
4012
4013static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
4014 int size, int flags)
4015{
Paul Moore253bfae2010-04-22 14:46:19 -04004016 return sock_has_perm(current, sock->sk, SOCKET__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004017}
4018
4019static int selinux_socket_getsockname(struct socket *sock)
4020{
Paul Moore253bfae2010-04-22 14:46:19 -04004021 return sock_has_perm(current, sock->sk, SOCKET__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004022}
4023
4024static int selinux_socket_getpeername(struct socket *sock)
4025{
Paul Moore253bfae2010-04-22 14:46:19 -04004026 return sock_has_perm(current, sock->sk, SOCKET__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004027}
4028
Eric Paris828dfe12008-04-17 13:17:49 -04004029static int selinux_socket_setsockopt(struct socket *sock, int level, int optname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030{
Paul Mooref8687af2006-10-30 15:22:15 -08004031 int err;
4032
Paul Moore253bfae2010-04-22 14:46:19 -04004033 err = sock_has_perm(current, sock->sk, SOCKET__SETOPT);
Paul Mooref8687af2006-10-30 15:22:15 -08004034 if (err)
4035 return err;
4036
4037 return selinux_netlbl_socket_setsockopt(sock, level, optname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038}
4039
4040static int selinux_socket_getsockopt(struct socket *sock, int level,
4041 int optname)
4042{
Paul Moore253bfae2010-04-22 14:46:19 -04004043 return sock_has_perm(current, sock->sk, SOCKET__GETOPT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004044}
4045
4046static int selinux_socket_shutdown(struct socket *sock, int how)
4047{
Paul Moore253bfae2010-04-22 14:46:19 -04004048 return sock_has_perm(current, sock->sk, SOCKET__SHUTDOWN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004049}
4050
David S. Miller3610cda2011-01-05 15:38:53 -08004051static int selinux_socket_unix_stream_connect(struct sock *sock,
4052 struct sock *other,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004053 struct sock *newsk)
4054{
David S. Miller3610cda2011-01-05 15:38:53 -08004055 struct sk_security_struct *sksec_sock = sock->sk_security;
4056 struct sk_security_struct *sksec_other = other->sk_security;
Paul Moore4d1e2452010-04-22 14:46:18 -04004057 struct sk_security_struct *sksec_new = newsk->sk_security;
Thomas Liu2bf49692009-07-14 12:14:09 -04004058 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004059 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004060 struct lsm_network_audit net = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061 int err;
4062
Thomas Liu2bf49692009-07-14 12:14:09 -04004063 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004064 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004065 ad.u.net = &net;
4066 ad.u.net->sk = other;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004067
Paul Moore4d1e2452010-04-22 14:46:18 -04004068 err = avc_has_perm(sksec_sock->sid, sksec_other->sid,
4069 sksec_other->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070 UNIX_STREAM_SOCKET__CONNECTTO, &ad);
4071 if (err)
4072 return err;
4073
Linus Torvalds1da177e2005-04-16 15:20:36 -07004074 /* server child socket */
Paul Moore4d1e2452010-04-22 14:46:18 -04004075 sksec_new->peer_sid = sksec_sock->sid;
4076 err = security_sid_mls_copy(sksec_other->sid, sksec_sock->sid,
4077 &sksec_new->sid);
4078 if (err)
4079 return err;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004080
Paul Moore4d1e2452010-04-22 14:46:18 -04004081 /* connecting socket */
4082 sksec_sock->peer_sid = sksec_new->sid;
4083
4084 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085}
4086
4087static int selinux_socket_unix_may_send(struct socket *sock,
4088 struct socket *other)
4089{
Paul Moore253bfae2010-04-22 14:46:19 -04004090 struct sk_security_struct *ssec = sock->sk->sk_security;
4091 struct sk_security_struct *osec = other->sk->sk_security;
Thomas Liu2bf49692009-07-14 12:14:09 -04004092 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004093 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004094 struct lsm_network_audit net = {0,};
Linus Torvalds1da177e2005-04-16 15:20:36 -07004095
Thomas Liu2bf49692009-07-14 12:14:09 -04004096 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004097 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004098 ad.u.net = &net;
4099 ad.u.net->sk = other->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100
Paul Moore253bfae2010-04-22 14:46:19 -04004101 return avc_has_perm(ssec->sid, osec->sid, osec->sclass, SOCKET__SENDTO,
4102 &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004103}
4104
Paul Mooreeffad8d2008-01-29 08:49:27 -05004105static int selinux_inet_sys_rcv_skb(int ifindex, char *addrp, u16 family,
4106 u32 peer_sid,
Thomas Liu2bf49692009-07-14 12:14:09 -04004107 struct common_audit_data *ad)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004108{
4109 int err;
4110 u32 if_sid;
4111 u32 node_sid;
4112
4113 err = sel_netif_sid(ifindex, &if_sid);
4114 if (err)
4115 return err;
4116 err = avc_has_perm(peer_sid, if_sid,
4117 SECCLASS_NETIF, NETIF__INGRESS, ad);
4118 if (err)
4119 return err;
4120
4121 err = sel_netnode_sid(addrp, family, &node_sid);
4122 if (err)
4123 return err;
4124 return avc_has_perm(peer_sid, node_sid,
4125 SECCLASS_NODE, NODE__RECVFROM, ad);
4126}
4127
Paul Moore220deb92008-01-29 08:38:23 -05004128static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
Paul Moored8395c82008-10-10 10:16:30 -04004129 u16 family)
Paul Moore220deb92008-01-29 08:38:23 -05004130{
Paul Moore277d3422008-12-31 12:54:11 -05004131 int err = 0;
Paul Moore220deb92008-01-29 08:38:23 -05004132 struct sk_security_struct *sksec = sk->sk_security;
Paul Moore220deb92008-01-29 08:38:23 -05004133 u32 sk_sid = sksec->sid;
Thomas Liu2bf49692009-07-14 12:14:09 -04004134 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004135 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004136 struct lsm_network_audit net = {0,};
Paul Moored8395c82008-10-10 10:16:30 -04004137 char *addrp;
4138
Thomas Liu2bf49692009-07-14 12:14:09 -04004139 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004140 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004141 ad.u.net = &net;
4142 ad.u.net->netif = skb->skb_iif;
4143 ad.u.net->family = family;
Paul Moored8395c82008-10-10 10:16:30 -04004144 err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4145 if (err)
4146 return err;
Paul Moore220deb92008-01-29 08:38:23 -05004147
Paul Moore58bfbb52009-03-27 17:10:41 -04004148 if (selinux_secmark_enabled()) {
Paul Moore220deb92008-01-29 08:38:23 -05004149 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
Paul Moored8395c82008-10-10 10:16:30 -04004150 PACKET__RECV, &ad);
Paul Moore58bfbb52009-03-27 17:10:41 -04004151 if (err)
4152 return err;
4153 }
Paul Moore220deb92008-01-29 08:38:23 -05004154
Steffen Klassertb9679a72011-02-23 12:55:21 +01004155 err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad);
4156 if (err)
4157 return err;
4158 err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004159
James Morris4e5ab4c2006-06-09 00:33:33 -07004160 return err;
4161}
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004162
James Morris4e5ab4c2006-06-09 00:33:33 -07004163static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
4164{
Paul Moore220deb92008-01-29 08:38:23 -05004165 int err;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004166 struct sk_security_struct *sksec = sk->sk_security;
Paul Moore220deb92008-01-29 08:38:23 -05004167 u16 family = sk->sk_family;
4168 u32 sk_sid = sksec->sid;
Thomas Liu2bf49692009-07-14 12:14:09 -04004169 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004170 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004171 struct lsm_network_audit net = {0,};
Paul Moore220deb92008-01-29 08:38:23 -05004172 char *addrp;
Paul Moored8395c82008-10-10 10:16:30 -04004173 u8 secmark_active;
4174 u8 peerlbl_active;
James Morris4e5ab4c2006-06-09 00:33:33 -07004175
James Morris4e5ab4c2006-06-09 00:33:33 -07004176 if (family != PF_INET && family != PF_INET6)
Paul Moore220deb92008-01-29 08:38:23 -05004177 return 0;
James Morris4e5ab4c2006-06-09 00:33:33 -07004178
4179 /* Handle mapped IPv4 packets arriving via IPv6 sockets */
Al Viro87fcd702006-12-04 22:00:55 +00004180 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
James Morris4e5ab4c2006-06-09 00:33:33 -07004181 family = PF_INET;
4182
Paul Moored8395c82008-10-10 10:16:30 -04004183 /* If any sort of compatibility mode is enabled then handoff processing
4184 * to the selinux_sock_rcv_skb_compat() function to deal with the
4185 * special handling. We do this in an attempt to keep this function
4186 * as fast and as clean as possible. */
Paul Moore58bfbb52009-03-27 17:10:41 -04004187 if (!selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004188 return selinux_sock_rcv_skb_compat(sk, skb, family);
4189
4190 secmark_active = selinux_secmark_enabled();
4191 peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4192 if (!secmark_active && !peerlbl_active)
4193 return 0;
4194
Thomas Liu2bf49692009-07-14 12:14:09 -04004195 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004196 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004197 ad.u.net = &net;
4198 ad.u.net->netif = skb->skb_iif;
4199 ad.u.net->family = family;
Paul Moore224dfbd2008-01-29 08:38:13 -05004200 err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
James Morris4e5ab4c2006-06-09 00:33:33 -07004201 if (err)
Paul Moore220deb92008-01-29 08:38:23 -05004202 return err;
James Morris4e5ab4c2006-06-09 00:33:33 -07004203
Paul Moored8395c82008-10-10 10:16:30 -04004204 if (peerlbl_active) {
Paul Moored621d352008-01-29 08:43:36 -05004205 u32 peer_sid;
4206
4207 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
4208 if (err)
4209 return err;
Eric Dumazet8964be42009-11-20 15:35:04 -08004210 err = selinux_inet_sys_rcv_skb(skb->skb_iif, addrp, family,
Paul Mooreeffad8d2008-01-29 08:49:27 -05004211 peer_sid, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004212 if (err) {
4213 selinux_netlbl_err(skb, err, 0);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004214 return err;
Paul Mooredfaebe92008-10-10 10:16:31 -04004215 }
Paul Moored621d352008-01-29 08:43:36 -05004216 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
4217 PEER__RECV, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004218 if (err)
4219 selinux_netlbl_err(skb, err, 0);
Paul Moored621d352008-01-29 08:43:36 -05004220 }
4221
Paul Moored8395c82008-10-10 10:16:30 -04004222 if (secmark_active) {
Paul Mooreeffad8d2008-01-29 08:49:27 -05004223 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4224 PACKET__RECV, &ad);
4225 if (err)
4226 return err;
4227 }
4228
Paul Moored621d352008-01-29 08:43:36 -05004229 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004230}
4231
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004232static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *optval,
4233 int __user *optlen, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004234{
4235 int err = 0;
4236 char *scontext;
4237 u32 scontext_len;
Paul Moore253bfae2010-04-22 14:46:19 -04004238 struct sk_security_struct *sksec = sock->sk->sk_security;
Paul Moore3de4bab2006-11-17 17:38:54 -05004239 u32 peer_sid = SECSID_NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004240
Paul Moore253bfae2010-04-22 14:46:19 -04004241 if (sksec->sclass == SECCLASS_UNIX_STREAM_SOCKET ||
4242 sksec->sclass == SECCLASS_TCP_SOCKET)
Eric Parisdd3e7832010-04-07 15:08:46 -04004243 peer_sid = sksec->peer_sid;
Paul Moore253bfae2010-04-22 14:46:19 -04004244 if (peer_sid == SECSID_NULL)
4245 return -ENOPROTOOPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004246
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004247 err = security_sid_to_context(peer_sid, &scontext, &scontext_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004248 if (err)
Paul Moore253bfae2010-04-22 14:46:19 -04004249 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004250
4251 if (scontext_len > len) {
4252 err = -ERANGE;
4253 goto out_len;
4254 }
4255
4256 if (copy_to_user(optval, scontext, scontext_len))
4257 err = -EFAULT;
4258
4259out_len:
4260 if (put_user(scontext_len, optlen))
4261 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004262 kfree(scontext);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004263 return err;
4264}
4265
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004266static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004267{
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004268 u32 peer_secid = SECSID_NULL;
Paul Moore75e22912008-01-29 08:38:04 -05004269 u16 family;
Catherine Zhang877ce7c2006-06-29 12:27:47 -07004270
Paul Mooreaa862902008-10-10 10:16:29 -04004271 if (skb && skb->protocol == htons(ETH_P_IP))
4272 family = PF_INET;
4273 else if (skb && skb->protocol == htons(ETH_P_IPV6))
4274 family = PF_INET6;
4275 else if (sock)
Paul Moore75e22912008-01-29 08:38:04 -05004276 family = sock->sk->sk_family;
Paul Moore75e22912008-01-29 08:38:04 -05004277 else
4278 goto out;
4279
4280 if (sock && family == PF_UNIX)
Ahmed S. Darwish713a04a2008-03-01 21:52:30 +02004281 selinux_inode_getsecid(SOCK_INODE(sock), &peer_secid);
Paul Moore3de4bab2006-11-17 17:38:54 -05004282 else if (skb)
Paul Moore220deb92008-01-29 08:38:23 -05004283 selinux_skb_peerlbl_sid(skb, family, &peer_secid);
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004284
Paul Moore75e22912008-01-29 08:38:04 -05004285out:
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004286 *secid = peer_secid;
Paul Moore75e22912008-01-29 08:38:04 -05004287 if (peer_secid == SECSID_NULL)
4288 return -EINVAL;
4289 return 0;
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004290}
4291
Al Viro7d877f32005-10-21 03:20:43 -04004292static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004293{
Paul Moore84914b72010-04-22 14:46:18 -04004294 struct sk_security_struct *sksec;
4295
4296 sksec = kzalloc(sizeof(*sksec), priority);
4297 if (!sksec)
4298 return -ENOMEM;
4299
4300 sksec->peer_sid = SECINITSID_UNLABELED;
4301 sksec->sid = SECINITSID_UNLABELED;
4302 selinux_netlbl_sk_security_reset(sksec);
4303 sk->sk_security = sksec;
4304
4305 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004306}
4307
4308static void selinux_sk_free_security(struct sock *sk)
4309{
Paul Moore84914b72010-04-22 14:46:18 -04004310 struct sk_security_struct *sksec = sk->sk_security;
4311
4312 sk->sk_security = NULL;
4313 selinux_netlbl_sk_security_free(sksec);
4314 kfree(sksec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004315}
4316
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004317static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
4318{
Eric Parisdd3e7832010-04-07 15:08:46 -04004319 struct sk_security_struct *sksec = sk->sk_security;
4320 struct sk_security_struct *newsksec = newsk->sk_security;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004321
Eric Parisdd3e7832010-04-07 15:08:46 -04004322 newsksec->sid = sksec->sid;
4323 newsksec->peer_sid = sksec->peer_sid;
4324 newsksec->sclass = sksec->sclass;
Paul Moore99f59ed2006-08-29 17:53:48 -07004325
Eric Parisdd3e7832010-04-07 15:08:46 -04004326 selinux_netlbl_sk_security_reset(newsksec);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004327}
4328
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004329static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004330{
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004331 if (!sk)
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004332 *secid = SECINITSID_ANY_SOCKET;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004333 else {
4334 struct sk_security_struct *sksec = sk->sk_security;
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004335
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004336 *secid = sksec->sid;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004337 }
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004338}
4339
Eric Paris828dfe12008-04-17 13:17:49 -04004340static void selinux_sock_graft(struct sock *sk, struct socket *parent)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004341{
4342 struct inode_security_struct *isec = SOCK_INODE(parent)->i_security;
4343 struct sk_security_struct *sksec = sk->sk_security;
4344
David Woodhouse2148ccc2006-09-29 15:50:25 -07004345 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 ||
4346 sk->sk_family == PF_UNIX)
4347 isec->sid = sksec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05004348 sksec->sclass = isec->sclass;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004349}
4350
Adrian Bunk9a673e52006-08-15 00:03:53 -07004351static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4352 struct request_sock *req)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004353{
4354 struct sk_security_struct *sksec = sk->sk_security;
4355 int err;
Paul Mooreaa862902008-10-10 10:16:29 -04004356 u16 family = sk->sk_family;
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07004357 u32 newsid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004358 u32 peersid;
4359
Paul Mooreaa862902008-10-10 10:16:29 -04004360 /* handle mapped IPv4 packets arriving via IPv6 sockets */
4361 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4362 family = PF_INET;
4363
4364 err = selinux_skb_peerlbl_sid(skb, family, &peersid);
Paul Moore220deb92008-01-29 08:38:23 -05004365 if (err)
4366 return err;
Venkat Yekkiralaa51c64f2006-07-27 22:01:34 -07004367 if (peersid == SECSID_NULL) {
4368 req->secid = sksec->sid;
Paul Moore3de4bab2006-11-17 17:38:54 -05004369 req->peer_secid = SECSID_NULL;
Paul Moore389fb802009-03-27 17:10:34 -04004370 } else {
4371 err = security_sid_mls_copy(sksec->sid, peersid, &newsid);
4372 if (err)
4373 return err;
4374 req->secid = newsid;
4375 req->peer_secid = peersid;
Venkat Yekkiralaa51c64f2006-07-27 22:01:34 -07004376 }
4377
Paul Moore389fb802009-03-27 17:10:34 -04004378 return selinux_netlbl_inet_conn_request(req, family);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004379}
4380
Adrian Bunk9a673e52006-08-15 00:03:53 -07004381static void selinux_inet_csk_clone(struct sock *newsk,
4382 const struct request_sock *req)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004383{
4384 struct sk_security_struct *newsksec = newsk->sk_security;
4385
4386 newsksec->sid = req->secid;
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004387 newsksec->peer_sid = req->peer_secid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004388 /* NOTE: Ideally, we should also get the isec->sid for the
4389 new socket in sync, but we don't have the isec available yet.
4390 So we will wait until sock_graft to do it, by which
4391 time it will have been created and available. */
Paul Moore99f59ed2006-08-29 17:53:48 -07004392
Paul Moore9f2ad662006-11-17 17:38:53 -05004393 /* We don't need to take any sort of lock here as we are the only
4394 * thread with access to newsksec */
Paul Moore389fb802009-03-27 17:10:34 -04004395 selinux_netlbl_inet_csk_clone(newsk, req->rsk_ops->family);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004396}
4397
Paul Moore014ab192008-10-10 10:16:33 -04004398static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004399{
Paul Mooreaa862902008-10-10 10:16:29 -04004400 u16 family = sk->sk_family;
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004401 struct sk_security_struct *sksec = sk->sk_security;
4402
Paul Mooreaa862902008-10-10 10:16:29 -04004403 /* handle mapped IPv4 packets arriving via IPv6 sockets */
4404 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4405 family = PF_INET;
4406
4407 selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid);
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004408}
4409
Eric Paris2606fd12010-10-13 16:24:41 -04004410static int selinux_secmark_relabel_packet(u32 sid)
4411{
4412 const struct task_security_struct *__tsec;
4413 u32 tsid;
4414
4415 __tsec = current_security();
4416 tsid = __tsec->sid;
4417
4418 return avc_has_perm(tsid, sid, SECCLASS_PACKET, PACKET__RELABELTO, NULL);
4419}
4420
4421static void selinux_secmark_refcount_inc(void)
4422{
4423 atomic_inc(&selinux_secmark_refcount);
4424}
4425
4426static void selinux_secmark_refcount_dec(void)
4427{
4428 atomic_dec(&selinux_secmark_refcount);
4429}
4430
Adrian Bunk9a673e52006-08-15 00:03:53 -07004431static void selinux_req_classify_flow(const struct request_sock *req,
4432 struct flowi *fl)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004433{
David S. Miller1d28f422011-03-12 00:29:39 -05004434 fl->flowi_secid = req->secid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004435}
4436
Paul Mooreed6d76e2009-08-28 18:12:49 -04004437static int selinux_tun_dev_create(void)
4438{
4439 u32 sid = current_sid();
4440
4441 /* we aren't taking into account the "sockcreate" SID since the socket
4442 * that is being created here is not a socket in the traditional sense,
4443 * instead it is a private sock, accessible only to the kernel, and
4444 * representing a wide range of network traffic spanning multiple
4445 * connections unlike traditional sockets - check the TUN driver to
4446 * get a better understanding of why this socket is special */
4447
4448 return avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__CREATE,
4449 NULL);
4450}
4451
4452static void selinux_tun_dev_post_create(struct sock *sk)
4453{
4454 struct sk_security_struct *sksec = sk->sk_security;
4455
4456 /* we don't currently perform any NetLabel based labeling here and it
4457 * isn't clear that we would want to do so anyway; while we could apply
4458 * labeling without the support of the TUN user the resulting labeled
4459 * traffic from the other end of the connection would almost certainly
4460 * cause confusion to the TUN user that had no idea network labeling
4461 * protocols were being used */
4462
4463 /* see the comments in selinux_tun_dev_create() about why we don't use
4464 * the sockcreate SID here */
4465
4466 sksec->sid = current_sid();
4467 sksec->sclass = SECCLASS_TUN_SOCKET;
4468}
4469
4470static int selinux_tun_dev_attach(struct sock *sk)
4471{
4472 struct sk_security_struct *sksec = sk->sk_security;
4473 u32 sid = current_sid();
4474 int err;
4475
4476 err = avc_has_perm(sid, sksec->sid, SECCLASS_TUN_SOCKET,
4477 TUN_SOCKET__RELABELFROM, NULL);
4478 if (err)
4479 return err;
4480 err = avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET,
4481 TUN_SOCKET__RELABELTO, NULL);
4482 if (err)
4483 return err;
4484
4485 sksec->sid = sid;
4486
4487 return 0;
4488}
4489
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb)
4491{
4492 int err = 0;
4493 u32 perm;
4494 struct nlmsghdr *nlh;
Paul Moore253bfae2010-04-22 14:46:19 -04004495 struct sk_security_struct *sksec = sk->sk_security;
Eric Paris828dfe12008-04-17 13:17:49 -04004496
Linus Torvalds1da177e2005-04-16 15:20:36 -07004497 if (skb->len < NLMSG_SPACE(0)) {
4498 err = -EINVAL;
4499 goto out;
4500 }
Arnaldo Carvalho de Melob529ccf2007-04-25 19:08:35 -07004501 nlh = nlmsg_hdr(skb);
Eric Paris828dfe12008-04-17 13:17:49 -04004502
Paul Moore253bfae2010-04-22 14:46:19 -04004503 err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004504 if (err) {
4505 if (err == -EINVAL) {
David Woodhouse9ad9ad32005-06-22 15:04:33 +01004506 audit_log(current->audit_context, GFP_KERNEL, AUDIT_SELINUX_ERR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004507 "SELinux: unrecognized netlink message"
4508 " type=%hu for sclass=%hu\n",
Paul Moore253bfae2010-04-22 14:46:19 -04004509 nlh->nlmsg_type, sksec->sclass);
Eric Paris39c9aed2008-11-05 09:34:42 -05004510 if (!selinux_enforcing || security_get_allow_unknown())
Linus Torvalds1da177e2005-04-16 15:20:36 -07004511 err = 0;
4512 }
4513
4514 /* Ignore */
4515 if (err == -ENOENT)
4516 err = 0;
4517 goto out;
4518 }
4519
Paul Moore253bfae2010-04-22 14:46:19 -04004520 err = sock_has_perm(current, sk, perm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004521out:
4522 return err;
4523}
4524
4525#ifdef CONFIG_NETFILTER
4526
Paul Mooreeffad8d2008-01-29 08:49:27 -05004527static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
4528 u16 family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529{
Paul Mooredfaebe92008-10-10 10:16:31 -04004530 int err;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004531 char *addrp;
4532 u32 peer_sid;
Thomas Liu2bf49692009-07-14 12:14:09 -04004533 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004534 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004535 struct lsm_network_audit net = {0,};
Paul Mooreeffad8d2008-01-29 08:49:27 -05004536 u8 secmark_active;
Paul Moore948bf852008-10-10 10:16:32 -04004537 u8 netlbl_active;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004538 u8 peerlbl_active;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004539
Paul Mooreeffad8d2008-01-29 08:49:27 -05004540 if (!selinux_policycap_netpeer)
4541 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004542
Paul Mooreeffad8d2008-01-29 08:49:27 -05004543 secmark_active = selinux_secmark_enabled();
Paul Moore948bf852008-10-10 10:16:32 -04004544 netlbl_active = netlbl_enabled();
4545 peerlbl_active = netlbl_active || selinux_xfrm_enabled();
Paul Mooreeffad8d2008-01-29 08:49:27 -05004546 if (!secmark_active && !peerlbl_active)
4547 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004548
Paul Moored8395c82008-10-10 10:16:30 -04004549 if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
4550 return NF_DROP;
4551
Thomas Liu2bf49692009-07-14 12:14:09 -04004552 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004553 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004554 ad.u.net = &net;
4555 ad.u.net->netif = ifindex;
4556 ad.u.net->family = family;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004557 if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0)
4558 return NF_DROP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004559
Paul Mooredfaebe92008-10-10 10:16:31 -04004560 if (peerlbl_active) {
4561 err = selinux_inet_sys_rcv_skb(ifindex, addrp, family,
4562 peer_sid, &ad);
4563 if (err) {
4564 selinux_netlbl_err(skb, err, 1);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004565 return NF_DROP;
Paul Mooredfaebe92008-10-10 10:16:31 -04004566 }
4567 }
Paul Mooreeffad8d2008-01-29 08:49:27 -05004568
4569 if (secmark_active)
4570 if (avc_has_perm(peer_sid, skb->secmark,
4571 SECCLASS_PACKET, PACKET__FORWARD_IN, &ad))
4572 return NF_DROP;
4573
Paul Moore948bf852008-10-10 10:16:32 -04004574 if (netlbl_active)
4575 /* we do this in the FORWARD path and not the POST_ROUTING
4576 * path because we want to make sure we apply the necessary
4577 * labeling before IPsec is applied so we can leverage AH
4578 * protection */
4579 if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0)
4580 return NF_DROP;
4581
Paul Mooreeffad8d2008-01-29 08:49:27 -05004582 return NF_ACCEPT;
4583}
4584
4585static unsigned int selinux_ipv4_forward(unsigned int hooknum,
4586 struct sk_buff *skb,
4587 const struct net_device *in,
4588 const struct net_device *out,
4589 int (*okfn)(struct sk_buff *))
4590{
4591 return selinux_ip_forward(skb, in->ifindex, PF_INET);
4592}
4593
4594#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4595static unsigned int selinux_ipv6_forward(unsigned int hooknum,
4596 struct sk_buff *skb,
4597 const struct net_device *in,
4598 const struct net_device *out,
4599 int (*okfn)(struct sk_buff *))
4600{
4601 return selinux_ip_forward(skb, in->ifindex, PF_INET6);
4602}
4603#endif /* IPV6 */
4604
Paul Moore948bf852008-10-10 10:16:32 -04004605static unsigned int selinux_ip_output(struct sk_buff *skb,
4606 u16 family)
4607{
4608 u32 sid;
4609
4610 if (!netlbl_enabled())
4611 return NF_ACCEPT;
4612
4613 /* we do this in the LOCAL_OUT path and not the POST_ROUTING path
4614 * because we want to make sure we apply the necessary labeling
4615 * before IPsec is applied so we can leverage AH protection */
4616 if (skb->sk) {
4617 struct sk_security_struct *sksec = skb->sk->sk_security;
4618 sid = sksec->sid;
4619 } else
4620 sid = SECINITSID_KERNEL;
4621 if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0)
4622 return NF_DROP;
4623
4624 return NF_ACCEPT;
4625}
4626
4627static unsigned int selinux_ipv4_output(unsigned int hooknum,
4628 struct sk_buff *skb,
4629 const struct net_device *in,
4630 const struct net_device *out,
4631 int (*okfn)(struct sk_buff *))
4632{
4633 return selinux_ip_output(skb, PF_INET);
4634}
4635
Paul Mooreeffad8d2008-01-29 08:49:27 -05004636static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb,
4637 int ifindex,
Paul Moored8395c82008-10-10 10:16:30 -04004638 u16 family)
James Morris4e5ab4c2006-06-09 00:33:33 -07004639{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004640 struct sock *sk = skb->sk;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004641 struct sk_security_struct *sksec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004642 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004643 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004644 struct lsm_network_audit net = {0,};
Paul Moored8395c82008-10-10 10:16:30 -04004645 char *addrp;
4646 u8 proto;
James Morris4e5ab4c2006-06-09 00:33:33 -07004647
Paul Mooreeffad8d2008-01-29 08:49:27 -05004648 if (sk == NULL)
4649 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004650 sksec = sk->sk_security;
James Morris4e5ab4c2006-06-09 00:33:33 -07004651
Thomas Liu2bf49692009-07-14 12:14:09 -04004652 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004653 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004654 ad.u.net = &net;
4655 ad.u.net->netif = ifindex;
4656 ad.u.net->family = family;
Paul Moored8395c82008-10-10 10:16:30 -04004657 if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
4658 return NF_DROP;
4659
Paul Moore58bfbb52009-03-27 17:10:41 -04004660 if (selinux_secmark_enabled())
Paul Mooreeffad8d2008-01-29 08:49:27 -05004661 if (avc_has_perm(sksec->sid, skb->secmark,
Paul Moored8395c82008-10-10 10:16:30 -04004662 SECCLASS_PACKET, PACKET__SEND, &ad))
Eric Paris2fe66ec2010-11-23 06:28:08 +00004663 return NF_DROP_ERR(-ECONNREFUSED);
James Morris4e5ab4c2006-06-09 00:33:33 -07004664
Steffen Klassertb9679a72011-02-23 12:55:21 +01004665 if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto))
4666 return NF_DROP_ERR(-ECONNREFUSED);
James Morris4e5ab4c2006-06-09 00:33:33 -07004667
Paul Mooreeffad8d2008-01-29 08:49:27 -05004668 return NF_ACCEPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004669}
4670
Paul Mooreeffad8d2008-01-29 08:49:27 -05004671static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
4672 u16 family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004674 u32 secmark_perm;
4675 u32 peer_sid;
4676 struct sock *sk;
Thomas Liu2bf49692009-07-14 12:14:09 -04004677 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004678 struct selinux_audit_data sad = {0,};
Eric Paris48c62af2012-04-02 13:15:44 -04004679 struct lsm_network_audit net = {0,};
Paul Mooreeffad8d2008-01-29 08:49:27 -05004680 char *addrp;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004681 u8 secmark_active;
4682 u8 peerlbl_active;
4683
Paul Mooreeffad8d2008-01-29 08:49:27 -05004684 /* If any sort of compatibility mode is enabled then handoff processing
4685 * to the selinux_ip_postroute_compat() function to deal with the
4686 * special handling. We do this in an attempt to keep this function
4687 * as fast and as clean as possible. */
Paul Moore58bfbb52009-03-27 17:10:41 -04004688 if (!selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004689 return selinux_ip_postroute_compat(skb, ifindex, family);
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07004690#ifdef CONFIG_XFRM
Paul Mooreeffad8d2008-01-29 08:49:27 -05004691 /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec
4692 * packet transformation so allow the packet to pass without any checks
4693 * since we'll have another chance to perform access control checks
4694 * when the packet is on it's final way out.
4695 * NOTE: there appear to be some IPv6 multicast cases where skb->dst
4696 * is NULL, in this case go ahead and apply access control. */
Eric Dumazetadf30902009-06-02 05:19:30 +00004697 if (skb_dst(skb) != NULL && skb_dst(skb)->xfrm != NULL)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004698 return NF_ACCEPT;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07004699#endif
Paul Mooreeffad8d2008-01-29 08:49:27 -05004700 secmark_active = selinux_secmark_enabled();
4701 peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4702 if (!secmark_active && !peerlbl_active)
4703 return NF_ACCEPT;
4704
Paul Moored8395c82008-10-10 10:16:30 -04004705 /* if the packet is being forwarded then get the peer label from the
4706 * packet itself; otherwise check to see if it is from a local
4707 * application or the kernel, if from an application get the peer label
4708 * from the sending socket, otherwise use the kernel's sid */
Paul Mooreeffad8d2008-01-29 08:49:27 -05004709 sk = skb->sk;
Paul Moored8395c82008-10-10 10:16:30 -04004710 if (sk == NULL) {
Steffen Klassert4a7ab3d2011-02-23 12:56:23 +01004711 if (skb->skb_iif) {
4712 secmark_perm = PACKET__FORWARD_OUT;
Paul Moored8395c82008-10-10 10:16:30 -04004713 if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
Eric Paris04f6d702010-11-23 06:28:02 +00004714 return NF_DROP;
Steffen Klassert4a7ab3d2011-02-23 12:56:23 +01004715 } else {
4716 secmark_perm = PACKET__SEND;
Paul Moored8395c82008-10-10 10:16:30 -04004717 peer_sid = SECINITSID_KERNEL;
Steffen Klassert4a7ab3d2011-02-23 12:56:23 +01004718 }
Paul Moored8395c82008-10-10 10:16:30 -04004719 } else {
Paul Mooreeffad8d2008-01-29 08:49:27 -05004720 struct sk_security_struct *sksec = sk->sk_security;
4721 peer_sid = sksec->sid;
4722 secmark_perm = PACKET__SEND;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004723 }
4724
Thomas Liu2bf49692009-07-14 12:14:09 -04004725 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004726 ad.selinux_audit_data = &sad;
Eric Paris48c62af2012-04-02 13:15:44 -04004727 ad.u.net = &net;
4728 ad.u.net->netif = ifindex;
4729 ad.u.net->family = family;
Paul Moored8395c82008-10-10 10:16:30 -04004730 if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL))
Eric Paris04f6d702010-11-23 06:28:02 +00004731 return NF_DROP;
Paul Moored8395c82008-10-10 10:16:30 -04004732
Paul Mooreeffad8d2008-01-29 08:49:27 -05004733 if (secmark_active)
4734 if (avc_has_perm(peer_sid, skb->secmark,
4735 SECCLASS_PACKET, secmark_perm, &ad))
Eric Paris1f1aaf82010-11-16 11:52:57 +00004736 return NF_DROP_ERR(-ECONNREFUSED);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004737
4738 if (peerlbl_active) {
4739 u32 if_sid;
4740 u32 node_sid;
4741
4742 if (sel_netif_sid(ifindex, &if_sid))
Eric Paris04f6d702010-11-23 06:28:02 +00004743 return NF_DROP;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004744 if (avc_has_perm(peer_sid, if_sid,
4745 SECCLASS_NETIF, NETIF__EGRESS, &ad))
Eric Paris1f1aaf82010-11-16 11:52:57 +00004746 return NF_DROP_ERR(-ECONNREFUSED);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004747
4748 if (sel_netnode_sid(addrp, family, &node_sid))
Eric Paris04f6d702010-11-23 06:28:02 +00004749 return NF_DROP;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004750 if (avc_has_perm(peer_sid, node_sid,
4751 SECCLASS_NODE, NODE__SENDTO, &ad))
Eric Paris1f1aaf82010-11-16 11:52:57 +00004752 return NF_DROP_ERR(-ECONNREFUSED);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004753 }
4754
4755 return NF_ACCEPT;
4756}
4757
4758static unsigned int selinux_ipv4_postroute(unsigned int hooknum,
4759 struct sk_buff *skb,
4760 const struct net_device *in,
4761 const struct net_device *out,
4762 int (*okfn)(struct sk_buff *))
4763{
4764 return selinux_ip_postroute(skb, out->ifindex, PF_INET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004765}
4766
4767#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004768static unsigned int selinux_ipv6_postroute(unsigned int hooknum,
4769 struct sk_buff *skb,
4770 const struct net_device *in,
4771 const struct net_device *out,
4772 int (*okfn)(struct sk_buff *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004773{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004774 return selinux_ip_postroute(skb, out->ifindex, PF_INET6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004775}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004776#endif /* IPV6 */
4777
4778#endif /* CONFIG_NETFILTER */
4779
Linus Torvalds1da177e2005-04-16 15:20:36 -07004780static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb)
4781{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004782 int err;
4783
Eric Paris200ac532009-02-12 15:01:04 -05004784 err = cap_netlink_send(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004785 if (err)
4786 return err;
4787
Stephen Smalley941fc5b2009-10-01 14:48:23 -04004788 return selinux_nlmsg_perm(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004789}
4790
Linus Torvalds1da177e2005-04-16 15:20:36 -07004791static int ipc_alloc_security(struct task_struct *task,
4792 struct kern_ipc_perm *perm,
4793 u16 sclass)
4794{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004795 struct ipc_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +11004796 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797
James Morris89d155e2005-10-30 14:59:21 -08004798 isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004799 if (!isec)
4800 return -ENOMEM;
4801
David Howells275bb412008-11-14 10:39:19 +11004802 sid = task_sid(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004803 isec->sclass = sclass;
David Howells275bb412008-11-14 10:39:19 +11004804 isec->sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004805 perm->security = isec;
4806
4807 return 0;
4808}
4809
4810static void ipc_free_security(struct kern_ipc_perm *perm)
4811{
4812 struct ipc_security_struct *isec = perm->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004813 perm->security = NULL;
4814 kfree(isec);
4815}
4816
4817static int msg_msg_alloc_security(struct msg_msg *msg)
4818{
4819 struct msg_security_struct *msec;
4820
James Morris89d155e2005-10-30 14:59:21 -08004821 msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004822 if (!msec)
4823 return -ENOMEM;
4824
Linus Torvalds1da177e2005-04-16 15:20:36 -07004825 msec->sid = SECINITSID_UNLABELED;
4826 msg->security = msec;
4827
4828 return 0;
4829}
4830
4831static void msg_msg_free_security(struct msg_msg *msg)
4832{
4833 struct msg_security_struct *msec = msg->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004834
4835 msg->security = NULL;
4836 kfree(msec);
4837}
4838
4839static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
Stephen Smalley6af963f2005-05-01 08:58:39 -07004840 u32 perms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004841{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004842 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004843 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004844 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11004845 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004846
Linus Torvalds1da177e2005-04-16 15:20:36 -07004847 isec = ipc_perms->security;
4848
Thomas Liu2bf49692009-07-14 12:14:09 -04004849 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004850 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004851 ad.u.ipc_id = ipc_perms->key;
4852
David Howells275bb412008-11-14 10:39:19 +11004853 return avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004854}
4855
4856static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
4857{
4858 return msg_msg_alloc_security(msg);
4859}
4860
4861static void selinux_msg_msg_free_security(struct msg_msg *msg)
4862{
4863 msg_msg_free_security(msg);
4864}
4865
4866/* message queue security operations */
4867static int selinux_msg_queue_alloc_security(struct msg_queue *msq)
4868{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004869 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004870 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004871 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11004872 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004873 int rc;
4874
4875 rc = ipc_alloc_security(current, &msq->q_perm, SECCLASS_MSGQ);
4876 if (rc)
4877 return rc;
4878
Linus Torvalds1da177e2005-04-16 15:20:36 -07004879 isec = msq->q_perm.security;
4880
Thomas Liu2bf49692009-07-14 12:14:09 -04004881 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004882 ad.selinux_audit_data = &sad;
Eric Paris828dfe12008-04-17 13:17:49 -04004883 ad.u.ipc_id = msq->q_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004884
David Howells275bb412008-11-14 10:39:19 +11004885 rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004886 MSGQ__CREATE, &ad);
4887 if (rc) {
4888 ipc_free_security(&msq->q_perm);
4889 return rc;
4890 }
4891 return 0;
4892}
4893
4894static void selinux_msg_queue_free_security(struct msg_queue *msq)
4895{
4896 ipc_free_security(&msq->q_perm);
4897}
4898
4899static int selinux_msg_queue_associate(struct msg_queue *msq, int msqflg)
4900{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004901 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004902 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004903 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11004904 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004905
Linus Torvalds1da177e2005-04-16 15:20:36 -07004906 isec = msq->q_perm.security;
4907
Thomas Liu2bf49692009-07-14 12:14:09 -04004908 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004909 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004910 ad.u.ipc_id = msq->q_perm.key;
4911
David Howells275bb412008-11-14 10:39:19 +11004912 return avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004913 MSGQ__ASSOCIATE, &ad);
4914}
4915
4916static int selinux_msg_queue_msgctl(struct msg_queue *msq, int cmd)
4917{
4918 int err;
4919 int perms;
4920
Eric Paris828dfe12008-04-17 13:17:49 -04004921 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004922 case IPC_INFO:
4923 case MSG_INFO:
4924 /* No specific object, just general system-wide information. */
4925 return task_has_system(current, SYSTEM__IPC_INFO);
4926 case IPC_STAT:
4927 case MSG_STAT:
4928 perms = MSGQ__GETATTR | MSGQ__ASSOCIATE;
4929 break;
4930 case IPC_SET:
4931 perms = MSGQ__SETATTR;
4932 break;
4933 case IPC_RMID:
4934 perms = MSGQ__DESTROY;
4935 break;
4936 default:
4937 return 0;
4938 }
4939
Stephen Smalley6af963f2005-05-01 08:58:39 -07004940 err = ipc_has_perm(&msq->q_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004941 return err;
4942}
4943
4944static int selinux_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, int msqflg)
4945{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004946 struct ipc_security_struct *isec;
4947 struct msg_security_struct *msec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004948 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004949 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11004950 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004951 int rc;
4952
Linus Torvalds1da177e2005-04-16 15:20:36 -07004953 isec = msq->q_perm.security;
4954 msec = msg->security;
4955
4956 /*
4957 * First time through, need to assign label to the message
4958 */
4959 if (msec->sid == SECINITSID_UNLABELED) {
4960 /*
4961 * Compute new sid based on current process and
4962 * message queue this message will be stored in
4963 */
David Howells275bb412008-11-14 10:39:19 +11004964 rc = security_transition_sid(sid, isec->sid, SECCLASS_MSG,
Eric Paris652bb9b2011-02-01 11:05:40 -05004965 NULL, &msec->sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004966 if (rc)
4967 return rc;
4968 }
4969
Thomas Liu2bf49692009-07-14 12:14:09 -04004970 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07004971 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004972 ad.u.ipc_id = msq->q_perm.key;
4973
4974 /* Can this process write to the queue? */
David Howells275bb412008-11-14 10:39:19 +11004975 rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004976 MSGQ__WRITE, &ad);
4977 if (!rc)
4978 /* Can this process send the message */
David Howells275bb412008-11-14 10:39:19 +11004979 rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG,
4980 MSG__SEND, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004981 if (!rc)
4982 /* Can the message be put in the queue? */
David Howells275bb412008-11-14 10:39:19 +11004983 rc = avc_has_perm(msec->sid, isec->sid, SECCLASS_MSGQ,
4984 MSGQ__ENQUEUE, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004985
4986 return rc;
4987}
4988
4989static int selinux_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
4990 struct task_struct *target,
4991 long type, int mode)
4992{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004993 struct ipc_security_struct *isec;
4994 struct msg_security_struct *msec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004995 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07004996 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11004997 u32 sid = task_sid(target);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004998 int rc;
4999
Linus Torvalds1da177e2005-04-16 15:20:36 -07005000 isec = msq->q_perm.security;
5001 msec = msg->security;
5002
Thomas Liu2bf49692009-07-14 12:14:09 -04005003 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07005004 ad.selinux_audit_data = &sad;
Eric Paris828dfe12008-04-17 13:17:49 -04005005 ad.u.ipc_id = msq->q_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005006
David Howells275bb412008-11-14 10:39:19 +11005007 rc = avc_has_perm(sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005008 SECCLASS_MSGQ, MSGQ__READ, &ad);
5009 if (!rc)
David Howells275bb412008-11-14 10:39:19 +11005010 rc = avc_has_perm(sid, msec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005011 SECCLASS_MSG, MSG__RECEIVE, &ad);
5012 return rc;
5013}
5014
5015/* Shared Memory security operations */
5016static int selinux_shm_alloc_security(struct shmid_kernel *shp)
5017{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005018 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04005019 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07005020 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11005021 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005022 int rc;
5023
5024 rc = ipc_alloc_security(current, &shp->shm_perm, SECCLASS_SHM);
5025 if (rc)
5026 return rc;
5027
Linus Torvalds1da177e2005-04-16 15:20:36 -07005028 isec = shp->shm_perm.security;
5029
Thomas Liu2bf49692009-07-14 12:14:09 -04005030 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07005031 ad.selinux_audit_data = &sad;
Eric Paris828dfe12008-04-17 13:17:49 -04005032 ad.u.ipc_id = shp->shm_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005033
David Howells275bb412008-11-14 10:39:19 +11005034 rc = avc_has_perm(sid, isec->sid, SECCLASS_SHM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005035 SHM__CREATE, &ad);
5036 if (rc) {
5037 ipc_free_security(&shp->shm_perm);
5038 return rc;
5039 }
5040 return 0;
5041}
5042
5043static void selinux_shm_free_security(struct shmid_kernel *shp)
5044{
5045 ipc_free_security(&shp->shm_perm);
5046}
5047
5048static int selinux_shm_associate(struct shmid_kernel *shp, int shmflg)
5049{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005050 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04005051 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07005052 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11005053 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005054
Linus Torvalds1da177e2005-04-16 15:20:36 -07005055 isec = shp->shm_perm.security;
5056
Thomas Liu2bf49692009-07-14 12:14:09 -04005057 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07005058 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005059 ad.u.ipc_id = shp->shm_perm.key;
5060
David Howells275bb412008-11-14 10:39:19 +11005061 return avc_has_perm(sid, isec->sid, SECCLASS_SHM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005062 SHM__ASSOCIATE, &ad);
5063}
5064
5065/* Note, at this point, shp is locked down */
5066static int selinux_shm_shmctl(struct shmid_kernel *shp, int cmd)
5067{
5068 int perms;
5069 int err;
5070
Eric Paris828dfe12008-04-17 13:17:49 -04005071 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005072 case IPC_INFO:
5073 case SHM_INFO:
5074 /* No specific object, just general system-wide information. */
5075 return task_has_system(current, SYSTEM__IPC_INFO);
5076 case IPC_STAT:
5077 case SHM_STAT:
5078 perms = SHM__GETATTR | SHM__ASSOCIATE;
5079 break;
5080 case IPC_SET:
5081 perms = SHM__SETATTR;
5082 break;
5083 case SHM_LOCK:
5084 case SHM_UNLOCK:
5085 perms = SHM__LOCK;
5086 break;
5087 case IPC_RMID:
5088 perms = SHM__DESTROY;
5089 break;
5090 default:
5091 return 0;
5092 }
5093
Stephen Smalley6af963f2005-05-01 08:58:39 -07005094 err = ipc_has_perm(&shp->shm_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005095 return err;
5096}
5097
5098static int selinux_shm_shmat(struct shmid_kernel *shp,
5099 char __user *shmaddr, int shmflg)
5100{
5101 u32 perms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005102
5103 if (shmflg & SHM_RDONLY)
5104 perms = SHM__READ;
5105 else
5106 perms = SHM__READ | SHM__WRITE;
5107
Stephen Smalley6af963f2005-05-01 08:58:39 -07005108 return ipc_has_perm(&shp->shm_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005109}
5110
5111/* Semaphore security operations */
5112static int selinux_sem_alloc_security(struct sem_array *sma)
5113{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005114 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04005115 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07005116 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11005117 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005118 int rc;
5119
5120 rc = ipc_alloc_security(current, &sma->sem_perm, SECCLASS_SEM);
5121 if (rc)
5122 return rc;
5123
Linus Torvalds1da177e2005-04-16 15:20:36 -07005124 isec = sma->sem_perm.security;
5125
Thomas Liu2bf49692009-07-14 12:14:09 -04005126 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07005127 ad.selinux_audit_data = &sad;
Eric Paris828dfe12008-04-17 13:17:49 -04005128 ad.u.ipc_id = sma->sem_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005129
David Howells275bb412008-11-14 10:39:19 +11005130 rc = avc_has_perm(sid, isec->sid, SECCLASS_SEM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005131 SEM__CREATE, &ad);
5132 if (rc) {
5133 ipc_free_security(&sma->sem_perm);
5134 return rc;
5135 }
5136 return 0;
5137}
5138
5139static void selinux_sem_free_security(struct sem_array *sma)
5140{
5141 ipc_free_security(&sma->sem_perm);
5142}
5143
5144static int selinux_sem_associate(struct sem_array *sma, int semflg)
5145{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005146 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04005147 struct common_audit_data ad;
Eric Paris3b3b0e42012-04-03 09:37:02 -07005148 struct selinux_audit_data sad = {0,};
David Howells275bb412008-11-14 10:39:19 +11005149 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005150
Linus Torvalds1da177e2005-04-16 15:20:36 -07005151 isec = sma->sem_perm.security;
5152
Thomas Liu2bf49692009-07-14 12:14:09 -04005153 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris3b3b0e42012-04-03 09:37:02 -07005154 ad.selinux_audit_data = &sad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005155 ad.u.ipc_id = sma->sem_perm.key;
5156
David Howells275bb412008-11-14 10:39:19 +11005157 return avc_has_perm(sid, isec->sid, SECCLASS_SEM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005158 SEM__ASSOCIATE, &ad);
5159}
5160
5161/* Note, at this point, sma is locked down */
5162static int selinux_sem_semctl(struct sem_array *sma, int cmd)
5163{
5164 int err;
5165 u32 perms;
5166
Eric Paris828dfe12008-04-17 13:17:49 -04005167 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005168 case IPC_INFO:
5169 case SEM_INFO:
5170 /* No specific object, just general system-wide information. */
5171 return task_has_system(current, SYSTEM__IPC_INFO);
5172 case GETPID:
5173 case GETNCNT:
5174 case GETZCNT:
5175 perms = SEM__GETATTR;
5176 break;
5177 case GETVAL:
5178 case GETALL:
5179 perms = SEM__READ;
5180 break;
5181 case SETVAL:
5182 case SETALL:
5183 perms = SEM__WRITE;
5184 break;
5185 case IPC_RMID:
5186 perms = SEM__DESTROY;
5187 break;
5188 case IPC_SET:
5189 perms = SEM__SETATTR;
5190 break;
5191 case IPC_STAT:
5192 case SEM_STAT:
5193 perms = SEM__GETATTR | SEM__ASSOCIATE;
5194 break;
5195 default:
5196 return 0;
5197 }
5198
Stephen Smalley6af963f2005-05-01 08:58:39 -07005199 err = ipc_has_perm(&sma->sem_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005200 return err;
5201}
5202
5203static int selinux_sem_semop(struct sem_array *sma,
5204 struct sembuf *sops, unsigned nsops, int alter)
5205{
5206 u32 perms;
5207
5208 if (alter)
5209 perms = SEM__READ | SEM__WRITE;
5210 else
5211 perms = SEM__READ;
5212
Stephen Smalley6af963f2005-05-01 08:58:39 -07005213 return ipc_has_perm(&sma->sem_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005214}
5215
5216static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
5217{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005218 u32 av = 0;
5219
Linus Torvalds1da177e2005-04-16 15:20:36 -07005220 av = 0;
5221 if (flag & S_IRUGO)
5222 av |= IPC__UNIX_READ;
5223 if (flag & S_IWUGO)
5224 av |= IPC__UNIX_WRITE;
5225
5226 if (av == 0)
5227 return 0;
5228
Stephen Smalley6af963f2005-05-01 08:58:39 -07005229 return ipc_has_perm(ipcp, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005230}
5231
Ahmed S. Darwish713a04a2008-03-01 21:52:30 +02005232static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
5233{
5234 struct ipc_security_struct *isec = ipcp->security;
5235 *secid = isec->sid;
5236}
5237
Eric Paris828dfe12008-04-17 13:17:49 -04005238static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005239{
5240 if (inode)
5241 inode_doinit_with_dentry(inode, dentry);
5242}
5243
5244static int selinux_getprocattr(struct task_struct *p,
Al Viro04ff9702007-03-12 16:17:58 +00005245 char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005246{
David Howells275bb412008-11-14 10:39:19 +11005247 const struct task_security_struct *__tsec;
Dustin Kirkland8c8570f2005-11-03 17:15:16 +00005248 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005249 int error;
Al Viro04ff9702007-03-12 16:17:58 +00005250 unsigned len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005251
5252 if (current != p) {
David Howells3b11a1d2008-11-14 10:39:26 +11005253 error = current_has_perm(p, PROCESS__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005254 if (error)
5255 return error;
5256 }
5257
David Howells275bb412008-11-14 10:39:19 +11005258 rcu_read_lock();
5259 __tsec = __task_cred(p)->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005260
5261 if (!strcmp(name, "current"))
David Howells275bb412008-11-14 10:39:19 +11005262 sid = __tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005263 else if (!strcmp(name, "prev"))
David Howells275bb412008-11-14 10:39:19 +11005264 sid = __tsec->osid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005265 else if (!strcmp(name, "exec"))
David Howells275bb412008-11-14 10:39:19 +11005266 sid = __tsec->exec_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005267 else if (!strcmp(name, "fscreate"))
David Howells275bb412008-11-14 10:39:19 +11005268 sid = __tsec->create_sid;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005269 else if (!strcmp(name, "keycreate"))
David Howells275bb412008-11-14 10:39:19 +11005270 sid = __tsec->keycreate_sid;
Eric Paris42c3e032006-06-26 00:26:03 -07005271 else if (!strcmp(name, "sockcreate"))
David Howells275bb412008-11-14 10:39:19 +11005272 sid = __tsec->sockcreate_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005273 else
David Howells275bb412008-11-14 10:39:19 +11005274 goto invalid;
5275 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005276
5277 if (!sid)
5278 return 0;
5279
Al Viro04ff9702007-03-12 16:17:58 +00005280 error = security_sid_to_context(sid, value, &len);
5281 if (error)
5282 return error;
5283 return len;
David Howells275bb412008-11-14 10:39:19 +11005284
5285invalid:
5286 rcu_read_unlock();
5287 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005288}
5289
5290static int selinux_setprocattr(struct task_struct *p,
5291 char *name, void *value, size_t size)
5292{
5293 struct task_security_struct *tsec;
Roland McGrath03563572008-03-26 15:46:39 -07005294 struct task_struct *tracer;
David Howellsd84f4f92008-11-14 10:39:23 +11005295 struct cred *new;
5296 u32 sid = 0, ptsid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005297 int error;
5298 char *str = value;
5299
5300 if (current != p) {
5301 /* SELinux only allows a process to change its own
5302 security attributes. */
5303 return -EACCES;
5304 }
5305
5306 /*
5307 * Basic control over ability to set these attributes at all.
5308 * current == p, but we'll pass them separately in case the
5309 * above restriction is ever removed.
5310 */
5311 if (!strcmp(name, "exec"))
David Howells3b11a1d2008-11-14 10:39:26 +11005312 error = current_has_perm(p, PROCESS__SETEXEC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005313 else if (!strcmp(name, "fscreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005314 error = current_has_perm(p, PROCESS__SETFSCREATE);
Michael LeMay4eb582c2006-06-26 00:24:57 -07005315 else if (!strcmp(name, "keycreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005316 error = current_has_perm(p, PROCESS__SETKEYCREATE);
Eric Paris42c3e032006-06-26 00:26:03 -07005317 else if (!strcmp(name, "sockcreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005318 error = current_has_perm(p, PROCESS__SETSOCKCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005319 else if (!strcmp(name, "current"))
David Howells3b11a1d2008-11-14 10:39:26 +11005320 error = current_has_perm(p, PROCESS__SETCURRENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005321 else
5322 error = -EINVAL;
5323 if (error)
5324 return error;
5325
5326 /* Obtain a SID for the context, if one was specified. */
5327 if (size && str[1] && str[1] != '\n') {
5328 if (str[size-1] == '\n') {
5329 str[size-1] = 0;
5330 size--;
5331 }
5332 error = security_context_to_sid(value, size, &sid);
Stephen Smalley12b29f32008-05-07 13:03:20 -04005333 if (error == -EINVAL && !strcmp(name, "fscreate")) {
5334 if (!capable(CAP_MAC_ADMIN))
5335 return error;
5336 error = security_context_to_sid_force(value, size,
5337 &sid);
5338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005339 if (error)
5340 return error;
5341 }
5342
David Howellsd84f4f92008-11-14 10:39:23 +11005343 new = prepare_creds();
5344 if (!new)
5345 return -ENOMEM;
5346
Linus Torvalds1da177e2005-04-16 15:20:36 -07005347 /* Permission checking based on the specified context is
5348 performed during the actual operation (execve,
5349 open/mkdir/...), when we know the full context of the
David Howellsd84f4f92008-11-14 10:39:23 +11005350 operation. See selinux_bprm_set_creds for the execve
Linus Torvalds1da177e2005-04-16 15:20:36 -07005351 checks and may_create for the file creation checks. The
5352 operation will then fail if the context is not permitted. */
David Howellsd84f4f92008-11-14 10:39:23 +11005353 tsec = new->security;
5354 if (!strcmp(name, "exec")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005355 tsec->exec_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005356 } else if (!strcmp(name, "fscreate")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005357 tsec->create_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005358 } else if (!strcmp(name, "keycreate")) {
Michael LeMay4eb582c2006-06-26 00:24:57 -07005359 error = may_create_key(sid, p);
5360 if (error)
David Howellsd84f4f92008-11-14 10:39:23 +11005361 goto abort_change;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005362 tsec->keycreate_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005363 } else if (!strcmp(name, "sockcreate")) {
Eric Paris42c3e032006-06-26 00:26:03 -07005364 tsec->sockcreate_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005365 } else if (!strcmp(name, "current")) {
5366 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005367 if (sid == 0)
David Howellsd84f4f92008-11-14 10:39:23 +11005368 goto abort_change;
KaiGai Koheid9250de2008-08-28 16:35:57 +09005369
David Howellsd84f4f92008-11-14 10:39:23 +11005370 /* Only allow single threaded processes to change context */
5371 error = -EPERM;
Oleg Nesterov5bb459b2009-07-10 03:48:23 +02005372 if (!current_is_single_threaded()) {
David Howellsd84f4f92008-11-14 10:39:23 +11005373 error = security_bounded_transition(tsec->sid, sid);
5374 if (error)
5375 goto abort_change;
Eric Paris828dfe12008-04-17 13:17:49 -04005376 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005377
5378 /* Check permissions for the transition. */
5379 error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
Eric Paris828dfe12008-04-17 13:17:49 -04005380 PROCESS__DYNTRANSITION, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005381 if (error)
David Howellsd84f4f92008-11-14 10:39:23 +11005382 goto abort_change;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005383
5384 /* Check for ptracing, and update the task SID if ok.
5385 Otherwise, leave SID unchanged and fail. */
David Howellsd84f4f92008-11-14 10:39:23 +11005386 ptsid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005387 task_lock(p);
Tejun Heo06d98472011-06-17 16:50:40 +02005388 tracer = ptrace_parent(p);
David Howellsd84f4f92008-11-14 10:39:23 +11005389 if (tracer)
5390 ptsid = task_sid(tracer);
5391 task_unlock(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005392
David Howellsd84f4f92008-11-14 10:39:23 +11005393 if (tracer) {
5394 error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS,
5395 PROCESS__PTRACE, NULL);
5396 if (error)
5397 goto abort_change;
5398 }
5399
5400 tsec->sid = sid;
5401 } else {
5402 error = -EINVAL;
5403 goto abort_change;
5404 }
5405
5406 commit_creds(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005407 return size;
David Howellsd84f4f92008-11-14 10:39:23 +11005408
5409abort_change:
5410 abort_creds(new);
5411 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005412}
5413
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005414static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
5415{
5416 return security_sid_to_context(secid, secdata, seclen);
5417}
5418
David Howells7bf570d2008-04-29 20:52:51 +01005419static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
David Howells63cb3442008-01-15 23:47:35 +00005420{
5421 return security_context_to_sid(secdata, seclen, secid);
5422}
5423
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005424static void selinux_release_secctx(char *secdata, u32 seclen)
5425{
Paul Moore088999e2007-08-01 11:12:58 -04005426 kfree(secdata);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005427}
5428
David P. Quigley1ee65e32009-09-03 14:25:57 -04005429/*
5430 * called with inode->i_mutex locked
5431 */
5432static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
5433{
5434 return selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, ctxlen, 0);
5435}
5436
5437/*
5438 * called with inode->i_mutex locked
5439 */
5440static int selinux_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
5441{
5442 return __vfs_setxattr_noperm(dentry, XATTR_NAME_SELINUX, ctx, ctxlen, 0);
5443}
5444
5445static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
5446{
5447 int len = 0;
5448 len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX,
5449 ctx, true);
5450 if (len < 0)
5451 return len;
5452 *ctxlen = len;
5453 return 0;
5454}
Michael LeMayd7200242006-06-22 14:47:17 -07005455#ifdef CONFIG_KEYS
5456
David Howellsd84f4f92008-11-14 10:39:23 +11005457static int selinux_key_alloc(struct key *k, const struct cred *cred,
David Howells7e047ef2006-06-26 00:24:50 -07005458 unsigned long flags)
Michael LeMayd7200242006-06-22 14:47:17 -07005459{
David Howellsd84f4f92008-11-14 10:39:23 +11005460 const struct task_security_struct *tsec;
Michael LeMayd7200242006-06-22 14:47:17 -07005461 struct key_security_struct *ksec;
5462
5463 ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
5464 if (!ksec)
5465 return -ENOMEM;
5466
David Howellsd84f4f92008-11-14 10:39:23 +11005467 tsec = cred->security;
5468 if (tsec->keycreate_sid)
5469 ksec->sid = tsec->keycreate_sid;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005470 else
David Howellsd84f4f92008-11-14 10:39:23 +11005471 ksec->sid = tsec->sid;
Michael LeMayd7200242006-06-22 14:47:17 -07005472
David Howells275bb412008-11-14 10:39:19 +11005473 k->security = ksec;
Michael LeMayd7200242006-06-22 14:47:17 -07005474 return 0;
5475}
5476
5477static void selinux_key_free(struct key *k)
5478{
5479 struct key_security_struct *ksec = k->security;
5480
5481 k->security = NULL;
5482 kfree(ksec);
5483}
5484
5485static int selinux_key_permission(key_ref_t key_ref,
David Howellsd84f4f92008-11-14 10:39:23 +11005486 const struct cred *cred,
5487 key_perm_t perm)
Michael LeMayd7200242006-06-22 14:47:17 -07005488{
5489 struct key *key;
Michael LeMayd7200242006-06-22 14:47:17 -07005490 struct key_security_struct *ksec;
David Howells275bb412008-11-14 10:39:19 +11005491 u32 sid;
Michael LeMayd7200242006-06-22 14:47:17 -07005492
5493 /* if no specific permissions are requested, we skip the
5494 permission check. No serious, additional covert channels
5495 appear to be created. */
5496 if (perm == 0)
5497 return 0;
5498
David Howellsd84f4f92008-11-14 10:39:23 +11005499 sid = cred_sid(cred);
David Howells275bb412008-11-14 10:39:19 +11005500
5501 key = key_ref_to_ptr(key_ref);
5502 ksec = key->security;
5503
5504 return avc_has_perm(sid, ksec->sid, SECCLASS_KEY, perm, NULL);
Michael LeMayd7200242006-06-22 14:47:17 -07005505}
5506
David Howells70a5bb72008-04-29 01:01:26 -07005507static int selinux_key_getsecurity(struct key *key, char **_buffer)
5508{
5509 struct key_security_struct *ksec = key->security;
5510 char *context = NULL;
5511 unsigned len;
5512 int rc;
5513
5514 rc = security_sid_to_context(ksec->sid, &context, &len);
5515 if (!rc)
5516 rc = len;
5517 *_buffer = context;
5518 return rc;
5519}
5520
Michael LeMayd7200242006-06-22 14:47:17 -07005521#endif
5522
Linus Torvalds1da177e2005-04-16 15:20:36 -07005523static struct security_operations selinux_ops = {
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02005524 .name = "selinux",
5525
Ingo Molnar9e488582009-05-07 19:26:19 +10005526 .ptrace_access_check = selinux_ptrace_access_check,
David Howells5cd9c582008-08-14 11:37:28 +01005527 .ptrace_traceme = selinux_ptrace_traceme,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005528 .capget = selinux_capget,
David Howellsd84f4f92008-11-14 10:39:23 +11005529 .capset = selinux_capset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005530 .capable = selinux_capable,
5531 .quotactl = selinux_quotactl,
5532 .quota_on = selinux_quota_on,
5533 .syslog = selinux_syslog,
5534 .vm_enough_memory = selinux_vm_enough_memory,
5535
5536 .netlink_send = selinux_netlink_send,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005537
David Howellsa6f76f22008-11-14 10:39:24 +11005538 .bprm_set_creds = selinux_bprm_set_creds,
David Howellsa6f76f22008-11-14 10:39:24 +11005539 .bprm_committing_creds = selinux_bprm_committing_creds,
5540 .bprm_committed_creds = selinux_bprm_committed_creds,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005541 .bprm_secureexec = selinux_bprm_secureexec,
5542
5543 .sb_alloc_security = selinux_sb_alloc_security,
5544 .sb_free_security = selinux_sb_free_security,
5545 .sb_copy_data = selinux_sb_copy_data,
Eric Paris026eb162011-03-03 16:09:14 -05005546 .sb_remount = selinux_sb_remount,
Eric Paris828dfe12008-04-17 13:17:49 -04005547 .sb_kern_mount = selinux_sb_kern_mount,
Eric Paris2069f452008-07-04 09:47:13 +10005548 .sb_show_options = selinux_sb_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005549 .sb_statfs = selinux_sb_statfs,
5550 .sb_mount = selinux_mount,
5551 .sb_umount = selinux_umount,
Eric Parisc9180a52007-11-30 13:00:35 -05005552 .sb_set_mnt_opts = selinux_set_mnt_opts,
Eric Paris828dfe12008-04-17 13:17:49 -04005553 .sb_clone_mnt_opts = selinux_sb_clone_mnt_opts,
Eric Parise0007522008-03-05 10:31:54 -05005554 .sb_parse_opts_str = selinux_parse_opts_str,
5555
Linus Torvalds1da177e2005-04-16 15:20:36 -07005556
5557 .inode_alloc_security = selinux_inode_alloc_security,
5558 .inode_free_security = selinux_inode_free_security,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07005559 .inode_init_security = selinux_inode_init_security,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005560 .inode_create = selinux_inode_create,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005561 .inode_link = selinux_inode_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005562 .inode_unlink = selinux_inode_unlink,
5563 .inode_symlink = selinux_inode_symlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005564 .inode_mkdir = selinux_inode_mkdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005565 .inode_rmdir = selinux_inode_rmdir,
5566 .inode_mknod = selinux_inode_mknod,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005567 .inode_rename = selinux_inode_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005568 .inode_readlink = selinux_inode_readlink,
5569 .inode_follow_link = selinux_inode_follow_link,
5570 .inode_permission = selinux_inode_permission,
5571 .inode_setattr = selinux_inode_setattr,
5572 .inode_getattr = selinux_inode_getattr,
5573 .inode_setxattr = selinux_inode_setxattr,
5574 .inode_post_setxattr = selinux_inode_post_setxattr,
5575 .inode_getxattr = selinux_inode_getxattr,
5576 .inode_listxattr = selinux_inode_listxattr,
5577 .inode_removexattr = selinux_inode_removexattr,
Eric Paris828dfe12008-04-17 13:17:49 -04005578 .inode_getsecurity = selinux_inode_getsecurity,
5579 .inode_setsecurity = selinux_inode_setsecurity,
5580 .inode_listsecurity = selinux_inode_listsecurity,
Eric Parisf5269712008-05-14 11:27:45 -04005581 .inode_getsecid = selinux_inode_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005582
5583 .file_permission = selinux_file_permission,
5584 .file_alloc_security = selinux_file_alloc_security,
5585 .file_free_security = selinux_file_free_security,
5586 .file_ioctl = selinux_file_ioctl,
5587 .file_mmap = selinux_file_mmap,
5588 .file_mprotect = selinux_file_mprotect,
5589 .file_lock = selinux_file_lock,
5590 .file_fcntl = selinux_file_fcntl,
5591 .file_set_fowner = selinux_file_set_fowner,
5592 .file_send_sigiotask = selinux_file_send_sigiotask,
5593 .file_receive = selinux_file_receive,
5594
Eric Paris828dfe12008-04-17 13:17:49 -04005595 .dentry_open = selinux_dentry_open,
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09005596
Linus Torvalds1da177e2005-04-16 15:20:36 -07005597 .task_create = selinux_task_create,
David Howellsee18d642009-09-02 09:14:21 +01005598 .cred_alloc_blank = selinux_cred_alloc_blank,
David Howellsf1752ee2008-11-14 10:39:17 +11005599 .cred_free = selinux_cred_free,
David Howellsd84f4f92008-11-14 10:39:23 +11005600 .cred_prepare = selinux_cred_prepare,
David Howellsee18d642009-09-02 09:14:21 +01005601 .cred_transfer = selinux_cred_transfer,
David Howells3a3b7ce2008-11-14 10:39:28 +11005602 .kernel_act_as = selinux_kernel_act_as,
5603 .kernel_create_files_as = selinux_kernel_create_files_as,
Eric Paris25354c42009-08-13 09:45:03 -04005604 .kernel_module_request = selinux_kernel_module_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005605 .task_setpgid = selinux_task_setpgid,
5606 .task_getpgid = selinux_task_getpgid,
Eric Paris828dfe12008-04-17 13:17:49 -04005607 .task_getsid = selinux_task_getsid,
David Quigleyf9008e42006-06-30 01:55:46 -07005608 .task_getsecid = selinux_task_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005609 .task_setnice = selinux_task_setnice,
James Morris03e68062006-06-23 02:03:58 -07005610 .task_setioprio = selinux_task_setioprio,
David Quigleya1836a42006-06-30 01:55:49 -07005611 .task_getioprio = selinux_task_getioprio,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005612 .task_setrlimit = selinux_task_setrlimit,
5613 .task_setscheduler = selinux_task_setscheduler,
5614 .task_getscheduler = selinux_task_getscheduler,
David Quigley35601542006-06-23 02:04:01 -07005615 .task_movememory = selinux_task_movememory,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005616 .task_kill = selinux_task_kill,
5617 .task_wait = selinux_task_wait,
Eric Paris828dfe12008-04-17 13:17:49 -04005618 .task_to_inode = selinux_task_to_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005619
5620 .ipc_permission = selinux_ipc_permission,
Eric Parisf5269712008-05-14 11:27:45 -04005621 .ipc_getsecid = selinux_ipc_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005622
5623 .msg_msg_alloc_security = selinux_msg_msg_alloc_security,
5624 .msg_msg_free_security = selinux_msg_msg_free_security,
5625
5626 .msg_queue_alloc_security = selinux_msg_queue_alloc_security,
5627 .msg_queue_free_security = selinux_msg_queue_free_security,
5628 .msg_queue_associate = selinux_msg_queue_associate,
5629 .msg_queue_msgctl = selinux_msg_queue_msgctl,
5630 .msg_queue_msgsnd = selinux_msg_queue_msgsnd,
5631 .msg_queue_msgrcv = selinux_msg_queue_msgrcv,
5632
5633 .shm_alloc_security = selinux_shm_alloc_security,
5634 .shm_free_security = selinux_shm_free_security,
5635 .shm_associate = selinux_shm_associate,
5636 .shm_shmctl = selinux_shm_shmctl,
5637 .shm_shmat = selinux_shm_shmat,
5638
Eric Paris828dfe12008-04-17 13:17:49 -04005639 .sem_alloc_security = selinux_sem_alloc_security,
5640 .sem_free_security = selinux_sem_free_security,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005641 .sem_associate = selinux_sem_associate,
5642 .sem_semctl = selinux_sem_semctl,
5643 .sem_semop = selinux_sem_semop,
5644
Eric Paris828dfe12008-04-17 13:17:49 -04005645 .d_instantiate = selinux_d_instantiate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005646
Eric Paris828dfe12008-04-17 13:17:49 -04005647 .getprocattr = selinux_getprocattr,
5648 .setprocattr = selinux_setprocattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005649
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005650 .secid_to_secctx = selinux_secid_to_secctx,
David Howells63cb3442008-01-15 23:47:35 +00005651 .secctx_to_secid = selinux_secctx_to_secid,
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005652 .release_secctx = selinux_release_secctx,
David P. Quigley1ee65e32009-09-03 14:25:57 -04005653 .inode_notifysecctx = selinux_inode_notifysecctx,
5654 .inode_setsecctx = selinux_inode_setsecctx,
5655 .inode_getsecctx = selinux_inode_getsecctx,
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005656
Eric Paris828dfe12008-04-17 13:17:49 -04005657 .unix_stream_connect = selinux_socket_unix_stream_connect,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005658 .unix_may_send = selinux_socket_unix_may_send,
5659
5660 .socket_create = selinux_socket_create,
5661 .socket_post_create = selinux_socket_post_create,
5662 .socket_bind = selinux_socket_bind,
5663 .socket_connect = selinux_socket_connect,
5664 .socket_listen = selinux_socket_listen,
5665 .socket_accept = selinux_socket_accept,
5666 .socket_sendmsg = selinux_socket_sendmsg,
5667 .socket_recvmsg = selinux_socket_recvmsg,
5668 .socket_getsockname = selinux_socket_getsockname,
5669 .socket_getpeername = selinux_socket_getpeername,
5670 .socket_getsockopt = selinux_socket_getsockopt,
5671 .socket_setsockopt = selinux_socket_setsockopt,
5672 .socket_shutdown = selinux_socket_shutdown,
5673 .socket_sock_rcv_skb = selinux_socket_sock_rcv_skb,
Catherine Zhang2c7946a2006-03-20 22:41:23 -08005674 .socket_getpeersec_stream = selinux_socket_getpeersec_stream,
5675 .socket_getpeersec_dgram = selinux_socket_getpeersec_dgram,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005676 .sk_alloc_security = selinux_sk_alloc_security,
5677 .sk_free_security = selinux_sk_free_security,
Venkat Yekkirala892c1412006-08-04 23:08:56 -07005678 .sk_clone_security = selinux_sk_clone_security,
Eric Paris828dfe12008-04-17 13:17:49 -04005679 .sk_getsecid = selinux_sk_getsecid,
Venkat Yekkirala4237c752006-07-24 23:32:50 -07005680 .sock_graft = selinux_sock_graft,
5681 .inet_conn_request = selinux_inet_conn_request,
5682 .inet_csk_clone = selinux_inet_csk_clone,
Venkat Yekkirala6b877692006-11-08 17:04:09 -06005683 .inet_conn_established = selinux_inet_conn_established,
Eric Paris2606fd12010-10-13 16:24:41 -04005684 .secmark_relabel_packet = selinux_secmark_relabel_packet,
5685 .secmark_refcount_inc = selinux_secmark_refcount_inc,
5686 .secmark_refcount_dec = selinux_secmark_refcount_dec,
Venkat Yekkirala4237c752006-07-24 23:32:50 -07005687 .req_classify_flow = selinux_req_classify_flow,
Paul Mooreed6d76e2009-08-28 18:12:49 -04005688 .tun_dev_create = selinux_tun_dev_create,
5689 .tun_dev_post_create = selinux_tun_dev_post_create,
5690 .tun_dev_attach = selinux_tun_dev_attach,
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005691
5692#ifdef CONFIG_SECURITY_NETWORK_XFRM
5693 .xfrm_policy_alloc_security = selinux_xfrm_policy_alloc,
5694 .xfrm_policy_clone_security = selinux_xfrm_policy_clone,
5695 .xfrm_policy_free_security = selinux_xfrm_policy_free,
Catherine Zhangc8c05a82006-06-08 23:39:49 -07005696 .xfrm_policy_delete_security = selinux_xfrm_policy_delete,
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005697 .xfrm_state_alloc_security = selinux_xfrm_state_alloc,
5698 .xfrm_state_free_security = selinux_xfrm_state_free,
Catherine Zhangc8c05a82006-06-08 23:39:49 -07005699 .xfrm_state_delete_security = selinux_xfrm_state_delete,
Eric Paris828dfe12008-04-17 13:17:49 -04005700 .xfrm_policy_lookup = selinux_xfrm_policy_lookup,
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07005701 .xfrm_state_pol_flow_match = selinux_xfrm_state_pol_flow_match,
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07005702 .xfrm_decode_session = selinux_xfrm_decode_session,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005703#endif
Michael LeMayd7200242006-06-22 14:47:17 -07005704
5705#ifdef CONFIG_KEYS
Eric Paris828dfe12008-04-17 13:17:49 -04005706 .key_alloc = selinux_key_alloc,
5707 .key_free = selinux_key_free,
5708 .key_permission = selinux_key_permission,
David Howells70a5bb72008-04-29 01:01:26 -07005709 .key_getsecurity = selinux_key_getsecurity,
Michael LeMayd7200242006-06-22 14:47:17 -07005710#endif
Ahmed S. Darwish9d57a7f2008-03-01 22:03:14 +02005711
5712#ifdef CONFIG_AUDIT
5713 .audit_rule_init = selinux_audit_rule_init,
5714 .audit_rule_known = selinux_audit_rule_known,
5715 .audit_rule_match = selinux_audit_rule_match,
5716 .audit_rule_free = selinux_audit_rule_free,
5717#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07005718};
5719
5720static __init int selinux_init(void)
5721{
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02005722 if (!security_module_enable(&selinux_ops)) {
5723 selinux_enabled = 0;
5724 return 0;
5725 }
5726
Linus Torvalds1da177e2005-04-16 15:20:36 -07005727 if (!selinux_enabled) {
5728 printk(KERN_INFO "SELinux: Disabled at boot.\n");
5729 return 0;
5730 }
5731
5732 printk(KERN_INFO "SELinux: Initializing.\n");
5733
5734 /* Set the security state for the initial task. */
David Howellsd84f4f92008-11-14 10:39:23 +11005735 cred_init_security();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005736
Stephen Smalleyfcaaade2010-04-28 15:57:57 -04005737 default_noexec = !(VM_DATA_DEFAULT_FLAGS & VM_EXEC);
5738
James Morris7cae7e22006-03-22 00:09:22 -08005739 sel_inode_cache = kmem_cache_create("selinux_inode_security",
5740 sizeof(struct inode_security_struct),
Paul Mundt20c2df82007-07-20 10:11:58 +09005741 0, SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005742 avc_init();
5743
Eric Paris828dfe12008-04-17 13:17:49 -04005744 if (register_security(&selinux_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005745 panic("SELinux: Unable to register with kernel.\n");
5746
Eric Paris828dfe12008-04-17 13:17:49 -04005747 if (selinux_enforcing)
Eric Parisfadcdb42007-02-22 18:11:31 -05005748 printk(KERN_DEBUG "SELinux: Starting in enforcing mode\n");
Eric Paris828dfe12008-04-17 13:17:49 -04005749 else
Eric Parisfadcdb42007-02-22 18:11:31 -05005750 printk(KERN_DEBUG "SELinux: Starting in permissive mode\n");
Michael LeMayd7200242006-06-22 14:47:17 -07005751
Linus Torvalds1da177e2005-04-16 15:20:36 -07005752 return 0;
5753}
5754
Al Viroe8c26252010-03-23 06:36:54 -04005755static void delayed_superblock_init(struct super_block *sb, void *unused)
5756{
5757 superblock_doinit(sb, NULL);
5758}
5759
Linus Torvalds1da177e2005-04-16 15:20:36 -07005760void selinux_complete_init(void)
5761{
Eric Parisfadcdb42007-02-22 18:11:31 -05005762 printk(KERN_DEBUG "SELinux: Completing initialization.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005763
5764 /* Set up any superblocks initialized prior to the policy load. */
Eric Parisfadcdb42007-02-22 18:11:31 -05005765 printk(KERN_DEBUG "SELinux: Setting up existing superblocks.\n");
Al Viroe8c26252010-03-23 06:36:54 -04005766 iterate_supers(delayed_superblock_init, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005767}
5768
5769/* SELinux requires early initialization in order to label
5770 all processes and objects when they are created. */
5771security_initcall(selinux_init);
5772
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005773#if defined(CONFIG_NETFILTER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005774
Paul Mooreeffad8d2008-01-29 08:49:27 -05005775static struct nf_hook_ops selinux_ipv4_ops[] = {
5776 {
5777 .hook = selinux_ipv4_postroute,
5778 .owner = THIS_MODULE,
5779 .pf = PF_INET,
5780 .hooknum = NF_INET_POST_ROUTING,
5781 .priority = NF_IP_PRI_SELINUX_LAST,
5782 },
5783 {
5784 .hook = selinux_ipv4_forward,
5785 .owner = THIS_MODULE,
5786 .pf = PF_INET,
5787 .hooknum = NF_INET_FORWARD,
5788 .priority = NF_IP_PRI_SELINUX_FIRST,
Paul Moore948bf852008-10-10 10:16:32 -04005789 },
5790 {
5791 .hook = selinux_ipv4_output,
5792 .owner = THIS_MODULE,
5793 .pf = PF_INET,
5794 .hooknum = NF_INET_LOCAL_OUT,
5795 .priority = NF_IP_PRI_SELINUX_FIRST,
Paul Mooreeffad8d2008-01-29 08:49:27 -05005796 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005797};
5798
5799#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5800
Paul Mooreeffad8d2008-01-29 08:49:27 -05005801static struct nf_hook_ops selinux_ipv6_ops[] = {
5802 {
5803 .hook = selinux_ipv6_postroute,
5804 .owner = THIS_MODULE,
5805 .pf = PF_INET6,
5806 .hooknum = NF_INET_POST_ROUTING,
5807 .priority = NF_IP6_PRI_SELINUX_LAST,
5808 },
5809 {
5810 .hook = selinux_ipv6_forward,
5811 .owner = THIS_MODULE,
5812 .pf = PF_INET6,
5813 .hooknum = NF_INET_FORWARD,
5814 .priority = NF_IP6_PRI_SELINUX_FIRST,
5815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005816};
5817
5818#endif /* IPV6 */
5819
5820static int __init selinux_nf_ip_init(void)
5821{
5822 int err = 0;
5823
5824 if (!selinux_enabled)
5825 goto out;
Eric Parisfadcdb42007-02-22 18:11:31 -05005826
5827 printk(KERN_DEBUG "SELinux: Registering netfilter hooks\n");
5828
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005829 err = nf_register_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5830 if (err)
5831 panic("SELinux: nf_register_hooks for IPv4: error %d\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005832
5833#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005834 err = nf_register_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5835 if (err)
5836 panic("SELinux: nf_register_hooks for IPv6: error %d\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005837#endif /* IPV6 */
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005838
Linus Torvalds1da177e2005-04-16 15:20:36 -07005839out:
5840 return err;
5841}
5842
5843__initcall(selinux_nf_ip_init);
5844
5845#ifdef CONFIG_SECURITY_SELINUX_DISABLE
5846static void selinux_nf_ip_exit(void)
5847{
Eric Parisfadcdb42007-02-22 18:11:31 -05005848 printk(KERN_DEBUG "SELinux: Unregistering netfilter hooks\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005849
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005850 nf_unregister_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005851#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005852 nf_unregister_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005853#endif /* IPV6 */
5854}
5855#endif
5856
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005857#else /* CONFIG_NETFILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005858
5859#ifdef CONFIG_SECURITY_SELINUX_DISABLE
5860#define selinux_nf_ip_exit()
5861#endif
5862
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005863#endif /* CONFIG_NETFILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005864
5865#ifdef CONFIG_SECURITY_SELINUX_DISABLE
Eric Paris828dfe12008-04-17 13:17:49 -04005866static int selinux_disabled;
5867
Linus Torvalds1da177e2005-04-16 15:20:36 -07005868int selinux_disable(void)
5869{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005870 if (ss_initialized) {
5871 /* Not permitted after initial policy load. */
5872 return -EINVAL;
5873 }
5874
5875 if (selinux_disabled) {
5876 /* Only do this once. */
5877 return -EINVAL;
5878 }
5879
5880 printk(KERN_INFO "SELinux: Disabled at runtime.\n");
5881
5882 selinux_disabled = 1;
Stephen Smalley30d55282006-05-03 10:52:36 -04005883 selinux_enabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005884
wzt.wzt@gmail.com189b3b12010-02-23 23:15:28 +08005885 reset_security_ops();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005886
Eric Parisaf8ff042009-09-20 21:23:01 -04005887 /* Try to destroy the avc node cache */
5888 avc_disable();
5889
Linus Torvalds1da177e2005-04-16 15:20:36 -07005890 /* Unregister netfilter hooks. */
5891 selinux_nf_ip_exit();
5892
5893 /* Unregister selinuxfs. */
5894 exit_sel_fs();
5895
5896 return 0;
5897}
5898#endif