blob: 5feecb41009d58420d5c702cbde9455d64b112fb [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.
17 * Paul Moore <paul.moore@hp.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>
27#include <linux/kernel.h>
Roland McGrath0d094ef2008-07-25 19:45:49 -070028#include <linux/tracehook.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/errno.h>
30#include <linux/sched.h>
31#include <linux/security.h>
32#include <linux/xattr.h>
33#include <linux/capability.h>
34#include <linux/unistd.h>
35#include <linux/mm.h>
36#include <linux/mman.h>
37#include <linux/slab.h>
38#include <linux/pagemap.h>
39#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/spinlock.h>
41#include <linux/syscalls.h>
42#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040043#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/namei.h>
45#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/proc_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/netfilter_ipv4.h>
48#include <linux/netfilter_ipv6.h>
49#include <linux/tty.h>
50#include <net/icmp.h>
Stephen Hemminger227b60f2007-10-10 17:30:46 -070051#include <net/ip.h> /* for local_port_range[] */
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <net/tcp.h> /* struct or_callable used in sock_rcv_skb */
Paul Moore220deb92008-01-29 08:38:23 -050053#include <net/net_namespace.h>
Paul Moored621d352008-01-29 08:43:36 -050054#include <net/netlabel.h>
Eric Parisf5269712008-05-14 11:27:45 -040055#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <asm/ioctls.h>
Paul Moored621d352008-01-29 08:43:36 -050057#include <asm/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <linux/bitops.h>
59#include <linux/interrupt.h>
60#include <linux/netdevice.h> /* for network interface checks */
61#include <linux/netlink.h>
62#include <linux/tcp.h>
63#include <linux/udp.h>
James Morris2ee92d42006-11-13 16:09:01 -080064#include <linux/dccp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#include <linux/quota.h>
66#include <linux/un.h> /* for Unix socket types */
67#include <net/af_unix.h> /* for Unix socket types */
68#include <linux/parser.h>
69#include <linux/nfs_mount.h>
70#include <net/ipv6.h>
71#include <linux/hugetlb.h>
72#include <linux/personality.h>
73#include <linux/sysctl.h>
74#include <linux/audit.h>
Eric Paris6931dfc2005-06-30 02:58:51 -070075#include <linux/string.h>
Catherine Zhang877ce7c2006-06-29 12:27:47 -070076#include <linux/selinux.h>
Eric Paris23970742006-09-25 23:32:01 -070077#include <linux/mutex.h>
Frank Mayharf06febc2008-09-12 09:54:39 -070078#include <linux/posix-timers.h>
Kees Cook00234592010-02-03 15:36:43 -080079#include <linux/syslog.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
81#include "avc.h"
82#include "objsec.h"
83#include "netif.h"
Paul Moore224dfbd2008-01-29 08:38:13 -050084#include "netnode.h"
Paul Moore3e112172008-04-10 10:48:14 -040085#include "netport.h"
Trent Jaegerd28d1e02005-12-13 23:12:40 -080086#include "xfrm.h"
Paul Moorec60475b2007-02-28 15:14:23 -050087#include "netlabel.h"
Ahmed S. Darwish9d57a7f2008-03-01 22:03:14 +020088#include "audit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90#define XATTR_SELINUX_SUFFIX "selinux"
91#define XATTR_NAME_SELINUX XATTR_SECURITY_PREFIX XATTR_SELINUX_SUFFIX
92
David P. Quigley11689d42009-01-16 09:22:03 -050093#define NUM_SEL_MNT_OPTS 5
Eric Parisc9180a52007-11-30 13:00:35 -050094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095extern int selinux_nlmsg_lookup(u16 sclass, u16 nlmsg_type, u32 *perm);
James Morris20510f22007-10-16 23:31:32 -070096extern struct security_operations *security_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Paul Moored621d352008-01-29 08:43:36 -050098/* SECMARK reference count */
99atomic_t selinux_secmark_refcount = ATOMIC_INIT(0);
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#ifdef CONFIG_SECURITY_SELINUX_DEVELOP
Eric Paris828dfe12008-04-17 13:17:49 -0400102int selinux_enforcing;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104static int __init enforcing_setup(char *str)
105{
Eric Parisf5269712008-05-14 11:27:45 -0400106 unsigned long enforcing;
107 if (!strict_strtoul(str, 0, &enforcing))
108 selinux_enforcing = enforcing ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 return 1;
110}
111__setup("enforcing=", enforcing_setup);
112#endif
113
114#ifdef CONFIG_SECURITY_SELINUX_BOOTPARAM
115int selinux_enabled = CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE;
116
117static int __init selinux_enabled_setup(char *str)
118{
Eric Parisf5269712008-05-14 11:27:45 -0400119 unsigned long enabled;
120 if (!strict_strtoul(str, 0, &enabled))
121 selinux_enabled = enabled ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 return 1;
123}
124__setup("selinux=", selinux_enabled_setup);
Stephen Smalley30d55282006-05-03 10:52:36 -0400125#else
126int selinux_enabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127#endif
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129/* Lists of inode and superblock security structures initialized
130 before the policy was loaded. */
131static LIST_HEAD(superblock_security_head);
132static DEFINE_SPINLOCK(sb_security_lock);
133
Christoph Lametere18b8902006-12-06 20:33:20 -0800134static struct kmem_cache *sel_inode_cache;
James Morris7cae7e22006-03-22 00:09:22 -0800135
Paul Moored621d352008-01-29 08:43:36 -0500136/**
137 * selinux_secmark_enabled - Check to see if SECMARK is currently enabled
138 *
139 * Description:
140 * This function checks the SECMARK reference counter to see if any SECMARK
141 * targets are currently configured, if the reference counter is greater than
142 * zero SECMARK is considered to be enabled. Returns true (1) if SECMARK is
143 * enabled, false (0) if SECMARK is disabled.
144 *
145 */
146static int selinux_secmark_enabled(void)
147{
148 return (atomic_read(&selinux_secmark_refcount) > 0);
149}
150
David Howellsd84f4f92008-11-14 10:39:23 +1100151/*
152 * initialise the security for the init task
153 */
154static void cred_init_security(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
David Howells3b11a1d2008-11-14 10:39:26 +1100156 struct cred *cred = (struct cred *) current->real_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 struct task_security_struct *tsec;
158
James Morris89d155e2005-10-30 14:59:21 -0800159 tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 if (!tsec)
David Howellsd84f4f92008-11-14 10:39:23 +1100161 panic("SELinux: Failed to initialize initial task.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
David Howellsd84f4f92008-11-14 10:39:23 +1100163 tsec->osid = tsec->sid = SECINITSID_KERNEL;
David Howellsf1752ee2008-11-14 10:39:17 +1100164 cred->security = tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165}
166
David Howells275bb412008-11-14 10:39:19 +1100167/*
David Howells88e67f32008-11-14 10:39:21 +1100168 * get the security ID of a set of credentials
169 */
170static inline u32 cred_sid(const struct cred *cred)
171{
172 const struct task_security_struct *tsec;
173
174 tsec = cred->security;
175 return tsec->sid;
176}
177
178/*
David Howells3b11a1d2008-11-14 10:39:26 +1100179 * get the objective security ID of a task
David Howells275bb412008-11-14 10:39:19 +1100180 */
181static inline u32 task_sid(const struct task_struct *task)
182{
David Howells275bb412008-11-14 10:39:19 +1100183 u32 sid;
184
185 rcu_read_lock();
David Howells88e67f32008-11-14 10:39:21 +1100186 sid = cred_sid(__task_cred(task));
David Howells275bb412008-11-14 10:39:19 +1100187 rcu_read_unlock();
188 return sid;
189}
190
191/*
David Howells3b11a1d2008-11-14 10:39:26 +1100192 * get the subjective security ID of the current task
David Howells275bb412008-11-14 10:39:19 +1100193 */
194static inline u32 current_sid(void)
195{
196 const struct task_security_struct *tsec = current_cred()->security;
197
198 return tsec->sid;
199}
200
David Howells88e67f32008-11-14 10:39:21 +1100201/* Allocate and free functions for each kind of security blob. */
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203static int inode_alloc_security(struct inode *inode)
204{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 struct inode_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +1100206 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Josef Bacika02fe132008-04-04 09:35:05 +1100208 isec = kmem_cache_zalloc(sel_inode_cache, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 if (!isec)
210 return -ENOMEM;
211
Eric Paris23970742006-09-25 23:32:01 -0700212 mutex_init(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 INIT_LIST_HEAD(&isec->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 isec->inode = inode;
215 isec->sid = SECINITSID_UNLABELED;
216 isec->sclass = SECCLASS_FILE;
David Howells275bb412008-11-14 10:39:19 +1100217 isec->task_sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 inode->i_security = isec;
219
220 return 0;
221}
222
223static void inode_free_security(struct inode *inode)
224{
225 struct inode_security_struct *isec = inode->i_security;
226 struct superblock_security_struct *sbsec = inode->i_sb->s_security;
227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 spin_lock(&sbsec->isec_lock);
229 if (!list_empty(&isec->list))
230 list_del_init(&isec->list);
231 spin_unlock(&sbsec->isec_lock);
232
233 inode->i_security = NULL;
James Morris7cae7e22006-03-22 00:09:22 -0800234 kmem_cache_free(sel_inode_cache, isec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235}
236
237static int file_alloc_security(struct file *file)
238{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 struct file_security_struct *fsec;
David Howells275bb412008-11-14 10:39:19 +1100240 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Stephen Smalley26d2a4b2006-02-01 03:05:55 -0800242 fsec = kzalloc(sizeof(struct file_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (!fsec)
244 return -ENOMEM;
245
David Howells275bb412008-11-14 10:39:19 +1100246 fsec->sid = sid;
247 fsec->fown_sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 file->f_security = fsec;
249
250 return 0;
251}
252
253static void file_free_security(struct file *file)
254{
255 struct file_security_struct *fsec = file->f_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 file->f_security = NULL;
257 kfree(fsec);
258}
259
260static int superblock_alloc_security(struct super_block *sb)
261{
262 struct superblock_security_struct *sbsec;
263
James Morris89d155e2005-10-30 14:59:21 -0800264 sbsec = kzalloc(sizeof(struct superblock_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (!sbsec)
266 return -ENOMEM;
267
Eric Parisbc7e9822006-09-25 23:32:02 -0700268 mutex_init(&sbsec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 INIT_LIST_HEAD(&sbsec->list);
270 INIT_LIST_HEAD(&sbsec->isec_head);
271 spin_lock_init(&sbsec->isec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 sbsec->sb = sb;
273 sbsec->sid = SECINITSID_UNLABELED;
274 sbsec->def_sid = SECINITSID_FILE;
Eric Parisc312feb2006-07-10 04:43:53 -0700275 sbsec->mntpoint_sid = SECINITSID_UNLABELED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 sb->s_security = sbsec;
277
278 return 0;
279}
280
281static void superblock_free_security(struct super_block *sb)
282{
283 struct superblock_security_struct *sbsec = sb->s_security;
284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 spin_lock(&sb_security_lock);
286 if (!list_empty(&sbsec->list))
287 list_del_init(&sbsec->list);
288 spin_unlock(&sb_security_lock);
289
290 sb->s_security = NULL;
291 kfree(sbsec);
292}
293
Al Viro7d877f32005-10-21 03:20:43 -0400294static int sk_alloc_security(struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295{
296 struct sk_security_struct *ssec;
297
James Morris89d155e2005-10-30 14:59:21 -0800298 ssec = kzalloc(sizeof(*ssec), priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 if (!ssec)
300 return -ENOMEM;
301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 ssec->peer_sid = SECINITSID_UNLABELED;
Venkat Yekkirala892c1412006-08-04 23:08:56 -0700303 ssec->sid = SECINITSID_UNLABELED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 sk->sk_security = ssec;
305
Paul Moore389fb8002009-03-27 17:10:34 -0400306 selinux_netlbl_sk_security_reset(ssec);
Paul Moore99f59ed2006-08-29 17:53:48 -0700307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 return 0;
309}
310
311static void sk_free_security(struct sock *sk)
312{
313 struct sk_security_struct *ssec = sk->sk_security;
314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 sk->sk_security = NULL;
Paul Moore6c5b3fc2008-10-10 10:16:33 -0400316 selinux_netlbl_sk_security_free(ssec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 kfree(ssec);
318}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320/* The security server must be initialized before
321 any labeling or access decisions can be provided. */
322extern int ss_initialized;
323
324/* The file system's label must be initialized prior to use. */
325
326static char *labeling_behaviors[6] = {
327 "uses xattr",
328 "uses transition SIDs",
329 "uses task SIDs",
330 "uses genfs_contexts",
331 "not configured for labeling",
332 "uses mountpoint labeling",
333};
334
335static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry);
336
337static inline int inode_doinit(struct inode *inode)
338{
339 return inode_doinit_with_dentry(inode, NULL);
340}
341
342enum {
Eric Paris31e87932007-09-19 17:19:12 -0400343 Opt_error = -1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 Opt_context = 1,
345 Opt_fscontext = 2,
Eric Parisc9180a52007-11-30 13:00:35 -0500346 Opt_defcontext = 3,
347 Opt_rootcontext = 4,
David P. Quigley11689d42009-01-16 09:22:03 -0500348 Opt_labelsupport = 5,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349};
350
Steven Whitehousea447c092008-10-13 10:46:57 +0100351static const match_table_t tokens = {
Eric Paris832cbd92008-04-01 13:24:09 -0400352 {Opt_context, CONTEXT_STR "%s"},
353 {Opt_fscontext, FSCONTEXT_STR "%s"},
354 {Opt_defcontext, DEFCONTEXT_STR "%s"},
355 {Opt_rootcontext, ROOTCONTEXT_STR "%s"},
David P. Quigley11689d42009-01-16 09:22:03 -0500356 {Opt_labelsupport, LABELSUPP_STR},
Eric Paris31e87932007-09-19 17:19:12 -0400357 {Opt_error, NULL},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358};
359
360#define SEL_MOUNT_FAIL_MSG "SELinux: duplicate or incompatible mount options\n"
361
Eric Parisc312feb2006-07-10 04:43:53 -0700362static int may_context_mount_sb_relabel(u32 sid,
363 struct superblock_security_struct *sbsec,
David Howells275bb412008-11-14 10:39:19 +1100364 const struct cred *cred)
Eric Parisc312feb2006-07-10 04:43:53 -0700365{
David Howells275bb412008-11-14 10:39:19 +1100366 const struct task_security_struct *tsec = cred->security;
Eric Parisc312feb2006-07-10 04:43:53 -0700367 int rc;
368
369 rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
370 FILESYSTEM__RELABELFROM, NULL);
371 if (rc)
372 return rc;
373
374 rc = avc_has_perm(tsec->sid, sid, SECCLASS_FILESYSTEM,
375 FILESYSTEM__RELABELTO, NULL);
376 return rc;
377}
378
Eric Paris08089252006-07-10 04:43:55 -0700379static int may_context_mount_inode_relabel(u32 sid,
380 struct superblock_security_struct *sbsec,
David Howells275bb412008-11-14 10:39:19 +1100381 const struct cred *cred)
Eric Paris08089252006-07-10 04:43:55 -0700382{
David Howells275bb412008-11-14 10:39:19 +1100383 const struct task_security_struct *tsec = cred->security;
Eric Paris08089252006-07-10 04:43:55 -0700384 int rc;
385 rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
386 FILESYSTEM__RELABELFROM, NULL);
387 if (rc)
388 return rc;
389
390 rc = avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM,
391 FILESYSTEM__ASSOCIATE, NULL);
392 return rc;
393}
394
Eric Parisc9180a52007-11-30 13:00:35 -0500395static int sb_finish_set_opts(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
397 struct superblock_security_struct *sbsec = sb->s_security;
398 struct dentry *root = sb->s_root;
Eric Parisc9180a52007-11-30 13:00:35 -0500399 struct inode *root_inode = root->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 int rc = 0;
401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
403 /* Make sure that the xattr handler exists and that no
404 error other than -ENODATA is returned by getxattr on
405 the root directory. -ENODATA is ok, as this may be
406 the first boot of the SELinux kernel before we have
407 assigned xattr values to the filesystem. */
Eric Parisc9180a52007-11-30 13:00:35 -0500408 if (!root_inode->i_op->getxattr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
410 "xattr support\n", sb->s_id, sb->s_type->name);
411 rc = -EOPNOTSUPP;
412 goto out;
413 }
Eric Parisc9180a52007-11-30 13:00:35 -0500414 rc = root_inode->i_op->getxattr(root, XATTR_NAME_SELINUX, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (rc < 0 && rc != -ENODATA) {
416 if (rc == -EOPNOTSUPP)
417 printk(KERN_WARNING "SELinux: (dev %s, type "
418 "%s) has no security xattr handler\n",
419 sb->s_id, sb->s_type->name);
420 else
421 printk(KERN_WARNING "SELinux: (dev %s, type "
422 "%s) getxattr errno %d\n", sb->s_id,
423 sb->s_type->name, -rc);
424 goto out;
425 }
426 }
427
David P. Quigley11689d42009-01-16 09:22:03 -0500428 sbsec->flags |= (SE_SBINITIALIZED | SE_SBLABELSUPP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Eric Parisc9180a52007-11-30 13:00:35 -0500430 if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
Eric Parisfadcdb42007-02-22 18:11:31 -0500431 printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 sb->s_id, sb->s_type->name);
Eric Parisc9180a52007-11-30 13:00:35 -0500433 else
Eric Parisfadcdb42007-02-22 18:11:31 -0500434 printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 sb->s_id, sb->s_type->name,
436 labeling_behaviors[sbsec->behavior-1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
David P. Quigley11689d42009-01-16 09:22:03 -0500438 if (sbsec->behavior == SECURITY_FS_USE_GENFS ||
439 sbsec->behavior == SECURITY_FS_USE_MNTPOINT ||
440 sbsec->behavior == SECURITY_FS_USE_NONE ||
441 sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
442 sbsec->flags &= ~SE_SBLABELSUPP;
443
David P. Quigleyddd29ec2009-09-09 14:25:37 -0400444 /* Special handling for sysfs. Is genfs but also has setxattr handler*/
445 if (strncmp(sb->s_type->name, "sysfs", sizeof("sysfs")) == 0)
446 sbsec->flags |= SE_SBLABELSUPP;
447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 /* Initialize the root inode. */
Eric Parisc9180a52007-11-30 13:00:35 -0500449 rc = inode_doinit_with_dentry(root_inode, root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 /* Initialize any other inodes associated with the superblock, e.g.
452 inodes created prior to initial policy load or inodes created
453 during get_sb by a pseudo filesystem that directly
454 populates itself. */
455 spin_lock(&sbsec->isec_lock);
456next_inode:
457 if (!list_empty(&sbsec->isec_head)) {
458 struct inode_security_struct *isec =
459 list_entry(sbsec->isec_head.next,
Eric Parisc9180a52007-11-30 13:00:35 -0500460 struct inode_security_struct, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 struct inode *inode = isec->inode;
462 spin_unlock(&sbsec->isec_lock);
463 inode = igrab(inode);
464 if (inode) {
Eric Parisc9180a52007-11-30 13:00:35 -0500465 if (!IS_PRIVATE(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 inode_doinit(inode);
467 iput(inode);
468 }
469 spin_lock(&sbsec->isec_lock);
470 list_del_init(&isec->list);
471 goto next_inode;
472 }
473 spin_unlock(&sbsec->isec_lock);
474out:
Eric Parisc9180a52007-11-30 13:00:35 -0500475 return rc;
476}
477
478/*
479 * This function should allow an FS to ask what it's mount security
480 * options were so it can use those later for submounts, displaying
481 * mount options, or whatever.
482 */
483static int selinux_get_mnt_opts(const struct super_block *sb,
Eric Parise0007522008-03-05 10:31:54 -0500484 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500485{
486 int rc = 0, i;
487 struct superblock_security_struct *sbsec = sb->s_security;
488 char *context = NULL;
489 u32 len;
490 char tmp;
491
Eric Parise0007522008-03-05 10:31:54 -0500492 security_init_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500493
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500494 if (!(sbsec->flags & SE_SBINITIALIZED))
Eric Parisc9180a52007-11-30 13:00:35 -0500495 return -EINVAL;
496
497 if (!ss_initialized)
498 return -EINVAL;
499
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500500 tmp = sbsec->flags & SE_MNTMASK;
Eric Parisc9180a52007-11-30 13:00:35 -0500501 /* count the number of mount options for this sb */
502 for (i = 0; i < 8; i++) {
503 if (tmp & 0x01)
Eric Parise0007522008-03-05 10:31:54 -0500504 opts->num_mnt_opts++;
Eric Parisc9180a52007-11-30 13:00:35 -0500505 tmp >>= 1;
506 }
David P. Quigley11689d42009-01-16 09:22:03 -0500507 /* Check if the Label support flag is set */
508 if (sbsec->flags & SE_SBLABELSUPP)
509 opts->num_mnt_opts++;
Eric Parisc9180a52007-11-30 13:00:35 -0500510
Eric Parise0007522008-03-05 10:31:54 -0500511 opts->mnt_opts = kcalloc(opts->num_mnt_opts, sizeof(char *), GFP_ATOMIC);
512 if (!opts->mnt_opts) {
Eric Parisc9180a52007-11-30 13:00:35 -0500513 rc = -ENOMEM;
514 goto out_free;
515 }
516
Eric Parise0007522008-03-05 10:31:54 -0500517 opts->mnt_opts_flags = kcalloc(opts->num_mnt_opts, sizeof(int), GFP_ATOMIC);
518 if (!opts->mnt_opts_flags) {
Eric Parisc9180a52007-11-30 13:00:35 -0500519 rc = -ENOMEM;
520 goto out_free;
521 }
522
523 i = 0;
524 if (sbsec->flags & FSCONTEXT_MNT) {
525 rc = security_sid_to_context(sbsec->sid, &context, &len);
526 if (rc)
527 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500528 opts->mnt_opts[i] = context;
529 opts->mnt_opts_flags[i++] = FSCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500530 }
531 if (sbsec->flags & CONTEXT_MNT) {
532 rc = security_sid_to_context(sbsec->mntpoint_sid, &context, &len);
533 if (rc)
534 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500535 opts->mnt_opts[i] = context;
536 opts->mnt_opts_flags[i++] = CONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500537 }
538 if (sbsec->flags & DEFCONTEXT_MNT) {
539 rc = security_sid_to_context(sbsec->def_sid, &context, &len);
540 if (rc)
541 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500542 opts->mnt_opts[i] = context;
543 opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500544 }
545 if (sbsec->flags & ROOTCONTEXT_MNT) {
546 struct inode *root = sbsec->sb->s_root->d_inode;
547 struct inode_security_struct *isec = root->i_security;
548
549 rc = security_sid_to_context(isec->sid, &context, &len);
550 if (rc)
551 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500552 opts->mnt_opts[i] = context;
553 opts->mnt_opts_flags[i++] = ROOTCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500554 }
David P. Quigley11689d42009-01-16 09:22:03 -0500555 if (sbsec->flags & SE_SBLABELSUPP) {
556 opts->mnt_opts[i] = NULL;
557 opts->mnt_opts_flags[i++] = SE_SBLABELSUPP;
558 }
Eric Parisc9180a52007-11-30 13:00:35 -0500559
Eric Parise0007522008-03-05 10:31:54 -0500560 BUG_ON(i != opts->num_mnt_opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500561
562 return 0;
563
564out_free:
Eric Parise0007522008-03-05 10:31:54 -0500565 security_free_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500566 return rc;
567}
568
569static int bad_option(struct superblock_security_struct *sbsec, char flag,
570 u32 old_sid, u32 new_sid)
571{
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500572 char mnt_flags = sbsec->flags & SE_MNTMASK;
573
Eric Parisc9180a52007-11-30 13:00:35 -0500574 /* check if the old mount command had the same options */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500575 if (sbsec->flags & SE_SBINITIALIZED)
Eric Parisc9180a52007-11-30 13:00:35 -0500576 if (!(sbsec->flags & flag) ||
577 (old_sid != new_sid))
578 return 1;
579
580 /* check if we were passed the same options twice,
581 * aka someone passed context=a,context=b
582 */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500583 if (!(sbsec->flags & SE_SBINITIALIZED))
584 if (mnt_flags & flag)
Eric Parisc9180a52007-11-30 13:00:35 -0500585 return 1;
586 return 0;
587}
Eric Parise0007522008-03-05 10:31:54 -0500588
Eric Parisc9180a52007-11-30 13:00:35 -0500589/*
590 * Allow filesystems with binary mount data to explicitly set mount point
591 * labeling information.
592 */
Eric Parise0007522008-03-05 10:31:54 -0500593static int selinux_set_mnt_opts(struct super_block *sb,
594 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500595{
David Howells275bb412008-11-14 10:39:19 +1100596 const struct cred *cred = current_cred();
Eric Parisc9180a52007-11-30 13:00:35 -0500597 int rc = 0, i;
Eric Parisc9180a52007-11-30 13:00:35 -0500598 struct superblock_security_struct *sbsec = sb->s_security;
599 const char *name = sb->s_type->name;
James Morris089be432008-07-15 18:32:49 +1000600 struct inode *inode = sbsec->sb->s_root->d_inode;
601 struct inode_security_struct *root_isec = inode->i_security;
Eric Parisc9180a52007-11-30 13:00:35 -0500602 u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
603 u32 defcontext_sid = 0;
Eric Parise0007522008-03-05 10:31:54 -0500604 char **mount_options = opts->mnt_opts;
605 int *flags = opts->mnt_opts_flags;
606 int num_opts = opts->num_mnt_opts;
Eric Parisc9180a52007-11-30 13:00:35 -0500607
608 mutex_lock(&sbsec->lock);
609
610 if (!ss_initialized) {
611 if (!num_opts) {
612 /* Defer initialization until selinux_complete_init,
613 after the initial policy is loaded and the security
614 server is ready to handle calls. */
615 spin_lock(&sb_security_lock);
616 if (list_empty(&sbsec->list))
617 list_add(&sbsec->list, &superblock_security_head);
618 spin_unlock(&sb_security_lock);
619 goto out;
620 }
621 rc = -EINVAL;
Eric Paris744ba352008-04-17 11:52:44 -0400622 printk(KERN_WARNING "SELinux: Unable to set superblock options "
623 "before the security server is initialized\n");
Eric Parisc9180a52007-11-30 13:00:35 -0500624 goto out;
625 }
626
627 /*
Eric Parise0007522008-03-05 10:31:54 -0500628 * Binary mount data FS will come through this function twice. Once
629 * from an explicit call and once from the generic calls from the vfs.
630 * Since the generic VFS calls will not contain any security mount data
631 * we need to skip the double mount verification.
632 *
633 * This does open a hole in which we will not notice if the first
634 * mount using this sb set explict options and a second mount using
635 * this sb does not set any security options. (The first options
636 * will be used for both mounts)
637 */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500638 if ((sbsec->flags & SE_SBINITIALIZED) && (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
Eric Parise0007522008-03-05 10:31:54 -0500639 && (num_opts == 0))
Eric Parisf5269712008-05-14 11:27:45 -0400640 goto out;
Eric Parise0007522008-03-05 10:31:54 -0500641
642 /*
Eric Parisc9180a52007-11-30 13:00:35 -0500643 * parse the mount options, check if they are valid sids.
644 * also check if someone is trying to mount the same sb more
645 * than once with different security options.
646 */
647 for (i = 0; i < num_opts; i++) {
648 u32 sid;
David P. Quigley11689d42009-01-16 09:22:03 -0500649
650 if (flags[i] == SE_SBLABELSUPP)
651 continue;
Eric Parisc9180a52007-11-30 13:00:35 -0500652 rc = security_context_to_sid(mount_options[i],
653 strlen(mount_options[i]), &sid);
654 if (rc) {
655 printk(KERN_WARNING "SELinux: security_context_to_sid"
656 "(%s) failed for (dev %s, type %s) errno=%d\n",
657 mount_options[i], sb->s_id, name, rc);
658 goto out;
659 }
660 switch (flags[i]) {
661 case FSCONTEXT_MNT:
662 fscontext_sid = sid;
663
664 if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid,
665 fscontext_sid))
666 goto out_double_mount;
667
668 sbsec->flags |= FSCONTEXT_MNT;
669 break;
670 case CONTEXT_MNT:
671 context_sid = sid;
672
673 if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid,
674 context_sid))
675 goto out_double_mount;
676
677 sbsec->flags |= CONTEXT_MNT;
678 break;
679 case ROOTCONTEXT_MNT:
680 rootcontext_sid = sid;
681
682 if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid,
683 rootcontext_sid))
684 goto out_double_mount;
685
686 sbsec->flags |= ROOTCONTEXT_MNT;
687
688 break;
689 case DEFCONTEXT_MNT:
690 defcontext_sid = sid;
691
692 if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid,
693 defcontext_sid))
694 goto out_double_mount;
695
696 sbsec->flags |= DEFCONTEXT_MNT;
697
698 break;
699 default:
700 rc = -EINVAL;
701 goto out;
702 }
703 }
704
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500705 if (sbsec->flags & SE_SBINITIALIZED) {
Eric Parisc9180a52007-11-30 13:00:35 -0500706 /* previously mounted with options, but not on this attempt? */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500707 if ((sbsec->flags & SE_MNTMASK) && !num_opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500708 goto out_double_mount;
709 rc = 0;
710 goto out;
711 }
712
James Morris089be432008-07-15 18:32:49 +1000713 if (strcmp(sb->s_type->name, "proc") == 0)
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500714 sbsec->flags |= SE_SBPROC;
Eric Parisc9180a52007-11-30 13:00:35 -0500715
716 /* Determine the labeling behavior to use for this filesystem type. */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500717 rc = security_fs_use((sbsec->flags & SE_SBPROC) ? "proc" : sb->s_type->name, &sbsec->behavior, &sbsec->sid);
Eric Parisc9180a52007-11-30 13:00:35 -0500718 if (rc) {
719 printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n",
James Morris089be432008-07-15 18:32:49 +1000720 __func__, sb->s_type->name, rc);
Eric Parisc9180a52007-11-30 13:00:35 -0500721 goto out;
722 }
723
724 /* sets the context of the superblock for the fs being mounted. */
725 if (fscontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100726 rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500727 if (rc)
728 goto out;
729
730 sbsec->sid = fscontext_sid;
731 }
732
733 /*
734 * Switch to using mount point labeling behavior.
735 * sets the label used on all file below the mountpoint, and will set
736 * the superblock context if not already set.
737 */
738 if (context_sid) {
739 if (!fscontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100740 rc = may_context_mount_sb_relabel(context_sid, sbsec,
741 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500742 if (rc)
743 goto out;
744 sbsec->sid = context_sid;
745 } else {
David Howells275bb412008-11-14 10:39:19 +1100746 rc = may_context_mount_inode_relabel(context_sid, sbsec,
747 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500748 if (rc)
749 goto out;
750 }
751 if (!rootcontext_sid)
752 rootcontext_sid = context_sid;
753
754 sbsec->mntpoint_sid = context_sid;
755 sbsec->behavior = SECURITY_FS_USE_MNTPOINT;
756 }
757
758 if (rootcontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100759 rc = may_context_mount_inode_relabel(rootcontext_sid, sbsec,
760 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500761 if (rc)
762 goto out;
763
764 root_isec->sid = rootcontext_sid;
765 root_isec->initialized = 1;
766 }
767
768 if (defcontext_sid) {
769 if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
770 rc = -EINVAL;
771 printk(KERN_WARNING "SELinux: defcontext option is "
772 "invalid for this filesystem type\n");
773 goto out;
774 }
775
776 if (defcontext_sid != sbsec->def_sid) {
777 rc = may_context_mount_inode_relabel(defcontext_sid,
David Howells275bb412008-11-14 10:39:19 +1100778 sbsec, cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500779 if (rc)
780 goto out;
781 }
782
783 sbsec->def_sid = defcontext_sid;
784 }
785
786 rc = sb_finish_set_opts(sb);
787out:
Eric Parisbc7e9822006-09-25 23:32:02 -0700788 mutex_unlock(&sbsec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return rc;
Eric Parisc9180a52007-11-30 13:00:35 -0500790out_double_mount:
791 rc = -EINVAL;
792 printk(KERN_WARNING "SELinux: mount invalid. Same superblock, different "
793 "security settings for (dev %s, type %s)\n", sb->s_id, name);
794 goto out;
795}
796
797static void selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
798 struct super_block *newsb)
799{
800 const struct superblock_security_struct *oldsbsec = oldsb->s_security;
801 struct superblock_security_struct *newsbsec = newsb->s_security;
802
803 int set_fscontext = (oldsbsec->flags & FSCONTEXT_MNT);
804 int set_context = (oldsbsec->flags & CONTEXT_MNT);
805 int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT);
806
Eric Paris0f5e6422008-04-21 16:24:11 -0400807 /*
808 * if the parent was able to be mounted it clearly had no special lsm
809 * mount options. thus we can safely put this sb on the list and deal
810 * with it later
811 */
812 if (!ss_initialized) {
813 spin_lock(&sb_security_lock);
814 if (list_empty(&newsbsec->list))
815 list_add(&newsbsec->list, &superblock_security_head);
816 spin_unlock(&sb_security_lock);
817 return;
818 }
Eric Parisc9180a52007-11-30 13:00:35 -0500819
Eric Parisc9180a52007-11-30 13:00:35 -0500820 /* how can we clone if the old one wasn't set up?? */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500821 BUG_ON(!(oldsbsec->flags & SE_SBINITIALIZED));
Eric Parisc9180a52007-11-30 13:00:35 -0500822
Eric Paris5a552612008-04-09 14:08:35 -0400823 /* if fs is reusing a sb, just let its options stand... */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500824 if (newsbsec->flags & SE_SBINITIALIZED)
Eric Paris5a552612008-04-09 14:08:35 -0400825 return;
826
Eric Parisc9180a52007-11-30 13:00:35 -0500827 mutex_lock(&newsbsec->lock);
828
829 newsbsec->flags = oldsbsec->flags;
830
831 newsbsec->sid = oldsbsec->sid;
832 newsbsec->def_sid = oldsbsec->def_sid;
833 newsbsec->behavior = oldsbsec->behavior;
834
835 if (set_context) {
836 u32 sid = oldsbsec->mntpoint_sid;
837
838 if (!set_fscontext)
839 newsbsec->sid = sid;
840 if (!set_rootcontext) {
841 struct inode *newinode = newsb->s_root->d_inode;
842 struct inode_security_struct *newisec = newinode->i_security;
843 newisec->sid = sid;
844 }
845 newsbsec->mntpoint_sid = sid;
846 }
847 if (set_rootcontext) {
848 const struct inode *oldinode = oldsb->s_root->d_inode;
849 const struct inode_security_struct *oldisec = oldinode->i_security;
850 struct inode *newinode = newsb->s_root->d_inode;
851 struct inode_security_struct *newisec = newinode->i_security;
852
853 newisec->sid = oldisec->sid;
854 }
855
856 sb_finish_set_opts(newsb);
857 mutex_unlock(&newsbsec->lock);
858}
859
Adrian Bunk2e1479d2008-03-17 22:29:23 +0200860static int selinux_parse_opts_str(char *options,
861 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500862{
Eric Parise0007522008-03-05 10:31:54 -0500863 char *p;
Eric Parisc9180a52007-11-30 13:00:35 -0500864 char *context = NULL, *defcontext = NULL;
865 char *fscontext = NULL, *rootcontext = NULL;
Eric Parise0007522008-03-05 10:31:54 -0500866 int rc, num_mnt_opts = 0;
Eric Parisc9180a52007-11-30 13:00:35 -0500867
Eric Parise0007522008-03-05 10:31:54 -0500868 opts->num_mnt_opts = 0;
Eric Parisc9180a52007-11-30 13:00:35 -0500869
870 /* Standard string-based options. */
871 while ((p = strsep(&options, "|")) != NULL) {
872 int token;
873 substring_t args[MAX_OPT_ARGS];
874
875 if (!*p)
876 continue;
877
878 token = match_token(p, tokens, args);
879
880 switch (token) {
881 case Opt_context:
882 if (context || defcontext) {
883 rc = -EINVAL;
884 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
885 goto out_err;
886 }
887 context = match_strdup(&args[0]);
888 if (!context) {
889 rc = -ENOMEM;
890 goto out_err;
891 }
892 break;
893
894 case Opt_fscontext:
895 if (fscontext) {
896 rc = -EINVAL;
897 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
898 goto out_err;
899 }
900 fscontext = match_strdup(&args[0]);
901 if (!fscontext) {
902 rc = -ENOMEM;
903 goto out_err;
904 }
905 break;
906
907 case Opt_rootcontext:
908 if (rootcontext) {
909 rc = -EINVAL;
910 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
911 goto out_err;
912 }
913 rootcontext = match_strdup(&args[0]);
914 if (!rootcontext) {
915 rc = -ENOMEM;
916 goto out_err;
917 }
918 break;
919
920 case Opt_defcontext:
921 if (context || defcontext) {
922 rc = -EINVAL;
923 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
924 goto out_err;
925 }
926 defcontext = match_strdup(&args[0]);
927 if (!defcontext) {
928 rc = -ENOMEM;
929 goto out_err;
930 }
931 break;
David P. Quigley11689d42009-01-16 09:22:03 -0500932 case Opt_labelsupport:
933 break;
Eric Parisc9180a52007-11-30 13:00:35 -0500934 default:
935 rc = -EINVAL;
936 printk(KERN_WARNING "SELinux: unknown mount option\n");
937 goto out_err;
938
939 }
940 }
941
Eric Parise0007522008-03-05 10:31:54 -0500942 rc = -ENOMEM;
943 opts->mnt_opts = kcalloc(NUM_SEL_MNT_OPTS, sizeof(char *), GFP_ATOMIC);
944 if (!opts->mnt_opts)
945 goto out_err;
946
947 opts->mnt_opts_flags = kcalloc(NUM_SEL_MNT_OPTS, sizeof(int), GFP_ATOMIC);
948 if (!opts->mnt_opts_flags) {
949 kfree(opts->mnt_opts);
950 goto out_err;
Eric Parisc9180a52007-11-30 13:00:35 -0500951 }
952
Eric Parise0007522008-03-05 10:31:54 -0500953 if (fscontext) {
954 opts->mnt_opts[num_mnt_opts] = fscontext;
955 opts->mnt_opts_flags[num_mnt_opts++] = FSCONTEXT_MNT;
956 }
957 if (context) {
958 opts->mnt_opts[num_mnt_opts] = context;
959 opts->mnt_opts_flags[num_mnt_opts++] = CONTEXT_MNT;
960 }
961 if (rootcontext) {
962 opts->mnt_opts[num_mnt_opts] = rootcontext;
963 opts->mnt_opts_flags[num_mnt_opts++] = ROOTCONTEXT_MNT;
964 }
965 if (defcontext) {
966 opts->mnt_opts[num_mnt_opts] = defcontext;
967 opts->mnt_opts_flags[num_mnt_opts++] = DEFCONTEXT_MNT;
968 }
969
970 opts->num_mnt_opts = num_mnt_opts;
971 return 0;
972
Eric Parisc9180a52007-11-30 13:00:35 -0500973out_err:
974 kfree(context);
975 kfree(defcontext);
976 kfree(fscontext);
977 kfree(rootcontext);
978 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979}
Eric Parise0007522008-03-05 10:31:54 -0500980/*
981 * string mount options parsing and call set the sbsec
982 */
983static int superblock_doinit(struct super_block *sb, void *data)
984{
985 int rc = 0;
986 char *options = data;
987 struct security_mnt_opts opts;
988
989 security_init_mnt_opts(&opts);
990
991 if (!data)
992 goto out;
993
994 BUG_ON(sb->s_type->fs_flags & FS_BINARY_MOUNTDATA);
995
996 rc = selinux_parse_opts_str(options, &opts);
997 if (rc)
998 goto out_err;
999
1000out:
1001 rc = selinux_set_mnt_opts(sb, &opts);
1002
1003out_err:
1004 security_free_mnt_opts(&opts);
1005 return rc;
1006}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
Adrian Bunk3583a712008-07-22 20:21:23 +03001008static void selinux_write_opts(struct seq_file *m,
1009 struct security_mnt_opts *opts)
Eric Paris2069f452008-07-04 09:47:13 +10001010{
1011 int i;
1012 char *prefix;
1013
1014 for (i = 0; i < opts->num_mnt_opts; i++) {
David P. Quigley11689d42009-01-16 09:22:03 -05001015 char *has_comma;
1016
1017 if (opts->mnt_opts[i])
1018 has_comma = strchr(opts->mnt_opts[i], ',');
1019 else
1020 has_comma = NULL;
Eric Paris2069f452008-07-04 09:47:13 +10001021
1022 switch (opts->mnt_opts_flags[i]) {
1023 case CONTEXT_MNT:
1024 prefix = CONTEXT_STR;
1025 break;
1026 case FSCONTEXT_MNT:
1027 prefix = FSCONTEXT_STR;
1028 break;
1029 case ROOTCONTEXT_MNT:
1030 prefix = ROOTCONTEXT_STR;
1031 break;
1032 case DEFCONTEXT_MNT:
1033 prefix = DEFCONTEXT_STR;
1034 break;
David P. Quigley11689d42009-01-16 09:22:03 -05001035 case SE_SBLABELSUPP:
1036 seq_putc(m, ',');
1037 seq_puts(m, LABELSUPP_STR);
1038 continue;
Eric Paris2069f452008-07-04 09:47:13 +10001039 default:
1040 BUG();
1041 };
1042 /* we need a comma before each option */
1043 seq_putc(m, ',');
1044 seq_puts(m, prefix);
1045 if (has_comma)
1046 seq_putc(m, '\"');
1047 seq_puts(m, opts->mnt_opts[i]);
1048 if (has_comma)
1049 seq_putc(m, '\"');
1050 }
1051}
1052
1053static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb)
1054{
1055 struct security_mnt_opts opts;
1056 int rc;
1057
1058 rc = selinux_get_mnt_opts(sb, &opts);
Eric Paris383795c2008-07-29 17:07:26 -04001059 if (rc) {
1060 /* before policy load we may get EINVAL, don't show anything */
1061 if (rc == -EINVAL)
1062 rc = 0;
Eric Paris2069f452008-07-04 09:47:13 +10001063 return rc;
Eric Paris383795c2008-07-29 17:07:26 -04001064 }
Eric Paris2069f452008-07-04 09:47:13 +10001065
1066 selinux_write_opts(m, &opts);
1067
1068 security_free_mnt_opts(&opts);
1069
1070 return rc;
1071}
1072
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073static inline u16 inode_mode_to_security_class(umode_t mode)
1074{
1075 switch (mode & S_IFMT) {
1076 case S_IFSOCK:
1077 return SECCLASS_SOCK_FILE;
1078 case S_IFLNK:
1079 return SECCLASS_LNK_FILE;
1080 case S_IFREG:
1081 return SECCLASS_FILE;
1082 case S_IFBLK:
1083 return SECCLASS_BLK_FILE;
1084 case S_IFDIR:
1085 return SECCLASS_DIR;
1086 case S_IFCHR:
1087 return SECCLASS_CHR_FILE;
1088 case S_IFIFO:
1089 return SECCLASS_FIFO_FILE;
1090
1091 }
1092
1093 return SECCLASS_FILE;
1094}
1095
James Morris13402582005-09-30 14:24:34 -04001096static inline int default_protocol_stream(int protocol)
1097{
1098 return (protocol == IPPROTO_IP || protocol == IPPROTO_TCP);
1099}
1100
1101static inline int default_protocol_dgram(int protocol)
1102{
1103 return (protocol == IPPROTO_IP || protocol == IPPROTO_UDP);
1104}
1105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106static inline u16 socket_type_to_security_class(int family, int type, int protocol)
1107{
1108 switch (family) {
1109 case PF_UNIX:
1110 switch (type) {
1111 case SOCK_STREAM:
1112 case SOCK_SEQPACKET:
1113 return SECCLASS_UNIX_STREAM_SOCKET;
1114 case SOCK_DGRAM:
1115 return SECCLASS_UNIX_DGRAM_SOCKET;
1116 }
1117 break;
1118 case PF_INET:
1119 case PF_INET6:
1120 switch (type) {
1121 case SOCK_STREAM:
James Morris13402582005-09-30 14:24:34 -04001122 if (default_protocol_stream(protocol))
1123 return SECCLASS_TCP_SOCKET;
1124 else
1125 return SECCLASS_RAWIP_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 case SOCK_DGRAM:
James Morris13402582005-09-30 14:24:34 -04001127 if (default_protocol_dgram(protocol))
1128 return SECCLASS_UDP_SOCKET;
1129 else
1130 return SECCLASS_RAWIP_SOCKET;
James Morris2ee92d42006-11-13 16:09:01 -08001131 case SOCK_DCCP:
1132 return SECCLASS_DCCP_SOCKET;
James Morris13402582005-09-30 14:24:34 -04001133 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 return SECCLASS_RAWIP_SOCKET;
1135 }
1136 break;
1137 case PF_NETLINK:
1138 switch (protocol) {
1139 case NETLINK_ROUTE:
1140 return SECCLASS_NETLINK_ROUTE_SOCKET;
1141 case NETLINK_FIREWALL:
1142 return SECCLASS_NETLINK_FIREWALL_SOCKET;
James Morris216efaa2005-08-15 20:34:48 -07001143 case NETLINK_INET_DIAG:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 return SECCLASS_NETLINK_TCPDIAG_SOCKET;
1145 case NETLINK_NFLOG:
1146 return SECCLASS_NETLINK_NFLOG_SOCKET;
1147 case NETLINK_XFRM:
1148 return SECCLASS_NETLINK_XFRM_SOCKET;
1149 case NETLINK_SELINUX:
1150 return SECCLASS_NETLINK_SELINUX_SOCKET;
1151 case NETLINK_AUDIT:
1152 return SECCLASS_NETLINK_AUDIT_SOCKET;
1153 case NETLINK_IP6_FW:
1154 return SECCLASS_NETLINK_IP6FW_SOCKET;
1155 case NETLINK_DNRTMSG:
1156 return SECCLASS_NETLINK_DNRT_SOCKET;
James Morris0c9b7942005-04-16 15:24:13 -07001157 case NETLINK_KOBJECT_UEVENT:
1158 return SECCLASS_NETLINK_KOBJECT_UEVENT_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 default:
1160 return SECCLASS_NETLINK_SOCKET;
1161 }
1162 case PF_PACKET:
1163 return SECCLASS_PACKET_SOCKET;
1164 case PF_KEY:
1165 return SECCLASS_KEY_SOCKET;
Christopher J. PeBenito3e3ff152006-06-09 00:25:03 -07001166 case PF_APPLETALK:
1167 return SECCLASS_APPLETALK_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 }
1169
1170 return SECCLASS_SOCKET;
1171}
1172
1173#ifdef CONFIG_PROC_FS
1174static int selinux_proc_get_sid(struct proc_dir_entry *de,
1175 u16 tclass,
1176 u32 *sid)
1177{
1178 int buflen, rc;
1179 char *buffer, *path, *end;
1180
Eric Paris828dfe12008-04-17 13:17:49 -04001181 buffer = (char *)__get_free_page(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 if (!buffer)
1183 return -ENOMEM;
1184
1185 buflen = PAGE_SIZE;
1186 end = buffer+buflen;
1187 *--end = '\0';
1188 buflen--;
1189 path = end-1;
1190 *path = '/';
1191 while (de && de != de->parent) {
1192 buflen -= de->namelen + 1;
1193 if (buflen < 0)
1194 break;
1195 end -= de->namelen;
1196 memcpy(end, de->name, de->namelen);
1197 *--end = '/';
1198 path = end;
1199 de = de->parent;
1200 }
1201 rc = security_genfs_sid("proc", path, tclass, sid);
1202 free_page((unsigned long)buffer);
1203 return rc;
1204}
1205#else
1206static int selinux_proc_get_sid(struct proc_dir_entry *de,
1207 u16 tclass,
1208 u32 *sid)
1209{
1210 return -EINVAL;
1211}
1212#endif
1213
1214/* The inode's security attributes must be initialized before first use. */
1215static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry)
1216{
1217 struct superblock_security_struct *sbsec = NULL;
1218 struct inode_security_struct *isec = inode->i_security;
1219 u32 sid;
1220 struct dentry *dentry;
1221#define INITCONTEXTLEN 255
1222 char *context = NULL;
1223 unsigned len = 0;
1224 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
1226 if (isec->initialized)
1227 goto out;
1228
Eric Paris23970742006-09-25 23:32:01 -07001229 mutex_lock(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 if (isec->initialized)
Eric Paris23970742006-09-25 23:32:01 -07001231 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233 sbsec = inode->i_sb->s_security;
David P. Quigley0d90a7e2009-01-16 09:22:02 -05001234 if (!(sbsec->flags & SE_SBINITIALIZED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 /* Defer initialization until selinux_complete_init,
1236 after the initial policy is loaded and the security
1237 server is ready to handle calls. */
1238 spin_lock(&sbsec->isec_lock);
1239 if (list_empty(&isec->list))
1240 list_add(&isec->list, &sbsec->isec_head);
1241 spin_unlock(&sbsec->isec_lock);
Eric Paris23970742006-09-25 23:32:01 -07001242 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 }
1244
1245 switch (sbsec->behavior) {
1246 case SECURITY_FS_USE_XATTR:
1247 if (!inode->i_op->getxattr) {
1248 isec->sid = sbsec->def_sid;
1249 break;
1250 }
1251
1252 /* Need a dentry, since the xattr API requires one.
1253 Life would be simpler if we could just pass the inode. */
1254 if (opt_dentry) {
1255 /* Called from d_instantiate or d_splice_alias. */
1256 dentry = dget(opt_dentry);
1257 } else {
1258 /* Called from selinux_complete_init, try to find a dentry. */
1259 dentry = d_find_alias(inode);
1260 }
1261 if (!dentry) {
Eric Parisdf7f54c2009-03-09 14:35:58 -04001262 /*
1263 * this is can be hit on boot when a file is accessed
1264 * before the policy is loaded. When we load policy we
1265 * may find inodes that have no dentry on the
1266 * sbsec->isec_head list. No reason to complain as these
1267 * will get fixed up the next time we go through
1268 * inode_doinit with a dentry, before these inodes could
1269 * be used again by userspace.
1270 */
Eric Paris23970742006-09-25 23:32:01 -07001271 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 }
1273
1274 len = INITCONTEXTLEN;
Eric Paris4cb912f2009-02-12 14:50:05 -05001275 context = kmalloc(len+1, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 if (!context) {
1277 rc = -ENOMEM;
1278 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001279 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
Eric Paris4cb912f2009-02-12 14:50:05 -05001281 context[len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1283 context, len);
1284 if (rc == -ERANGE) {
James Morris314dabb2009-08-10 22:00:13 +10001285 kfree(context);
1286
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 /* Need a larger buffer. Query for the right size. */
1288 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1289 NULL, 0);
1290 if (rc < 0) {
1291 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001292 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 len = rc;
Eric Paris4cb912f2009-02-12 14:50:05 -05001295 context = kmalloc(len+1, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 if (!context) {
1297 rc = -ENOMEM;
1298 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001299 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 }
Eric Paris4cb912f2009-02-12 14:50:05 -05001301 context[len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 rc = inode->i_op->getxattr(dentry,
1303 XATTR_NAME_SELINUX,
1304 context, len);
1305 }
1306 dput(dentry);
1307 if (rc < 0) {
1308 if (rc != -ENODATA) {
Eric Paris744ba352008-04-17 11:52:44 -04001309 printk(KERN_WARNING "SELinux: %s: getxattr returned "
Harvey Harrisondd6f9532008-03-06 10:03:59 +11001310 "%d for dev=%s ino=%ld\n", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 -rc, inode->i_sb->s_id, inode->i_ino);
1312 kfree(context);
Eric Paris23970742006-09-25 23:32:01 -07001313 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315 /* Map ENODATA to the default file SID */
1316 sid = sbsec->def_sid;
1317 rc = 0;
1318 } else {
James Morrisf5c1d5b2005-07-28 01:07:37 -07001319 rc = security_context_to_sid_default(context, rc, &sid,
Stephen Smalley869ab512008-04-04 08:46:05 -04001320 sbsec->def_sid,
1321 GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 if (rc) {
Eric Paris4ba0a8a2009-02-12 15:01:10 -05001323 char *dev = inode->i_sb->s_id;
1324 unsigned long ino = inode->i_ino;
1325
1326 if (rc == -EINVAL) {
1327 if (printk_ratelimit())
1328 printk(KERN_NOTICE "SELinux: inode=%lu on dev=%s was found to have an invalid "
1329 "context=%s. This indicates you may need to relabel the inode or the "
1330 "filesystem in question.\n", ino, dev, context);
1331 } else {
1332 printk(KERN_WARNING "SELinux: %s: context_to_sid(%s) "
1333 "returned %d for dev=%s ino=%ld\n",
1334 __func__, context, -rc, dev, ino);
1335 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 kfree(context);
1337 /* Leave with the unlabeled SID */
1338 rc = 0;
1339 break;
1340 }
1341 }
1342 kfree(context);
1343 isec->sid = sid;
1344 break;
1345 case SECURITY_FS_USE_TASK:
1346 isec->sid = isec->task_sid;
1347 break;
1348 case SECURITY_FS_USE_TRANS:
1349 /* Default to the fs SID. */
1350 isec->sid = sbsec->sid;
1351
1352 /* Try to obtain a transition SID. */
1353 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1354 rc = security_transition_sid(isec->task_sid,
1355 sbsec->sid,
1356 isec->sclass,
1357 &sid);
1358 if (rc)
Eric Paris23970742006-09-25 23:32:01 -07001359 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 isec->sid = sid;
1361 break;
Eric Parisc312feb2006-07-10 04:43:53 -07001362 case SECURITY_FS_USE_MNTPOINT:
1363 isec->sid = sbsec->mntpoint_sid;
1364 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 default:
Eric Parisc312feb2006-07-10 04:43:53 -07001366 /* Default to the fs superblock SID. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 isec->sid = sbsec->sid;
1368
David P. Quigley0d90a7e2009-01-16 09:22:02 -05001369 if ((sbsec->flags & SE_SBPROC) && !S_ISLNK(inode->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 struct proc_inode *proci = PROC_I(inode);
1371 if (proci->pde) {
1372 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1373 rc = selinux_proc_get_sid(proci->pde,
1374 isec->sclass,
1375 &sid);
1376 if (rc)
Eric Paris23970742006-09-25 23:32:01 -07001377 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 isec->sid = sid;
1379 }
1380 }
1381 break;
1382 }
1383
1384 isec->initialized = 1;
1385
Eric Paris23970742006-09-25 23:32:01 -07001386out_unlock:
1387 mutex_unlock(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388out:
1389 if (isec->sclass == SECCLASS_FILE)
1390 isec->sclass = inode_mode_to_security_class(inode->i_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 return rc;
1392}
1393
1394/* Convert a Linux signal to an access vector. */
1395static inline u32 signal_to_av(int sig)
1396{
1397 u32 perm = 0;
1398
1399 switch (sig) {
1400 case SIGCHLD:
1401 /* Commonly granted from child to parent. */
1402 perm = PROCESS__SIGCHLD;
1403 break;
1404 case SIGKILL:
1405 /* Cannot be caught or ignored */
1406 perm = PROCESS__SIGKILL;
1407 break;
1408 case SIGSTOP:
1409 /* Cannot be caught or ignored */
1410 perm = PROCESS__SIGSTOP;
1411 break;
1412 default:
1413 /* All other signals. */
1414 perm = PROCESS__SIGNAL;
1415 break;
1416 }
1417
1418 return perm;
1419}
1420
David Howells275bb412008-11-14 10:39:19 +11001421/*
David Howellsd84f4f92008-11-14 10:39:23 +11001422 * Check permission between a pair of credentials
1423 * fork check, ptrace check, etc.
1424 */
1425static int cred_has_perm(const struct cred *actor,
1426 const struct cred *target,
1427 u32 perms)
1428{
1429 u32 asid = cred_sid(actor), tsid = cred_sid(target);
1430
1431 return avc_has_perm(asid, tsid, SECCLASS_PROCESS, perms, NULL);
1432}
1433
1434/*
David Howells88e67f32008-11-14 10:39:21 +11001435 * Check permission between a pair of tasks, e.g. signal checks,
David Howells275bb412008-11-14 10:39:19 +11001436 * fork check, ptrace check, etc.
1437 * tsk1 is the actor and tsk2 is the target
David Howells3b11a1d2008-11-14 10:39:26 +11001438 * - this uses the default subjective creds of tsk1
David Howells275bb412008-11-14 10:39:19 +11001439 */
1440static int task_has_perm(const struct task_struct *tsk1,
1441 const struct task_struct *tsk2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 u32 perms)
1443{
David Howells275bb412008-11-14 10:39:19 +11001444 const struct task_security_struct *__tsec1, *__tsec2;
1445 u32 sid1, sid2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
David Howells275bb412008-11-14 10:39:19 +11001447 rcu_read_lock();
1448 __tsec1 = __task_cred(tsk1)->security; sid1 = __tsec1->sid;
1449 __tsec2 = __task_cred(tsk2)->security; sid2 = __tsec2->sid;
1450 rcu_read_unlock();
1451 return avc_has_perm(sid1, sid2, SECCLASS_PROCESS, perms, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452}
1453
David Howells3b11a1d2008-11-14 10:39:26 +11001454/*
1455 * Check permission between current and another task, e.g. signal checks,
1456 * fork check, ptrace check, etc.
1457 * current is the actor and tsk2 is the target
1458 * - this uses current's subjective creds
1459 */
1460static int current_has_perm(const struct task_struct *tsk,
1461 u32 perms)
1462{
1463 u32 sid, tsid;
1464
1465 sid = current_sid();
1466 tsid = task_sid(tsk);
1467 return avc_has_perm(sid, tsid, SECCLASS_PROCESS, perms, NULL);
1468}
1469
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001470#if CAP_LAST_CAP > 63
1471#error Fix SELinux to handle capabilities > 63.
1472#endif
1473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474/* Check whether a task is allowed to use a capability. */
1475static int task_has_capability(struct task_struct *tsk,
David Howells3699c532009-01-06 22:27:01 +00001476 const struct cred *cred,
Eric Paris06112162008-11-11 22:02:50 +11001477 int cap, int audit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478{
Thomas Liu2bf49692009-07-14 12:14:09 -04001479 struct common_audit_data ad;
Eric Paris06112162008-11-11 22:02:50 +11001480 struct av_decision avd;
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001481 u16 sclass;
David Howells3699c532009-01-06 22:27:01 +00001482 u32 sid = cred_sid(cred);
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001483 u32 av = CAP_TO_MASK(cap);
Eric Paris06112162008-11-11 22:02:50 +11001484 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
Thomas Liu2bf49692009-07-14 12:14:09 -04001486 COMMON_AUDIT_DATA_INIT(&ad, CAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 ad.tsk = tsk;
1488 ad.u.cap = cap;
1489
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001490 switch (CAP_TO_INDEX(cap)) {
1491 case 0:
1492 sclass = SECCLASS_CAPABILITY;
1493 break;
1494 case 1:
1495 sclass = SECCLASS_CAPABILITY2;
1496 break;
1497 default:
1498 printk(KERN_ERR
1499 "SELinux: out of range capability %d\n", cap);
1500 BUG();
1501 }
Eric Paris06112162008-11-11 22:02:50 +11001502
David Howells275bb412008-11-14 10:39:19 +11001503 rc = avc_has_perm_noaudit(sid, sid, sclass, av, 0, &avd);
Eric Paris06112162008-11-11 22:02:50 +11001504 if (audit == SECURITY_CAP_AUDIT)
David Howells275bb412008-11-14 10:39:19 +11001505 avc_audit(sid, sid, sclass, av, &avd, rc, &ad);
Eric Paris06112162008-11-11 22:02:50 +11001506 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507}
1508
1509/* Check whether a task is allowed to use a system operation. */
1510static int task_has_system(struct task_struct *tsk,
1511 u32 perms)
1512{
David Howells275bb412008-11-14 10:39:19 +11001513 u32 sid = task_sid(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
David Howells275bb412008-11-14 10:39:19 +11001515 return avc_has_perm(sid, SECINITSID_KERNEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 SECCLASS_SYSTEM, perms, NULL);
1517}
1518
1519/* Check whether a task has a particular permission to an inode.
1520 The 'adp' parameter is optional and allows other audit
1521 data to be passed (e.g. the dentry). */
David Howells88e67f32008-11-14 10:39:21 +11001522static int inode_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 struct inode *inode,
1524 u32 perms,
Thomas Liu2bf49692009-07-14 12:14:09 -04001525 struct common_audit_data *adp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 struct inode_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04001528 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11001529 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
David Howellse0e81732009-09-02 09:13:40 +01001531 validate_creds(cred);
1532
Eric Paris828dfe12008-04-17 13:17:49 -04001533 if (unlikely(IS_PRIVATE(inode)))
Stephen Smalleybbaca6c2007-02-14 00:34:16 -08001534 return 0;
1535
David Howells88e67f32008-11-14 10:39:21 +11001536 sid = cred_sid(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 isec = inode->i_security;
1538
1539 if (!adp) {
1540 adp = &ad;
Thomas Liu2bf49692009-07-14 12:14:09 -04001541 COMMON_AUDIT_DATA_INIT(&ad, FS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 ad.u.fs.inode = inode;
1543 }
1544
David Howells275bb412008-11-14 10:39:19 +11001545 return avc_has_perm(sid, isec->sid, isec->sclass, perms, adp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546}
1547
1548/* Same as inode_has_perm, but pass explicit audit data containing
1549 the dentry to help the auditing code to more easily generate the
1550 pathname if needed. */
David Howells88e67f32008-11-14 10:39:21 +11001551static inline int dentry_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 struct vfsmount *mnt,
1553 struct dentry *dentry,
1554 u32 av)
1555{
1556 struct inode *inode = dentry->d_inode;
Thomas Liu2bf49692009-07-14 12:14:09 -04001557 struct common_audit_data ad;
David Howells88e67f32008-11-14 10:39:21 +11001558
Thomas Liu2bf49692009-07-14 12:14:09 -04001559 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08001560 ad.u.fs.path.mnt = mnt;
1561 ad.u.fs.path.dentry = dentry;
David Howells88e67f32008-11-14 10:39:21 +11001562 return inode_has_perm(cred, inode, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563}
1564
1565/* Check whether a task can use an open file descriptor to
1566 access an inode in a given way. Check access to the
1567 descriptor itself, and then use dentry_has_perm to
1568 check a particular permission to the file.
1569 Access to the descriptor is implicitly granted if it
1570 has the same SID as the process. If av is zero, then
1571 access to the file is not checked, e.g. for cases
1572 where only the descriptor is affected like seek. */
David Howells88e67f32008-11-14 10:39:21 +11001573static int file_has_perm(const struct cred *cred,
1574 struct file *file,
1575 u32 av)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 struct file_security_struct *fsec = file->f_security;
Jan Blunck44707fd2008-02-14 19:38:33 -08001578 struct inode *inode = file->f_path.dentry->d_inode;
Thomas Liu2bf49692009-07-14 12:14:09 -04001579 struct common_audit_data ad;
David Howells88e67f32008-11-14 10:39:21 +11001580 u32 sid = cred_sid(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 int rc;
1582
Thomas Liu2bf49692009-07-14 12:14:09 -04001583 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08001584 ad.u.fs.path = file->f_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
David Howells275bb412008-11-14 10:39:19 +11001586 if (sid != fsec->sid) {
1587 rc = avc_has_perm(sid, fsec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 SECCLASS_FD,
1589 FD__USE,
1590 &ad);
1591 if (rc)
David Howells88e67f32008-11-14 10:39:21 +11001592 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 }
1594
1595 /* av is zero if only checking access to the descriptor. */
David Howells88e67f32008-11-14 10:39:21 +11001596 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 if (av)
David Howells88e67f32008-11-14 10:39:21 +11001598 rc = inode_has_perm(cred, inode, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
David Howells88e67f32008-11-14 10:39:21 +11001600out:
1601 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602}
1603
1604/* Check whether a task can create a file. */
1605static int may_create(struct inode *dir,
1606 struct dentry *dentry,
1607 u16 tclass)
1608{
David Howells275bb412008-11-14 10:39:19 +11001609 const struct cred *cred = current_cred();
1610 const struct task_security_struct *tsec = cred->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 struct inode_security_struct *dsec;
1612 struct superblock_security_struct *sbsec;
David Howells275bb412008-11-14 10:39:19 +11001613 u32 sid, newsid;
Thomas Liu2bf49692009-07-14 12:14:09 -04001614 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 int rc;
1616
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 dsec = dir->i_security;
1618 sbsec = dir->i_sb->s_security;
1619
David Howells275bb412008-11-14 10:39:19 +11001620 sid = tsec->sid;
1621 newsid = tsec->create_sid;
1622
Thomas Liu2bf49692009-07-14 12:14:09 -04001623 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08001624 ad.u.fs.path.dentry = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
David Howells275bb412008-11-14 10:39:19 +11001626 rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 DIR__ADD_NAME | DIR__SEARCH,
1628 &ad);
1629 if (rc)
1630 return rc;
1631
David P. Quigleycd895962009-01-16 09:22:04 -05001632 if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
David Howells275bb412008-11-14 10:39:19 +11001633 rc = security_transition_sid(sid, dsec->sid, tclass, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 if (rc)
1635 return rc;
1636 }
1637
David Howells275bb412008-11-14 10:39:19 +11001638 rc = avc_has_perm(sid, newsid, tclass, FILE__CREATE, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 if (rc)
1640 return rc;
1641
1642 return avc_has_perm(newsid, sbsec->sid,
1643 SECCLASS_FILESYSTEM,
1644 FILESYSTEM__ASSOCIATE, &ad);
1645}
1646
Michael LeMay4eb582c2006-06-26 00:24:57 -07001647/* Check whether a task can create a key. */
1648static int may_create_key(u32 ksid,
1649 struct task_struct *ctx)
1650{
David Howells275bb412008-11-14 10:39:19 +11001651 u32 sid = task_sid(ctx);
Michael LeMay4eb582c2006-06-26 00:24:57 -07001652
David Howells275bb412008-11-14 10:39:19 +11001653 return avc_has_perm(sid, ksid, SECCLASS_KEY, KEY__CREATE, NULL);
Michael LeMay4eb582c2006-06-26 00:24:57 -07001654}
1655
Eric Paris828dfe12008-04-17 13:17:49 -04001656#define MAY_LINK 0
1657#define MAY_UNLINK 1
1658#define MAY_RMDIR 2
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
1660/* Check whether a task can link, unlink, or rmdir a file/directory. */
1661static int may_link(struct inode *dir,
1662 struct dentry *dentry,
1663 int kind)
1664
1665{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 struct inode_security_struct *dsec, *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04001667 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11001668 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 u32 av;
1670 int rc;
1671
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 dsec = dir->i_security;
1673 isec = dentry->d_inode->i_security;
1674
Thomas Liu2bf49692009-07-14 12:14:09 -04001675 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08001676 ad.u.fs.path.dentry = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 av = DIR__SEARCH;
1679 av |= (kind ? DIR__REMOVE_NAME : DIR__ADD_NAME);
David Howells275bb412008-11-14 10:39:19 +11001680 rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 if (rc)
1682 return rc;
1683
1684 switch (kind) {
1685 case MAY_LINK:
1686 av = FILE__LINK;
1687 break;
1688 case MAY_UNLINK:
1689 av = FILE__UNLINK;
1690 break;
1691 case MAY_RMDIR:
1692 av = DIR__RMDIR;
1693 break;
1694 default:
Eric Paris744ba352008-04-17 11:52:44 -04001695 printk(KERN_WARNING "SELinux: %s: unrecognized kind %d\n",
1696 __func__, kind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 return 0;
1698 }
1699
David Howells275bb412008-11-14 10:39:19 +11001700 rc = avc_has_perm(sid, isec->sid, isec->sclass, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 return rc;
1702}
1703
1704static inline int may_rename(struct inode *old_dir,
1705 struct dentry *old_dentry,
1706 struct inode *new_dir,
1707 struct dentry *new_dentry)
1708{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 struct inode_security_struct *old_dsec, *new_dsec, *old_isec, *new_isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04001710 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11001711 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 u32 av;
1713 int old_is_dir, new_is_dir;
1714 int rc;
1715
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 old_dsec = old_dir->i_security;
1717 old_isec = old_dentry->d_inode->i_security;
1718 old_is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
1719 new_dsec = new_dir->i_security;
1720
Thomas Liu2bf49692009-07-14 12:14:09 -04001721 COMMON_AUDIT_DATA_INIT(&ad, FS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
Jan Blunck44707fd2008-02-14 19:38:33 -08001723 ad.u.fs.path.dentry = old_dentry;
David Howells275bb412008-11-14 10:39:19 +11001724 rc = avc_has_perm(sid, old_dsec->sid, SECCLASS_DIR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 DIR__REMOVE_NAME | DIR__SEARCH, &ad);
1726 if (rc)
1727 return rc;
David Howells275bb412008-11-14 10:39:19 +11001728 rc = avc_has_perm(sid, old_isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 old_isec->sclass, FILE__RENAME, &ad);
1730 if (rc)
1731 return rc;
1732 if (old_is_dir && new_dir != old_dir) {
David Howells275bb412008-11-14 10:39:19 +11001733 rc = avc_has_perm(sid, old_isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 old_isec->sclass, DIR__REPARENT, &ad);
1735 if (rc)
1736 return rc;
1737 }
1738
Jan Blunck44707fd2008-02-14 19:38:33 -08001739 ad.u.fs.path.dentry = new_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 av = DIR__ADD_NAME | DIR__SEARCH;
1741 if (new_dentry->d_inode)
1742 av |= DIR__REMOVE_NAME;
David Howells275bb412008-11-14 10:39:19 +11001743 rc = avc_has_perm(sid, new_dsec->sid, SECCLASS_DIR, av, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 if (rc)
1745 return rc;
1746 if (new_dentry->d_inode) {
1747 new_isec = new_dentry->d_inode->i_security;
1748 new_is_dir = S_ISDIR(new_dentry->d_inode->i_mode);
David Howells275bb412008-11-14 10:39:19 +11001749 rc = avc_has_perm(sid, new_isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 new_isec->sclass,
1751 (new_is_dir ? DIR__RMDIR : FILE__UNLINK), &ad);
1752 if (rc)
1753 return rc;
1754 }
1755
1756 return 0;
1757}
1758
1759/* Check whether a task can perform a filesystem operation. */
David Howells88e67f32008-11-14 10:39:21 +11001760static int superblock_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 struct super_block *sb,
1762 u32 perms,
Thomas Liu2bf49692009-07-14 12:14:09 -04001763 struct common_audit_data *ad)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 struct superblock_security_struct *sbsec;
David Howells88e67f32008-11-14 10:39:21 +11001766 u32 sid = cred_sid(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 sbsec = sb->s_security;
David Howells275bb412008-11-14 10:39:19 +11001769 return avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM, perms, ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770}
1771
1772/* Convert a Linux mode and permission mask to an access vector. */
1773static inline u32 file_mask_to_av(int mode, int mask)
1774{
1775 u32 av = 0;
1776
1777 if ((mode & S_IFMT) != S_IFDIR) {
1778 if (mask & MAY_EXEC)
1779 av |= FILE__EXECUTE;
1780 if (mask & MAY_READ)
1781 av |= FILE__READ;
1782
1783 if (mask & MAY_APPEND)
1784 av |= FILE__APPEND;
1785 else if (mask & MAY_WRITE)
1786 av |= FILE__WRITE;
1787
1788 } else {
1789 if (mask & MAY_EXEC)
1790 av |= DIR__SEARCH;
1791 if (mask & MAY_WRITE)
1792 av |= DIR__WRITE;
1793 if (mask & MAY_READ)
1794 av |= DIR__READ;
1795 }
1796
1797 return av;
1798}
1799
1800/* Convert a Linux file to an access vector. */
1801static inline u32 file_to_av(struct file *file)
1802{
1803 u32 av = 0;
1804
1805 if (file->f_mode & FMODE_READ)
1806 av |= FILE__READ;
1807 if (file->f_mode & FMODE_WRITE) {
1808 if (file->f_flags & O_APPEND)
1809 av |= FILE__APPEND;
1810 else
1811 av |= FILE__WRITE;
1812 }
Stephen Smalley0794c662008-03-17 08:55:18 -04001813 if (!av) {
1814 /*
1815 * Special file opened with flags 3 for ioctl-only use.
1816 */
1817 av = FILE__IOCTL;
1818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819
1820 return av;
1821}
1822
Eric Paris8b6a5a32008-10-29 17:06:46 -04001823/*
1824 * Convert a file to an access vector and include the correct open
1825 * open permission.
1826 */
1827static inline u32 open_file_to_av(struct file *file)
1828{
1829 u32 av = file_to_av(file);
1830
1831 if (selinux_policycap_openperm) {
1832 mode_t mode = file->f_path.dentry->d_inode->i_mode;
1833 /*
1834 * lnk files and socks do not really have an 'open'
1835 */
1836 if (S_ISREG(mode))
1837 av |= FILE__OPEN;
1838 else if (S_ISCHR(mode))
1839 av |= CHR_FILE__OPEN;
1840 else if (S_ISBLK(mode))
1841 av |= BLK_FILE__OPEN;
1842 else if (S_ISFIFO(mode))
1843 av |= FIFO_FILE__OPEN;
1844 else if (S_ISDIR(mode))
1845 av |= DIR__OPEN;
Eric Paris6a25b272009-03-05 13:40:35 -05001846 else if (S_ISSOCK(mode))
1847 av |= SOCK_FILE__OPEN;
Eric Paris8b6a5a32008-10-29 17:06:46 -04001848 else
1849 printk(KERN_ERR "SELinux: WARNING: inside %s with "
1850 "unknown mode:%o\n", __func__, mode);
1851 }
1852 return av;
1853}
1854
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855/* Hook functions begin here. */
1856
Ingo Molnar9e488582009-05-07 19:26:19 +10001857static int selinux_ptrace_access_check(struct task_struct *child,
David Howells5cd9c582008-08-14 11:37:28 +01001858 unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 int rc;
1861
Ingo Molnar9e488582009-05-07 19:26:19 +10001862 rc = cap_ptrace_access_check(child, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 if (rc)
1864 return rc;
1865
Stephen Smalley006ebb42008-05-19 08:32:49 -04001866 if (mode == PTRACE_MODE_READ) {
David Howells275bb412008-11-14 10:39:19 +11001867 u32 sid = current_sid();
1868 u32 csid = task_sid(child);
1869 return avc_has_perm(sid, csid, SECCLASS_FILE, FILE__READ, NULL);
Stephen Smalley006ebb42008-05-19 08:32:49 -04001870 }
1871
David Howells3b11a1d2008-11-14 10:39:26 +11001872 return current_has_perm(child, PROCESS__PTRACE);
David Howells5cd9c582008-08-14 11:37:28 +01001873}
1874
1875static int selinux_ptrace_traceme(struct task_struct *parent)
1876{
1877 int rc;
1878
Eric Paris200ac532009-02-12 15:01:04 -05001879 rc = cap_ptrace_traceme(parent);
David Howells5cd9c582008-08-14 11:37:28 +01001880 if (rc)
1881 return rc;
1882
1883 return task_has_perm(parent, current, PROCESS__PTRACE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884}
1885
1886static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
Eric Paris828dfe12008-04-17 13:17:49 -04001887 kernel_cap_t *inheritable, kernel_cap_t *permitted)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888{
1889 int error;
1890
David Howells3b11a1d2008-11-14 10:39:26 +11001891 error = current_has_perm(target, PROCESS__GETCAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 if (error)
1893 return error;
1894
Eric Paris200ac532009-02-12 15:01:04 -05001895 return cap_capget(target, effective, inheritable, permitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896}
1897
David Howellsd84f4f92008-11-14 10:39:23 +11001898static int selinux_capset(struct cred *new, const struct cred *old,
1899 const kernel_cap_t *effective,
1900 const kernel_cap_t *inheritable,
1901 const kernel_cap_t *permitted)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902{
1903 int error;
1904
Eric Paris200ac532009-02-12 15:01:04 -05001905 error = cap_capset(new, old,
David Howellsd84f4f92008-11-14 10:39:23 +11001906 effective, inheritable, permitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 if (error)
1908 return error;
1909
David Howellsd84f4f92008-11-14 10:39:23 +11001910 return cred_has_perm(old, new, PROCESS__SETCAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911}
1912
James Morris5626d3e2009-01-30 10:05:06 +11001913/*
1914 * (This comment used to live with the selinux_task_setuid hook,
1915 * which was removed).
1916 *
1917 * Since setuid only affects the current process, and since the SELinux
1918 * controls are not based on the Linux identity attributes, SELinux does not
1919 * need to control this operation. However, SELinux does control the use of
1920 * the CAP_SETUID and CAP_SETGID capabilities using the capable hook.
1921 */
1922
David Howells3699c532009-01-06 22:27:01 +00001923static int selinux_capable(struct task_struct *tsk, const struct cred *cred,
1924 int cap, int audit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925{
1926 int rc;
1927
Eric Paris200ac532009-02-12 15:01:04 -05001928 rc = cap_capable(tsk, cred, cap, audit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 if (rc)
1930 return rc;
1931
David Howells3699c532009-01-06 22:27:01 +00001932 return task_has_capability(tsk, cred, cap, audit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933}
1934
Eric W. Biederman3fbfa982007-02-14 00:34:14 -08001935static int selinux_sysctl_get_sid(ctl_table *table, u16 tclass, u32 *sid)
1936{
1937 int buflen, rc;
1938 char *buffer, *path, *end;
1939
1940 rc = -ENOMEM;
Eric Paris828dfe12008-04-17 13:17:49 -04001941 buffer = (char *)__get_free_page(GFP_KERNEL);
Eric W. Biederman3fbfa982007-02-14 00:34:14 -08001942 if (!buffer)
1943 goto out;
1944
1945 buflen = PAGE_SIZE;
1946 end = buffer+buflen;
1947 *--end = '\0';
1948 buflen--;
1949 path = end-1;
1950 *path = '/';
1951 while (table) {
1952 const char *name = table->procname;
1953 size_t namelen = strlen(name);
1954 buflen -= namelen + 1;
1955 if (buflen < 0)
1956 goto out_free;
1957 end -= namelen;
1958 memcpy(end, name, namelen);
1959 *--end = '/';
1960 path = end;
1961 table = table->parent;
1962 }
Eric W. Biedermanb599fdf2007-02-14 00:34:15 -08001963 buflen -= 4;
1964 if (buflen < 0)
1965 goto out_free;
1966 end -= 4;
1967 memcpy(end, "/sys", 4);
1968 path = end;
Eric W. Biederman3fbfa982007-02-14 00:34:14 -08001969 rc = security_genfs_sid("proc", path, tclass, sid);
1970out_free:
1971 free_page((unsigned long)buffer);
1972out:
1973 return rc;
1974}
1975
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976static int selinux_sysctl(ctl_table *table, int op)
1977{
1978 int error = 0;
1979 u32 av;
David Howells275bb412008-11-14 10:39:19 +11001980 u32 tsid, sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 int rc;
1982
David Howells275bb412008-11-14 10:39:19 +11001983 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984
Eric W. Biederman3fbfa982007-02-14 00:34:14 -08001985 rc = selinux_sysctl_get_sid(table, (op == 0001) ?
1986 SECCLASS_DIR : SECCLASS_FILE, &tsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 if (rc) {
1988 /* Default to the well-defined sysctl SID. */
1989 tsid = SECINITSID_SYSCTL;
1990 }
1991
1992 /* The op values are "defined" in sysctl.c, thereby creating
1993 * a bad coupling between this module and sysctl.c */
Eric Paris828dfe12008-04-17 13:17:49 -04001994 if (op == 001) {
David Howells275bb412008-11-14 10:39:19 +11001995 error = avc_has_perm(sid, tsid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 SECCLASS_DIR, DIR__SEARCH, NULL);
1997 } else {
1998 av = 0;
1999 if (op & 004)
2000 av |= FILE__READ;
2001 if (op & 002)
2002 av |= FILE__WRITE;
2003 if (av)
David Howells275bb412008-11-14 10:39:19 +11002004 error = avc_has_perm(sid, tsid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 SECCLASS_FILE, av, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04002006 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007
2008 return error;
2009}
2010
2011static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
2012{
David Howells88e67f32008-11-14 10:39:21 +11002013 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 int rc = 0;
2015
2016 if (!sb)
2017 return 0;
2018
2019 switch (cmds) {
Eric Paris828dfe12008-04-17 13:17:49 -04002020 case Q_SYNC:
2021 case Q_QUOTAON:
2022 case Q_QUOTAOFF:
2023 case Q_SETINFO:
2024 case Q_SETQUOTA:
David Howells88e67f32008-11-14 10:39:21 +11002025 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAMOD, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04002026 break;
2027 case Q_GETFMT:
2028 case Q_GETINFO:
2029 case Q_GETQUOTA:
David Howells88e67f32008-11-14 10:39:21 +11002030 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAGET, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04002031 break;
2032 default:
2033 rc = 0; /* let the kernel handle invalid cmds */
2034 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 }
2036 return rc;
2037}
2038
2039static int selinux_quota_on(struct dentry *dentry)
2040{
David Howells88e67f32008-11-14 10:39:21 +11002041 const struct cred *cred = current_cred();
2042
2043 return dentry_has_perm(cred, NULL, dentry, FILE__QUOTAON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044}
2045
Kees Cook00234592010-02-03 15:36:43 -08002046static int selinux_syslog(int type, bool from_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047{
2048 int rc;
2049
Kees Cook00234592010-02-03 15:36:43 -08002050 rc = cap_syslog(type, from_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 if (rc)
2052 return rc;
2053
2054 switch (type) {
Kees Cookd78ca3c2010-02-03 15:37:13 -08002055 case SYSLOG_ACTION_READ_ALL: /* Read last kernel messages */
2056 case SYSLOG_ACTION_SIZE_BUFFER: /* Return size of the log buffer */
Eric Paris828dfe12008-04-17 13:17:49 -04002057 rc = task_has_system(current, SYSTEM__SYSLOG_READ);
2058 break;
Kees Cookd78ca3c2010-02-03 15:37:13 -08002059 case SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging to console */
2060 case SYSLOG_ACTION_CONSOLE_ON: /* Enable logging to console */
2061 /* Set level of messages printed to console */
2062 case SYSLOG_ACTION_CONSOLE_LEVEL:
Eric Paris828dfe12008-04-17 13:17:49 -04002063 rc = task_has_system(current, SYSTEM__SYSLOG_CONSOLE);
2064 break;
Kees Cookd78ca3c2010-02-03 15:37:13 -08002065 case SYSLOG_ACTION_CLOSE: /* Close log */
2066 case SYSLOG_ACTION_OPEN: /* Open log */
2067 case SYSLOG_ACTION_READ: /* Read from log */
2068 case SYSLOG_ACTION_READ_CLEAR: /* Read/clear last kernel messages */
2069 case SYSLOG_ACTION_CLEAR: /* Clear ring buffer */
Eric Paris828dfe12008-04-17 13:17:49 -04002070 default:
2071 rc = task_has_system(current, SYSTEM__SYSLOG_MOD);
2072 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 }
2074 return rc;
2075}
2076
2077/*
2078 * Check that a process has enough memory to allocate a new virtual
2079 * mapping. 0 means there is enough memory for the allocation to
2080 * succeed and -ENOMEM implies there is not.
2081 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 * Do not audit the selinux permission check, as this is applied to all
2083 * processes that allocate mappings.
2084 */
Alan Cox34b4e4a2007-08-22 14:01:28 -07002085static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086{
2087 int rc, cap_sys_admin = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088
David Howells3699c532009-01-06 22:27:01 +00002089 rc = selinux_capable(current, current_cred(), CAP_SYS_ADMIN,
2090 SECURITY_CAP_NOAUDIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 if (rc == 0)
2092 cap_sys_admin = 1;
2093
Alan Cox34b4e4a2007-08-22 14:01:28 -07002094 return __vm_enough_memory(mm, pages, cap_sys_admin);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095}
2096
2097/* binprm security operations */
2098
David Howellsa6f76f22008-11-14 10:39:24 +11002099static int selinux_bprm_set_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100{
David Howellsa6f76f22008-11-14 10:39:24 +11002101 const struct task_security_struct *old_tsec;
2102 struct task_security_struct *new_tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 struct inode_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04002104 struct common_audit_data ad;
David Howellsa6f76f22008-11-14 10:39:24 +11002105 struct inode *inode = bprm->file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 int rc;
2107
Eric Paris200ac532009-02-12 15:01:04 -05002108 rc = cap_bprm_set_creds(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 if (rc)
2110 return rc;
2111
David Howellsa6f76f22008-11-14 10:39:24 +11002112 /* SELinux context only depends on initial program or script and not
2113 * the script interpreter */
2114 if (bprm->cred_prepared)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 return 0;
2116
David Howellsa6f76f22008-11-14 10:39:24 +11002117 old_tsec = current_security();
2118 new_tsec = bprm->cred->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 isec = inode->i_security;
2120
2121 /* Default to the current task SID. */
David Howellsa6f76f22008-11-14 10:39:24 +11002122 new_tsec->sid = old_tsec->sid;
2123 new_tsec->osid = old_tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
Michael LeMay28eba5b2006-06-27 02:53:42 -07002125 /* Reset fs, key, and sock SIDs on execve. */
David Howellsa6f76f22008-11-14 10:39:24 +11002126 new_tsec->create_sid = 0;
2127 new_tsec->keycreate_sid = 0;
2128 new_tsec->sockcreate_sid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
David Howellsa6f76f22008-11-14 10:39:24 +11002130 if (old_tsec->exec_sid) {
2131 new_tsec->sid = old_tsec->exec_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 /* Reset exec SID on execve. */
David Howellsa6f76f22008-11-14 10:39:24 +11002133 new_tsec->exec_sid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 } else {
2135 /* Check for a default transition on this program. */
David Howellsa6f76f22008-11-14 10:39:24 +11002136 rc = security_transition_sid(old_tsec->sid, isec->sid,
2137 SECCLASS_PROCESS, &new_tsec->sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 if (rc)
2139 return rc;
2140 }
2141
Thomas Liu2bf49692009-07-14 12:14:09 -04002142 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002143 ad.u.fs.path = bprm->file->f_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Josef Sipek3d5ff522006-12-08 02:37:38 -08002145 if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
David Howellsa6f76f22008-11-14 10:39:24 +11002146 new_tsec->sid = old_tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
David Howellsa6f76f22008-11-14 10:39:24 +11002148 if (new_tsec->sid == old_tsec->sid) {
2149 rc = avc_has_perm(old_tsec->sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 SECCLASS_FILE, FILE__EXECUTE_NO_TRANS, &ad);
2151 if (rc)
2152 return rc;
2153 } else {
2154 /* Check permissions for the transition. */
David Howellsa6f76f22008-11-14 10:39:24 +11002155 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 SECCLASS_PROCESS, PROCESS__TRANSITION, &ad);
2157 if (rc)
2158 return rc;
2159
David Howellsa6f76f22008-11-14 10:39:24 +11002160 rc = avc_has_perm(new_tsec->sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 SECCLASS_FILE, FILE__ENTRYPOINT, &ad);
2162 if (rc)
2163 return rc;
2164
David Howellsa6f76f22008-11-14 10:39:24 +11002165 /* Check for shared state */
2166 if (bprm->unsafe & LSM_UNSAFE_SHARE) {
2167 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2168 SECCLASS_PROCESS, PROCESS__SHARE,
2169 NULL);
2170 if (rc)
2171 return -EPERM;
2172 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173
David Howellsa6f76f22008-11-14 10:39:24 +11002174 /* Make sure that anyone attempting to ptrace over a task that
2175 * changes its SID has the appropriate permit */
2176 if (bprm->unsafe &
2177 (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
2178 struct task_struct *tracer;
2179 struct task_security_struct *sec;
2180 u32 ptsid = 0;
2181
2182 rcu_read_lock();
2183 tracer = tracehook_tracer_task(current);
2184 if (likely(tracer != NULL)) {
2185 sec = __task_cred(tracer)->security;
2186 ptsid = sec->sid;
2187 }
2188 rcu_read_unlock();
2189
2190 if (ptsid != 0) {
2191 rc = avc_has_perm(ptsid, new_tsec->sid,
2192 SECCLASS_PROCESS,
2193 PROCESS__PTRACE, NULL);
2194 if (rc)
2195 return -EPERM;
2196 }
2197 }
2198
2199 /* Clear any possibly unsafe personality bits on exec: */
2200 bprm->per_clear |= PER_CLEAR_ON_SETID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 }
2202
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 return 0;
2204}
2205
Eric Paris828dfe12008-04-17 13:17:49 -04002206static int selinux_bprm_secureexec(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207{
David Howells275bb412008-11-14 10:39:19 +11002208 const struct cred *cred = current_cred();
2209 const struct task_security_struct *tsec = cred->security;
2210 u32 sid, osid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 int atsecure = 0;
2212
David Howells275bb412008-11-14 10:39:19 +11002213 sid = tsec->sid;
2214 osid = tsec->osid;
2215
2216 if (osid != sid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 /* Enable secure mode for SIDs transitions unless
2218 the noatsecure permission is granted between
2219 the two SIDs, i.e. ahp returns 0. */
David Howells275bb412008-11-14 10:39:19 +11002220 atsecure = avc_has_perm(osid, sid,
David Howellsa6f76f22008-11-14 10:39:24 +11002221 SECCLASS_PROCESS,
2222 PROCESS__NOATSECURE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 }
2224
Eric Paris200ac532009-02-12 15:01:04 -05002225 return (atsecure || cap_bprm_secureexec(bprm));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226}
2227
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228extern struct vfsmount *selinuxfs_mount;
2229extern struct dentry *selinux_null;
2230
2231/* Derived from fs/exec.c:flush_old_files. */
David Howells745ca242008-11-14 10:39:22 +11002232static inline void flush_unauthorized_files(const struct cred *cred,
2233 struct files_struct *files)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234{
Thomas Liu2bf49692009-07-14 12:14:09 -04002235 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 struct file *file, *devnull = NULL;
Stephen Smalleyb20c8122006-09-25 23:32:03 -07002237 struct tty_struct *tty;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002238 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 long j = -1;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002240 int drop_tty = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002242 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 if (tty) {
2244 file_list_lock();
Eric Paris37dd0bd2008-10-31 17:40:00 -04002245 if (!list_empty(&tty->tty_files)) {
2246 struct inode *inode;
2247
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 /* Revalidate access to controlling tty.
2249 Use inode_has_perm on the tty inode directly rather
2250 than using file_has_perm, as this particular open
2251 file may belong to another process and we are only
2252 interested in the inode-based check here. */
Eric Paris37dd0bd2008-10-31 17:40:00 -04002253 file = list_first_entry(&tty->tty_files, struct file, f_u.fu_list);
2254 inode = file->f_path.dentry->d_inode;
David Howells88e67f32008-11-14 10:39:21 +11002255 if (inode_has_perm(cred, inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 FILE__READ | FILE__WRITE, NULL)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002257 drop_tty = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 }
2259 }
2260 file_list_unlock();
Alan Cox452a00d2008-10-13 10:39:13 +01002261 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 }
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07002263 /* Reset controlling tty. */
2264 if (drop_tty)
2265 no_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266
2267 /* Revalidate access to inherited open files. */
2268
Thomas Liu2bf49692009-07-14 12:14:09 -04002269 COMMON_AUDIT_DATA_INIT(&ad, FS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270
2271 spin_lock(&files->file_lock);
2272 for (;;) {
2273 unsigned long set, i;
2274 int fd;
2275
2276 j++;
2277 i = j * __NFDBITS;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002278 fdt = files_fdtable(files);
Vadim Lobanovbbea9f62006-12-10 02:21:12 -08002279 if (i >= fdt->max_fds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 break;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002281 set = fdt->open_fds->fds_bits[j];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 if (!set)
2283 continue;
2284 spin_unlock(&files->file_lock);
Eric Paris828dfe12008-04-17 13:17:49 -04002285 for ( ; set ; i++, set >>= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 if (set & 1) {
2287 file = fget(i);
2288 if (!file)
2289 continue;
David Howells88e67f32008-11-14 10:39:21 +11002290 if (file_has_perm(cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 file,
2292 file_to_av(file))) {
2293 sys_close(i);
2294 fd = get_unused_fd();
2295 if (fd != i) {
2296 if (fd >= 0)
2297 put_unused_fd(fd);
2298 fput(file);
2299 continue;
2300 }
2301 if (devnull) {
Nick Piggin095975d2006-01-08 01:02:19 -08002302 get_file(devnull);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 } else {
David Howells745ca242008-11-14 10:39:22 +11002304 devnull = dentry_open(
2305 dget(selinux_null),
2306 mntget(selinuxfs_mount),
2307 O_RDWR, cred);
Akinobu Mitafc5d81e2006-11-27 15:16:48 +09002308 if (IS_ERR(devnull)) {
2309 devnull = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 put_unused_fd(fd);
2311 fput(file);
2312 continue;
2313 }
2314 }
2315 fd_install(fd, devnull);
2316 }
2317 fput(file);
2318 }
2319 }
2320 spin_lock(&files->file_lock);
2321
2322 }
2323 spin_unlock(&files->file_lock);
2324}
2325
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326/*
David Howellsa6f76f22008-11-14 10:39:24 +11002327 * Prepare a process for imminent new credential changes due to exec
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 */
David Howellsa6f76f22008-11-14 10:39:24 +11002329static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330{
David Howellsa6f76f22008-11-14 10:39:24 +11002331 struct task_security_struct *new_tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 struct rlimit *rlim, *initrlim;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 int rc, i;
2334
David Howellsa6f76f22008-11-14 10:39:24 +11002335 new_tsec = bprm->cred->security;
2336 if (new_tsec->sid == new_tsec->osid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 return;
2338
2339 /* Close files for which the new task SID is not authorized. */
David Howellsa6f76f22008-11-14 10:39:24 +11002340 flush_unauthorized_files(bprm->cred, current->files);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341
David Howellsa6f76f22008-11-14 10:39:24 +11002342 /* Always clear parent death signal on SID transitions. */
2343 current->pdeath_signal = 0;
2344
2345 /* Check whether the new SID can inherit resource limits from the old
2346 * SID. If not, reset all soft limits to the lower of the current
2347 * task's hard limit and the init task's soft limit.
2348 *
2349 * Note that the setting of hard limits (even to lower them) can be
2350 * controlled by the setrlimit check. The inclusion of the init task's
2351 * soft limit into the computation is to avoid resetting soft limits
2352 * higher than the default soft limit for cases where the default is
2353 * lower than the hard limit, e.g. RLIMIT_CORE or RLIMIT_STACK.
2354 */
2355 rc = avc_has_perm(new_tsec->osid, new_tsec->sid, SECCLASS_PROCESS,
2356 PROCESS__RLIMITINH, NULL);
2357 if (rc) {
2358 for (i = 0; i < RLIM_NLIMITS; i++) {
2359 rlim = current->signal->rlim + i;
2360 initrlim = init_task.signal->rlim + i;
2361 rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
2362 }
Jiri Slaby17740d82009-08-28 10:47:16 +02002363 update_rlimit_cpu(current->signal->rlim[RLIMIT_CPU].rlim_cur);
David Howellsa6f76f22008-11-14 10:39:24 +11002364 }
2365}
2366
2367/*
2368 * Clean up the process immediately after the installation of new credentials
2369 * due to exec
2370 */
2371static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
2372{
2373 const struct task_security_struct *tsec = current_security();
2374 struct itimerval itimer;
David Howellsa6f76f22008-11-14 10:39:24 +11002375 u32 osid, sid;
2376 int rc, i;
David Howellsa6f76f22008-11-14 10:39:24 +11002377
David Howellsa6f76f22008-11-14 10:39:24 +11002378 osid = tsec->osid;
2379 sid = tsec->sid;
2380
2381 if (sid == osid)
2382 return;
2383
2384 /* Check whether the new SID can inherit signal state from the old SID.
2385 * If not, clear itimers to avoid subsequent signal generation and
2386 * flush and unblock signals.
2387 *
2388 * This must occur _after_ the task SID has been updated so that any
2389 * kill done after the flush will be checked against the new SID.
2390 */
2391 rc = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__SIGINH, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 if (rc) {
2393 memset(&itimer, 0, sizeof itimer);
2394 for (i = 0; i < 3; i++)
2395 do_setitimer(i, &itimer, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 spin_lock_irq(&current->sighand->siglock);
David Howells3bcac022009-04-29 13:45:05 +01002397 if (!(current->signal->flags & SIGNAL_GROUP_EXIT)) {
2398 __flush_signals(current);
2399 flush_signal_handlers(current, 1);
2400 sigemptyset(&current->blocked);
2401 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 spin_unlock_irq(&current->sighand->siglock);
2403 }
2404
David Howellsa6f76f22008-11-14 10:39:24 +11002405 /* Wake up the parent if it is waiting so that it can recheck
2406 * wait permission to the new task SID. */
Oleg Nesterovecd6de32009-04-29 16:02:24 +02002407 read_lock(&tasklist_lock);
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07002408 __wake_up_parent(current, current->real_parent);
Oleg Nesterovecd6de32009-04-29 16:02:24 +02002409 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410}
2411
2412/* superblock security operations */
2413
2414static int selinux_sb_alloc_security(struct super_block *sb)
2415{
2416 return superblock_alloc_security(sb);
2417}
2418
2419static void selinux_sb_free_security(struct super_block *sb)
2420{
2421 superblock_free_security(sb);
2422}
2423
2424static inline int match_prefix(char *prefix, int plen, char *option, int olen)
2425{
2426 if (plen > olen)
2427 return 0;
2428
2429 return !memcmp(prefix, option, plen);
2430}
2431
2432static inline int selinux_option(char *option, int len)
2433{
Eric Paris832cbd92008-04-01 13:24:09 -04002434 return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) ||
2435 match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) ||
2436 match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) ||
David P. Quigley11689d42009-01-16 09:22:03 -05002437 match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) ||
2438 match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439}
2440
2441static inline void take_option(char **to, char *from, int *first, int len)
2442{
2443 if (!*first) {
2444 **to = ',';
2445 *to += 1;
Cory Olmo3528a952006-09-29 01:58:44 -07002446 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 *first = 0;
2448 memcpy(*to, from, len);
2449 *to += len;
2450}
2451
Eric Paris828dfe12008-04-17 13:17:49 -04002452static inline void take_selinux_option(char **to, char *from, int *first,
2453 int len)
Cory Olmo3528a952006-09-29 01:58:44 -07002454{
2455 int current_size = 0;
2456
2457 if (!*first) {
2458 **to = '|';
2459 *to += 1;
Eric Paris828dfe12008-04-17 13:17:49 -04002460 } else
Cory Olmo3528a952006-09-29 01:58:44 -07002461 *first = 0;
2462
2463 while (current_size < len) {
2464 if (*from != '"') {
2465 **to = *from;
2466 *to += 1;
2467 }
2468 from += 1;
2469 current_size += 1;
2470 }
2471}
2472
Eric Parise0007522008-03-05 10:31:54 -05002473static int selinux_sb_copy_data(char *orig, char *copy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474{
2475 int fnosec, fsec, rc = 0;
2476 char *in_save, *in_curr, *in_end;
2477 char *sec_curr, *nosec_save, *nosec;
Cory Olmo3528a952006-09-29 01:58:44 -07002478 int open_quote = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479
2480 in_curr = orig;
2481 sec_curr = copy;
2482
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 nosec = (char *)get_zeroed_page(GFP_KERNEL);
2484 if (!nosec) {
2485 rc = -ENOMEM;
2486 goto out;
2487 }
2488
2489 nosec_save = nosec;
2490 fnosec = fsec = 1;
2491 in_save = in_end = orig;
2492
2493 do {
Cory Olmo3528a952006-09-29 01:58:44 -07002494 if (*in_end == '"')
2495 open_quote = !open_quote;
2496 if ((*in_end == ',' && open_quote == 0) ||
2497 *in_end == '\0') {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 int len = in_end - in_curr;
2499
2500 if (selinux_option(in_curr, len))
Cory Olmo3528a952006-09-29 01:58:44 -07002501 take_selinux_option(&sec_curr, in_curr, &fsec, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502 else
2503 take_option(&nosec, in_curr, &fnosec, len);
2504
2505 in_curr = in_end + 1;
2506 }
2507 } while (*in_end++);
2508
Eric Paris6931dfc2005-06-30 02:58:51 -07002509 strcpy(in_save, nosec_save);
Gerald Schaeferda3caa22005-06-21 17:15:18 -07002510 free_page((unsigned long)nosec_save);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511out:
2512 return rc;
2513}
2514
James Morris12204e22008-12-19 10:44:42 +11002515static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516{
David Howells88e67f32008-11-14 10:39:21 +11002517 const struct cred *cred = current_cred();
Thomas Liu2bf49692009-07-14 12:14:09 -04002518 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519 int rc;
2520
2521 rc = superblock_doinit(sb, data);
2522 if (rc)
2523 return rc;
2524
James Morris74192242008-12-19 11:41:10 +11002525 /* Allow all mounts performed by the kernel */
2526 if (flags & MS_KERNMOUNT)
2527 return 0;
2528
Thomas Liu2bf49692009-07-14 12:14:09 -04002529 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002530 ad.u.fs.path.dentry = sb->s_root;
David Howells88e67f32008-11-14 10:39:21 +11002531 return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532}
2533
David Howells726c3342006-06-23 02:02:58 -07002534static int selinux_sb_statfs(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535{
David Howells88e67f32008-11-14 10:39:21 +11002536 const struct cred *cred = current_cred();
Thomas Liu2bf49692009-07-14 12:14:09 -04002537 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538
Thomas Liu2bf49692009-07-14 12:14:09 -04002539 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002540 ad.u.fs.path.dentry = dentry->d_sb->s_root;
David Howells88e67f32008-11-14 10:39:21 +11002541 return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542}
2543
Eric Paris828dfe12008-04-17 13:17:49 -04002544static int selinux_mount(char *dev_name,
Al Virob5266eb2008-03-22 17:48:24 -04002545 struct path *path,
Eric Paris828dfe12008-04-17 13:17:49 -04002546 char *type,
2547 unsigned long flags,
2548 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549{
David Howells88e67f32008-11-14 10:39:21 +11002550 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551
2552 if (flags & MS_REMOUNT)
David Howells88e67f32008-11-14 10:39:21 +11002553 return superblock_has_perm(cred, path->mnt->mnt_sb,
Eric Paris828dfe12008-04-17 13:17:49 -04002554 FILESYSTEM__REMOUNT, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 else
David Howells88e67f32008-11-14 10:39:21 +11002556 return dentry_has_perm(cred, path->mnt, path->dentry,
Eric Paris828dfe12008-04-17 13:17:49 -04002557 FILE__MOUNTON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558}
2559
2560static int selinux_umount(struct vfsmount *mnt, int flags)
2561{
David Howells88e67f32008-11-14 10:39:21 +11002562 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563
David Howells88e67f32008-11-14 10:39:21 +11002564 return superblock_has_perm(cred, mnt->mnt_sb,
Eric Paris828dfe12008-04-17 13:17:49 -04002565 FILESYSTEM__UNMOUNT, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566}
2567
2568/* inode security operations */
2569
2570static int selinux_inode_alloc_security(struct inode *inode)
2571{
2572 return inode_alloc_security(inode);
2573}
2574
2575static void selinux_inode_free_security(struct inode *inode)
2576{
2577 inode_free_security(inode);
2578}
2579
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002580static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
2581 char **name, void **value,
2582 size_t *len)
2583{
David Howells275bb412008-11-14 10:39:19 +11002584 const struct cred *cred = current_cred();
2585 const struct task_security_struct *tsec = cred->security;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002586 struct inode_security_struct *dsec;
2587 struct superblock_security_struct *sbsec;
David Howells275bb412008-11-14 10:39:19 +11002588 u32 sid, newsid, clen;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002589 int rc;
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002590 char *namep = NULL, *context;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002591
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002592 dsec = dir->i_security;
2593 sbsec = dir->i_sb->s_security;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002594
David Howells275bb412008-11-14 10:39:19 +11002595 sid = tsec->sid;
2596 newsid = tsec->create_sid;
2597
David P. Quigleycd895962009-01-16 09:22:04 -05002598 if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
David Howells275bb412008-11-14 10:39:19 +11002599 rc = security_transition_sid(sid, dsec->sid,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002600 inode_mode_to_security_class(inode->i_mode),
2601 &newsid);
2602 if (rc) {
2603 printk(KERN_WARNING "%s: "
2604 "security_transition_sid failed, rc=%d (dev=%s "
2605 "ino=%ld)\n",
Harvey Harrisondd6f9532008-03-06 10:03:59 +11002606 __func__,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002607 -rc, inode->i_sb->s_id, inode->i_ino);
2608 return rc;
2609 }
2610 }
2611
Eric Paris296fddf2006-09-25 23:32:00 -07002612 /* Possibly defer initialization to selinux_complete_init. */
David P. Quigley0d90a7e2009-01-16 09:22:02 -05002613 if (sbsec->flags & SE_SBINITIALIZED) {
Eric Paris296fddf2006-09-25 23:32:00 -07002614 struct inode_security_struct *isec = inode->i_security;
2615 isec->sclass = inode_mode_to_security_class(inode->i_mode);
2616 isec->sid = newsid;
2617 isec->initialized = 1;
2618 }
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002619
David P. Quigleycd895962009-01-16 09:22:04 -05002620 if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
Stephen Smalley25a74f32005-11-08 21:34:33 -08002621 return -EOPNOTSUPP;
2622
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002623 if (name) {
Josef Bacika02fe132008-04-04 09:35:05 +11002624 namep = kstrdup(XATTR_SELINUX_SUFFIX, GFP_NOFS);
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002625 if (!namep)
2626 return -ENOMEM;
2627 *name = namep;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002628 }
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002629
2630 if (value && len) {
Stephen Smalley12b29f32008-05-07 13:03:20 -04002631 rc = security_sid_to_context_force(newsid, &context, &clen);
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002632 if (rc) {
2633 kfree(namep);
2634 return rc;
2635 }
2636 *value = context;
2637 *len = clen;
2638 }
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002639
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002640 return 0;
2641}
2642
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643static int selinux_inode_create(struct inode *dir, struct dentry *dentry, int mask)
2644{
2645 return may_create(dir, dentry, SECCLASS_FILE);
2646}
2647
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2649{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 return may_link(dir, old_dentry, MAY_LINK);
2651}
2652
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry)
2654{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 return may_link(dir, dentry, MAY_UNLINK);
2656}
2657
2658static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name)
2659{
2660 return may_create(dir, dentry, SECCLASS_LNK_FILE);
2661}
2662
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, int mask)
2664{
2665 return may_create(dir, dentry, SECCLASS_DIR);
2666}
2667
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry)
2669{
2670 return may_link(dir, dentry, MAY_RMDIR);
2671}
2672
2673static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2674{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 return may_create(dir, dentry, inode_mode_to_security_class(mode));
2676}
2677
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry,
Eric Paris828dfe12008-04-17 13:17:49 -04002679 struct inode *new_inode, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680{
2681 return may_rename(old_inode, old_dentry, new_inode, new_dentry);
2682}
2683
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684static int selinux_inode_readlink(struct dentry *dentry)
2685{
David Howells88e67f32008-11-14 10:39:21 +11002686 const struct cred *cred = current_cred();
2687
2688 return dentry_has_perm(cred, NULL, dentry, FILE__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689}
2690
2691static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *nameidata)
2692{
David Howells88e67f32008-11-14 10:39:21 +11002693 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694
David Howells88e67f32008-11-14 10:39:21 +11002695 return dentry_has_perm(cred, NULL, dentry, FILE__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696}
2697
Al Virob77b0642008-07-17 09:37:02 -04002698static int selinux_inode_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699{
David Howells88e67f32008-11-14 10:39:21 +11002700 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701
2702 if (!mask) {
2703 /* No permission to check. Existence test. */
2704 return 0;
2705 }
2706
David Howells88e67f32008-11-14 10:39:21 +11002707 return inode_has_perm(cred, inode,
Eric Paris8b6a5a32008-10-29 17:06:46 -04002708 file_mask_to_av(inode->i_mode, mask), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709}
2710
2711static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
2712{
David Howells88e67f32008-11-14 10:39:21 +11002713 const struct cred *cred = current_cred();
Amerigo Wangbc6a6002009-08-20 19:29:02 -07002714 unsigned int ia_valid = iattr->ia_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715
Amerigo Wangbc6a6002009-08-20 19:29:02 -07002716 /* ATTR_FORCE is just used for ATTR_KILL_S[UG]ID. */
2717 if (ia_valid & ATTR_FORCE) {
2718 ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_MODE |
2719 ATTR_FORCE);
2720 if (!ia_valid)
2721 return 0;
2722 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723
Amerigo Wangbc6a6002009-08-20 19:29:02 -07002724 if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID |
2725 ATTR_ATIME_SET | ATTR_MTIME_SET | ATTR_TIMES_SET))
David Howells88e67f32008-11-14 10:39:21 +11002726 return dentry_has_perm(cred, NULL, dentry, FILE__SETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727
David Howells88e67f32008-11-14 10:39:21 +11002728 return dentry_has_perm(cred, NULL, dentry, FILE__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729}
2730
2731static int selinux_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
2732{
David Howells88e67f32008-11-14 10:39:21 +11002733 const struct cred *cred = current_cred();
2734
2735 return dentry_has_perm(cred, mnt, dentry, 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. */
David Howells88e67f32008-11-14 10:39:21 +11002756 return dentry_has_perm(cred, NULL, 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;
David Howells275bb412008-11-14 10:39:19 +11002766 u32 newsid, sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 int rc = 0;
2768
Serge E. Hallynb5376772007-10-16 23:31:36 -07002769 if (strcmp(name, XATTR_NAME_SELINUX))
2770 return selinux_inode_setotherxattr(dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771
2772 sbsec = inode->i_sb->s_security;
David P. Quigleycd895962009-01-16 09:22:04 -05002773 if (!(sbsec->flags & SE_SBLABELSUPP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 return -EOPNOTSUPP;
2775
Satyam Sharma3bd858a2007-07-17 15:00:08 +05302776 if (!is_owner_or_cap(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777 return -EPERM;
2778
Thomas Liu2bf49692009-07-14 12:14:09 -04002779 COMMON_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002780 ad.u.fs.path.dentry = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781
David Howells275bb412008-11-14 10:39:19 +11002782 rc = avc_has_perm(sid, isec->sid, isec->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 FILE__RELABELFROM, &ad);
2784 if (rc)
2785 return rc;
2786
2787 rc = security_context_to_sid(value, size, &newsid);
Stephen Smalley12b29f32008-05-07 13:03:20 -04002788 if (rc == -EINVAL) {
2789 if (!capable(CAP_MAC_ADMIN))
2790 return rc;
2791 rc = security_context_to_sid_force(value, size, &newsid);
2792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 if (rc)
2794 return rc;
2795
David Howells275bb412008-11-14 10:39:19 +11002796 rc = avc_has_perm(sid, newsid, isec->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 FILE__RELABELTO, &ad);
2798 if (rc)
2799 return rc;
2800
David Howells275bb412008-11-14 10:39:19 +11002801 rc = security_validate_transition(isec->sid, newsid, sid,
Eric Paris828dfe12008-04-17 13:17:49 -04002802 isec->sclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 if (rc)
2804 return rc;
2805
2806 return avc_has_perm(newsid,
2807 sbsec->sid,
2808 SECCLASS_FILESYSTEM,
2809 FILESYSTEM__ASSOCIATE,
2810 &ad);
2811}
2812
David Howells8f0cfa52008-04-29 00:59:41 -07002813static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
Eric Parisf5269712008-05-14 11:27:45 -04002814 const void *value, size_t size,
David Howells8f0cfa52008-04-29 00:59:41 -07002815 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816{
2817 struct inode *inode = dentry->d_inode;
2818 struct inode_security_struct *isec = inode->i_security;
2819 u32 newsid;
2820 int rc;
2821
2822 if (strcmp(name, XATTR_NAME_SELINUX)) {
2823 /* Not an attribute we recognize, so nothing to do. */
2824 return;
2825 }
2826
Stephen Smalley12b29f32008-05-07 13:03:20 -04002827 rc = security_context_to_sid_force(value, size, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 if (rc) {
Stephen Smalley12b29f32008-05-07 13:03:20 -04002829 printk(KERN_ERR "SELinux: unable to map context to SID"
2830 "for (%s, %lu), rc=%d\n",
2831 inode->i_sb->s_id, inode->i_ino, -rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 return;
2833 }
2834
2835 isec->sid = newsid;
2836 return;
2837}
2838
David Howells8f0cfa52008-04-29 00:59:41 -07002839static int selinux_inode_getxattr(struct dentry *dentry, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840{
David Howells88e67f32008-11-14 10:39:21 +11002841 const struct cred *cred = current_cred();
2842
2843 return dentry_has_perm(cred, NULL, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844}
2845
Eric Paris828dfe12008-04-17 13:17:49 -04002846static int selinux_inode_listxattr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847{
David Howells88e67f32008-11-14 10:39:21 +11002848 const struct cred *cred = current_cred();
2849
2850 return dentry_has_perm(cred, NULL, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851}
2852
David Howells8f0cfa52008-04-29 00:59:41 -07002853static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854{
Serge E. Hallynb5376772007-10-16 23:31:36 -07002855 if (strcmp(name, XATTR_NAME_SELINUX))
2856 return selinux_inode_setotherxattr(dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857
2858 /* No one is allowed to remove a SELinux security label.
2859 You can change the label, but all data must be labeled. */
2860 return -EACCES;
2861}
2862
James Morrisd381d8a2005-10-30 14:59:22 -08002863/*
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002864 * Copy the inode security context value to the user.
James Morrisd381d8a2005-10-30 14:59:22 -08002865 *
2866 * Permission check is handled by selinux_inode_getxattr hook.
2867 */
David P. Quigley42492592008-02-04 22:29:39 -08002868static int selinux_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869{
David P. Quigley42492592008-02-04 22:29:39 -08002870 u32 size;
2871 int error;
2872 char *context = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 struct inode_security_struct *isec = inode->i_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874
Dustin Kirkland8c8570f2005-11-03 17:15:16 +00002875 if (strcmp(name, XATTR_SELINUX_SUFFIX))
2876 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002878 /*
2879 * If the caller has CAP_MAC_ADMIN, then get the raw context
2880 * value even if it is not defined by current policy; otherwise,
2881 * use the in-core value under current policy.
2882 * Use the non-auditing forms of the permission checks since
2883 * getxattr may be called by unprivileged processes commonly
2884 * and lack of permission just means that we fall back to the
2885 * in-core context value, not a denial.
2886 */
David Howells3699c532009-01-06 22:27:01 +00002887 error = selinux_capable(current, current_cred(), CAP_MAC_ADMIN,
2888 SECURITY_CAP_NOAUDIT);
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002889 if (!error)
2890 error = security_sid_to_context_force(isec->sid, &context,
2891 &size);
2892 else
2893 error = security_sid_to_context(isec->sid, &context, &size);
David P. Quigley42492592008-02-04 22:29:39 -08002894 if (error)
2895 return error;
2896 error = size;
2897 if (alloc) {
2898 *buffer = context;
2899 goto out_nofree;
2900 }
2901 kfree(context);
2902out_nofree:
2903 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904}
2905
2906static int selinux_inode_setsecurity(struct inode *inode, const char *name,
Eric Paris828dfe12008-04-17 13:17:49 -04002907 const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908{
2909 struct inode_security_struct *isec = inode->i_security;
2910 u32 newsid;
2911 int rc;
2912
2913 if (strcmp(name, XATTR_SELINUX_SUFFIX))
2914 return -EOPNOTSUPP;
2915
2916 if (!value || !size)
2917 return -EACCES;
2918
Eric Paris828dfe12008-04-17 13:17:49 -04002919 rc = security_context_to_sid((void *)value, size, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 if (rc)
2921 return rc;
2922
2923 isec->sid = newsid;
David P. Quigleyddd29ec2009-09-09 14:25:37 -04002924 isec->initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925 return 0;
2926}
2927
2928static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
2929{
2930 const int len = sizeof(XATTR_NAME_SELINUX);
2931 if (buffer && len <= buffer_size)
2932 memcpy(buffer, XATTR_NAME_SELINUX, len);
2933 return len;
2934}
2935
Ahmed S. Darwish713a04ae2008-03-01 21:52:30 +02002936static void selinux_inode_getsecid(const struct inode *inode, u32 *secid)
2937{
2938 struct inode_security_struct *isec = inode->i_security;
2939 *secid = isec->sid;
2940}
2941
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942/* file security operations */
2943
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002944static int selinux_revalidate_file_permission(struct file *file, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945{
David Howells88e67f32008-11-14 10:39:21 +11002946 const struct cred *cred = current_cred();
Josef Sipek3d5ff522006-12-08 02:37:38 -08002947 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 /* file_mask_to_av won't add FILE__WRITE if MAY_APPEND is set */
2950 if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE))
2951 mask |= MAY_APPEND;
2952
Paul Moore389fb8002009-03-27 17:10:34 -04002953 return file_has_perm(cred, file,
2954 file_mask_to_av(inode->i_mode, mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955}
2956
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002957static int selinux_file_permission(struct file *file, int mask)
2958{
Stephen Smalley20dda182009-06-22 14:54:53 -04002959 struct inode *inode = file->f_path.dentry->d_inode;
2960 struct file_security_struct *fsec = file->f_security;
2961 struct inode_security_struct *isec = inode->i_security;
2962 u32 sid = current_sid();
2963
Paul Moore389fb8002009-03-27 17:10:34 -04002964 if (!mask)
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002965 /* No permission to check. Existence test. */
2966 return 0;
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002967
Stephen Smalley20dda182009-06-22 14:54:53 -04002968 if (sid == fsec->sid && fsec->isid == isec->sid &&
2969 fsec->pseqno == avc_policy_seqno())
2970 /* No change since dentry_open check. */
2971 return 0;
2972
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002973 return selinux_revalidate_file_permission(file, mask);
2974}
2975
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976static int selinux_file_alloc_security(struct file *file)
2977{
2978 return file_alloc_security(file);
2979}
2980
2981static void selinux_file_free_security(struct file *file)
2982{
2983 file_free_security(file);
2984}
2985
2986static int selinux_file_ioctl(struct file *file, unsigned int cmd,
2987 unsigned long arg)
2988{
David Howells88e67f32008-11-14 10:39:21 +11002989 const struct cred *cred = current_cred();
Stephen Smalley242631c2008-06-05 09:21:28 -04002990 u32 av = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991
Stephen Smalley242631c2008-06-05 09:21:28 -04002992 if (_IOC_DIR(cmd) & _IOC_WRITE)
2993 av |= FILE__WRITE;
2994 if (_IOC_DIR(cmd) & _IOC_READ)
2995 av |= FILE__READ;
2996 if (!av)
2997 av = FILE__IOCTL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998
David Howells88e67f32008-11-14 10:39:21 +11002999 return file_has_perm(cred, file, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000}
3001
3002static int file_map_prot_check(struct file *file, unsigned long prot, int shared)
3003{
David Howells88e67f32008-11-14 10:39:21 +11003004 const struct cred *cred = current_cred();
David Howellsd84f4f92008-11-14 10:39:23 +11003005 int rc = 0;
David Howells88e67f32008-11-14 10:39:21 +11003006
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007#ifndef CONFIG_PPC32
3008 if ((prot & PROT_EXEC) && (!file || (!shared && (prot & PROT_WRITE)))) {
3009 /*
3010 * We are making executable an anonymous mapping or a
3011 * private file mapping that will also be writable.
3012 * This has an additional check.
3013 */
David Howellsd84f4f92008-11-14 10:39:23 +11003014 rc = cred_has_perm(cred, cred, PROCESS__EXECMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 if (rc)
David Howellsd84f4f92008-11-14 10:39:23 +11003016 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 }
3018#endif
3019
3020 if (file) {
3021 /* read access is always possible with a mapping */
3022 u32 av = FILE__READ;
3023
3024 /* write access only matters if the mapping is shared */
3025 if (shared && (prot & PROT_WRITE))
3026 av |= FILE__WRITE;
3027
3028 if (prot & PROT_EXEC)
3029 av |= FILE__EXECUTE;
3030
David Howells88e67f32008-11-14 10:39:21 +11003031 return file_has_perm(cred, file, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 }
David Howellsd84f4f92008-11-14 10:39:23 +11003033
3034error:
3035 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036}
3037
3038static int selinux_file_mmap(struct file *file, unsigned long reqprot,
Eric Parised032182007-06-28 15:55:21 -04003039 unsigned long prot, unsigned long flags,
3040 unsigned long addr, unsigned long addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041{
Eric Parised032182007-06-28 15:55:21 -04003042 int rc = 0;
David Howells275bb412008-11-14 10:39:19 +11003043 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044
Eric Paris84336d1a2009-07-31 12:54:05 -04003045 /*
3046 * notice that we are intentionally putting the SELinux check before
3047 * the secondary cap_file_mmap check. This is such a likely attempt
3048 * at bad behaviour/exploit that we always want to get the AVC, even
3049 * if DAC would have also denied the operation.
3050 */
Eric Parisa2551df2009-07-31 12:54:11 -04003051 if (addr < CONFIG_LSM_MMAP_MIN_ADDR) {
Eric Parised032182007-06-28 15:55:21 -04003052 rc = avc_has_perm(sid, sid, SECCLASS_MEMPROTECT,
3053 MEMPROTECT__MMAP_ZERO, NULL);
Eric Paris84336d1a2009-07-31 12:54:05 -04003054 if (rc)
3055 return rc;
3056 }
3057
3058 /* do DAC check on address space usage */
3059 rc = cap_file_mmap(file, reqprot, prot, flags, addr, addr_only);
Eric Parised032182007-06-28 15:55:21 -04003060 if (rc || addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061 return rc;
3062
3063 if (selinux_checkreqprot)
3064 prot = reqprot;
3065
3066 return file_map_prot_check(file, prot,
3067 (flags & MAP_TYPE) == MAP_SHARED);
3068}
3069
3070static int selinux_file_mprotect(struct vm_area_struct *vma,
3071 unsigned long reqprot,
3072 unsigned long prot)
3073{
David Howells88e67f32008-11-14 10:39:21 +11003074 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075
3076 if (selinux_checkreqprot)
3077 prot = reqprot;
3078
3079#ifndef CONFIG_PPC32
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003080 if ((prot & PROT_EXEC) && !(vma->vm_flags & VM_EXEC)) {
James Morrisd541bbe2009-01-29 12:19:51 +11003081 int rc = 0;
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003082 if (vma->vm_start >= vma->vm_mm->start_brk &&
3083 vma->vm_end <= vma->vm_mm->brk) {
David Howellsd84f4f92008-11-14 10:39:23 +11003084 rc = cred_has_perm(cred, cred, PROCESS__EXECHEAP);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003085 } else if (!vma->vm_file &&
3086 vma->vm_start <= vma->vm_mm->start_stack &&
3087 vma->vm_end >= vma->vm_mm->start_stack) {
David Howells3b11a1d2008-11-14 10:39:26 +11003088 rc = current_has_perm(current, PROCESS__EXECSTACK);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003089 } else if (vma->vm_file && vma->anon_vma) {
3090 /*
3091 * We are making executable a file mapping that has
3092 * had some COW done. Since pages might have been
3093 * written, check ability to execute the possibly
3094 * modified content. This typically should only
3095 * occur for text relocations.
3096 */
David Howellsd84f4f92008-11-14 10:39:23 +11003097 rc = file_has_perm(cred, vma->vm_file, FILE__EXECMOD);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003098 }
Lorenzo Hernandez García-Hierro6b992192005-06-25 14:54:34 -07003099 if (rc)
3100 return rc;
3101 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102#endif
3103
3104 return file_map_prot_check(vma->vm_file, prot, vma->vm_flags&VM_SHARED);
3105}
3106
3107static int selinux_file_lock(struct file *file, unsigned int cmd)
3108{
David Howells88e67f32008-11-14 10:39:21 +11003109 const struct cred *cred = current_cred();
3110
3111 return file_has_perm(cred, file, FILE__LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112}
3113
3114static int selinux_file_fcntl(struct file *file, unsigned int cmd,
3115 unsigned long arg)
3116{
David Howells88e67f32008-11-14 10:39:21 +11003117 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 int err = 0;
3119
3120 switch (cmd) {
Eric Paris828dfe12008-04-17 13:17:49 -04003121 case F_SETFL:
3122 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3123 err = -EINVAL;
3124 break;
3125 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126
Eric Paris828dfe12008-04-17 13:17:49 -04003127 if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) {
David Howells88e67f32008-11-14 10:39:21 +11003128 err = file_has_perm(cred, file, FILE__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003130 }
3131 /* fall through */
3132 case F_SETOWN:
3133 case F_SETSIG:
3134 case F_GETFL:
3135 case F_GETOWN:
3136 case F_GETSIG:
3137 /* Just check FD__USE permission */
David Howells88e67f32008-11-14 10:39:21 +11003138 err = file_has_perm(cred, file, 0);
Eric Paris828dfe12008-04-17 13:17:49 -04003139 break;
3140 case F_GETLK:
3141 case F_SETLK:
3142 case F_SETLKW:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143#if BITS_PER_LONG == 32
Eric Paris828dfe12008-04-17 13:17:49 -04003144 case F_GETLK64:
3145 case F_SETLK64:
3146 case F_SETLKW64:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147#endif
Eric Paris828dfe12008-04-17 13:17:49 -04003148 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3149 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003151 }
David Howells88e67f32008-11-14 10:39:21 +11003152 err = file_has_perm(cred, file, FILE__LOCK);
Eric Paris828dfe12008-04-17 13:17:49 -04003153 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 }
3155
3156 return err;
3157}
3158
3159static int selinux_file_set_fowner(struct file *file)
3160{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161 struct file_security_struct *fsec;
3162
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 fsec = file->f_security;
David Howells275bb412008-11-14 10:39:19 +11003164 fsec->fown_sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165
3166 return 0;
3167}
3168
3169static int selinux_file_send_sigiotask(struct task_struct *tsk,
3170 struct fown_struct *fown, int signum)
3171{
Eric Paris828dfe12008-04-17 13:17:49 -04003172 struct file *file;
Stephen Smalley65c90bc2009-05-04 15:43:18 -04003173 u32 sid = task_sid(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 u32 perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003175 struct file_security_struct *fsec;
3176
3177 /* struct fown_struct is never outside the context of a struct file */
Eric Paris828dfe12008-04-17 13:17:49 -04003178 file = container_of(fown, struct file, f_owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 fsec = file->f_security;
3181
3182 if (!signum)
3183 perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */
3184 else
3185 perm = signal_to_av(signum);
3186
David Howells275bb412008-11-14 10:39:19 +11003187 return avc_has_perm(fsec->fown_sid, sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003188 SECCLASS_PROCESS, perm, NULL);
3189}
3190
3191static int selinux_file_receive(struct file *file)
3192{
David Howells88e67f32008-11-14 10:39:21 +11003193 const struct cred *cred = current_cred();
3194
3195 return file_has_perm(cred, file, file_to_av(file));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196}
3197
David Howells745ca242008-11-14 10:39:22 +11003198static int selinux_dentry_open(struct file *file, const struct cred *cred)
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003199{
3200 struct file_security_struct *fsec;
3201 struct inode *inode;
3202 struct inode_security_struct *isec;
David Howellsd84f4f92008-11-14 10:39:23 +11003203
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003204 inode = file->f_path.dentry->d_inode;
3205 fsec = file->f_security;
3206 isec = inode->i_security;
3207 /*
3208 * Save inode label and policy sequence number
3209 * at open-time so that selinux_file_permission
3210 * can determine whether revalidation is necessary.
3211 * Task label is already saved in the file security
3212 * struct as its SID.
3213 */
3214 fsec->isid = isec->sid;
3215 fsec->pseqno = avc_policy_seqno();
3216 /*
3217 * Since the inode label or policy seqno may have changed
3218 * between the selinux_inode_permission check and the saving
3219 * of state above, recheck that access is still permitted.
3220 * Otherwise, access might never be revalidated against the
3221 * new inode label or new policy.
3222 * This check is not redundant - do not remove.
3223 */
David Howells88e67f32008-11-14 10:39:21 +11003224 return inode_has_perm(cred, inode, open_file_to_av(file), NULL);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003225}
3226
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227/* task security operations */
3228
3229static int selinux_task_create(unsigned long clone_flags)
3230{
David Howells3b11a1d2008-11-14 10:39:26 +11003231 return current_has_perm(current, PROCESS__FORK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232}
3233
David Howellsf1752ee2008-11-14 10:39:17 +11003234/*
David Howellsee18d642009-09-02 09:14:21 +01003235 * allocate the SELinux part of blank credentials
3236 */
3237static int selinux_cred_alloc_blank(struct cred *cred, gfp_t gfp)
3238{
3239 struct task_security_struct *tsec;
3240
3241 tsec = kzalloc(sizeof(struct task_security_struct), gfp);
3242 if (!tsec)
3243 return -ENOMEM;
3244
3245 cred->security = tsec;
3246 return 0;
3247}
3248
3249/*
David Howellsf1752ee2008-11-14 10:39:17 +11003250 * detach and free the LSM part of a set of credentials
3251 */
3252static void selinux_cred_free(struct cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253{
David Howellsf1752ee2008-11-14 10:39:17 +11003254 struct task_security_struct *tsec = cred->security;
David Howellse0e81732009-09-02 09:13:40 +01003255
3256 BUG_ON((unsigned long) cred->security < PAGE_SIZE);
3257 cred->security = (void *) 0x7UL;
David Howellsf1752ee2008-11-14 10:39:17 +11003258 kfree(tsec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259}
3260
David Howellsd84f4f92008-11-14 10:39:23 +11003261/*
3262 * prepare a new set of credentials for modification
3263 */
3264static int selinux_cred_prepare(struct cred *new, const struct cred *old,
3265 gfp_t gfp)
3266{
3267 const struct task_security_struct *old_tsec;
3268 struct task_security_struct *tsec;
3269
3270 old_tsec = old->security;
3271
3272 tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp);
3273 if (!tsec)
3274 return -ENOMEM;
3275
3276 new->security = tsec;
3277 return 0;
3278}
3279
3280/*
David Howellsee18d642009-09-02 09:14:21 +01003281 * transfer the SELinux data to a blank set of creds
3282 */
3283static void selinux_cred_transfer(struct cred *new, const struct cred *old)
3284{
3285 const struct task_security_struct *old_tsec = old->security;
3286 struct task_security_struct *tsec = new->security;
3287
3288 *tsec = *old_tsec;
3289}
3290
3291/*
David Howells3a3b7ce2008-11-14 10:39:28 +11003292 * set the security data for a kernel service
3293 * - all the creation contexts are set to unlabelled
3294 */
3295static int selinux_kernel_act_as(struct cred *new, u32 secid)
3296{
3297 struct task_security_struct *tsec = new->security;
3298 u32 sid = current_sid();
3299 int ret;
3300
3301 ret = avc_has_perm(sid, secid,
3302 SECCLASS_KERNEL_SERVICE,
3303 KERNEL_SERVICE__USE_AS_OVERRIDE,
3304 NULL);
3305 if (ret == 0) {
3306 tsec->sid = secid;
3307 tsec->create_sid = 0;
3308 tsec->keycreate_sid = 0;
3309 tsec->sockcreate_sid = 0;
3310 }
3311 return ret;
3312}
3313
3314/*
3315 * set the file creation context in a security record to the same as the
3316 * objective context of the specified inode
3317 */
3318static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
3319{
3320 struct inode_security_struct *isec = inode->i_security;
3321 struct task_security_struct *tsec = new->security;
3322 u32 sid = current_sid();
3323 int ret;
3324
3325 ret = avc_has_perm(sid, isec->sid,
3326 SECCLASS_KERNEL_SERVICE,
3327 KERNEL_SERVICE__CREATE_FILES_AS,
3328 NULL);
3329
3330 if (ret == 0)
3331 tsec->create_sid = isec->sid;
David Howellsef574712010-02-26 01:56:16 +00003332 return ret;
David Howells3a3b7ce2008-11-14 10:39:28 +11003333}
3334
Eric Parisdd8dbf22009-11-03 16:35:32 +11003335static int selinux_kernel_module_request(char *kmod_name)
Eric Paris25354c42009-08-13 09:45:03 -04003336{
Eric Parisdd8dbf22009-11-03 16:35:32 +11003337 u32 sid;
3338 struct common_audit_data ad;
3339
3340 sid = task_sid(current);
3341
3342 COMMON_AUDIT_DATA_INIT(&ad, KMOD);
3343 ad.u.kmod_name = kmod_name;
3344
3345 return avc_has_perm(sid, SECINITSID_KERNEL, SECCLASS_SYSTEM,
3346 SYSTEM__MODULE_REQUEST, &ad);
Eric Paris25354c42009-08-13 09:45:03 -04003347}
3348
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
3350{
David Howells3b11a1d2008-11-14 10:39:26 +11003351 return current_has_perm(p, PROCESS__SETPGID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352}
3353
3354static int selinux_task_getpgid(struct task_struct *p)
3355{
David Howells3b11a1d2008-11-14 10:39:26 +11003356 return current_has_perm(p, PROCESS__GETPGID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357}
3358
3359static int selinux_task_getsid(struct task_struct *p)
3360{
David Howells3b11a1d2008-11-14 10:39:26 +11003361 return current_has_perm(p, PROCESS__GETSESSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362}
3363
David Quigleyf9008e42006-06-30 01:55:46 -07003364static void selinux_task_getsecid(struct task_struct *p, u32 *secid)
3365{
David Howells275bb412008-11-14 10:39:19 +11003366 *secid = task_sid(p);
David Quigleyf9008e42006-06-30 01:55:46 -07003367}
3368
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369static int selinux_task_setnice(struct task_struct *p, int nice)
3370{
3371 int rc;
3372
Eric Paris200ac532009-02-12 15:01:04 -05003373 rc = cap_task_setnice(p, nice);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374 if (rc)
3375 return rc;
3376
David Howells3b11a1d2008-11-14 10:39:26 +11003377 return current_has_perm(p, PROCESS__SETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378}
3379
James Morris03e68062006-06-23 02:03:58 -07003380static int selinux_task_setioprio(struct task_struct *p, int ioprio)
3381{
Serge E. Hallynb5376772007-10-16 23:31:36 -07003382 int rc;
3383
Eric Paris200ac532009-02-12 15:01:04 -05003384 rc = cap_task_setioprio(p, ioprio);
Serge E. Hallynb5376772007-10-16 23:31:36 -07003385 if (rc)
3386 return rc;
3387
David Howells3b11a1d2008-11-14 10:39:26 +11003388 return current_has_perm(p, PROCESS__SETSCHED);
James Morris03e68062006-06-23 02:03:58 -07003389}
3390
David Quigleya1836a42006-06-30 01:55:49 -07003391static int selinux_task_getioprio(struct task_struct *p)
3392{
David Howells3b11a1d2008-11-14 10:39:26 +11003393 return current_has_perm(p, PROCESS__GETSCHED);
David Quigleya1836a42006-06-30 01:55:49 -07003394}
3395
Linus Torvalds1da177e2005-04-16 15:20:36 -07003396static int selinux_task_setrlimit(unsigned int resource, struct rlimit *new_rlim)
3397{
3398 struct rlimit *old_rlim = current->signal->rlim + resource;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003399
3400 /* Control the ability to change the hard limit (whether
3401 lowering or raising it), so that the hard limit can
3402 later be used as a safe reset point for the soft limit
David Howellsd84f4f92008-11-14 10:39:23 +11003403 upon context transitions. See selinux_bprm_committing_creds. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404 if (old_rlim->rlim_max != new_rlim->rlim_max)
David Howells3b11a1d2008-11-14 10:39:26 +11003405 return current_has_perm(current, PROCESS__SETRLIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406
3407 return 0;
3408}
3409
3410static int selinux_task_setscheduler(struct task_struct *p, int policy, struct sched_param *lp)
3411{
Serge E. Hallynb5376772007-10-16 23:31:36 -07003412 int rc;
3413
Eric Paris200ac532009-02-12 15:01:04 -05003414 rc = cap_task_setscheduler(p, policy, lp);
Serge E. Hallynb5376772007-10-16 23:31:36 -07003415 if (rc)
3416 return rc;
3417
David Howells3b11a1d2008-11-14 10:39:26 +11003418 return current_has_perm(p, PROCESS__SETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419}
3420
3421static int selinux_task_getscheduler(struct task_struct *p)
3422{
David Howells3b11a1d2008-11-14 10:39:26 +11003423 return current_has_perm(p, PROCESS__GETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424}
3425
David Quigley35601542006-06-23 02:04:01 -07003426static int selinux_task_movememory(struct task_struct *p)
3427{
David Howells3b11a1d2008-11-14 10:39:26 +11003428 return current_has_perm(p, PROCESS__SETSCHED);
David Quigley35601542006-06-23 02:04:01 -07003429}
3430
David Quigleyf9008e42006-06-30 01:55:46 -07003431static int selinux_task_kill(struct task_struct *p, struct siginfo *info,
3432 int sig, u32 secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433{
3434 u32 perm;
3435 int rc;
3436
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437 if (!sig)
3438 perm = PROCESS__SIGNULL; /* null signal; existence test */
3439 else
3440 perm = signal_to_av(sig);
David Quigleyf9008e42006-06-30 01:55:46 -07003441 if (secid)
David Howells275bb412008-11-14 10:39:19 +11003442 rc = avc_has_perm(secid, task_sid(p),
3443 SECCLASS_PROCESS, perm, NULL);
David Quigleyf9008e42006-06-30 01:55:46 -07003444 else
David Howells3b11a1d2008-11-14 10:39:26 +11003445 rc = current_has_perm(p, perm);
David Quigleyf9008e42006-06-30 01:55:46 -07003446 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003447}
3448
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449static int selinux_task_wait(struct task_struct *p)
3450{
Eric Paris8a535142007-10-22 16:10:31 -04003451 return task_has_perm(p, current, PROCESS__SIGCHLD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452}
3453
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454static void selinux_task_to_inode(struct task_struct *p,
3455 struct inode *inode)
3456{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457 struct inode_security_struct *isec = inode->i_security;
David Howells275bb412008-11-14 10:39:19 +11003458 u32 sid = task_sid(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459
David Howells275bb412008-11-14 10:39:19 +11003460 isec->sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 isec->initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462}
3463
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464/* Returns error only if unable to parse addresses */
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003465static int selinux_parse_skb_ipv4(struct sk_buff *skb,
Thomas Liu2bf49692009-07-14 12:14:09 -04003466 struct common_audit_data *ad, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003467{
3468 int offset, ihlen, ret = -EINVAL;
3469 struct iphdr _iph, *ih;
3470
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03003471 offset = skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472 ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
3473 if (ih == NULL)
3474 goto out;
3475
3476 ihlen = ih->ihl * 4;
3477 if (ihlen < sizeof(_iph))
3478 goto out;
3479
3480 ad->u.net.v4info.saddr = ih->saddr;
3481 ad->u.net.v4info.daddr = ih->daddr;
3482 ret = 0;
3483
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003484 if (proto)
3485 *proto = ih->protocol;
3486
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 switch (ih->protocol) {
Eric Paris828dfe12008-04-17 13:17:49 -04003488 case IPPROTO_TCP: {
3489 struct tcphdr _tcph, *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003490
Eric Paris828dfe12008-04-17 13:17:49 -04003491 if (ntohs(ih->frag_off) & IP_OFFSET)
3492 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493
3494 offset += ihlen;
3495 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3496 if (th == NULL)
3497 break;
3498
3499 ad->u.net.sport = th->source;
3500 ad->u.net.dport = th->dest;
3501 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003502 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503
Eric Paris828dfe12008-04-17 13:17:49 -04003504 case IPPROTO_UDP: {
3505 struct udphdr _udph, *uh;
3506
3507 if (ntohs(ih->frag_off) & IP_OFFSET)
3508 break;
3509
3510 offset += ihlen;
3511 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3512 if (uh == NULL)
3513 break;
3514
3515 ad->u.net.sport = uh->source;
3516 ad->u.net.dport = uh->dest;
3517 break;
3518 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519
James Morris2ee92d42006-11-13 16:09:01 -08003520 case IPPROTO_DCCP: {
3521 struct dccp_hdr _dccph, *dh;
3522
3523 if (ntohs(ih->frag_off) & IP_OFFSET)
3524 break;
3525
3526 offset += ihlen;
3527 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3528 if (dh == NULL)
3529 break;
3530
3531 ad->u.net.sport = dh->dccph_sport;
3532 ad->u.net.dport = dh->dccph_dport;
3533 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003534 }
James Morris2ee92d42006-11-13 16:09:01 -08003535
Eric Paris828dfe12008-04-17 13:17:49 -04003536 default:
3537 break;
3538 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539out:
3540 return ret;
3541}
3542
3543#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3544
3545/* Returns error only if unable to parse addresses */
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003546static int selinux_parse_skb_ipv6(struct sk_buff *skb,
Thomas Liu2bf49692009-07-14 12:14:09 -04003547 struct common_audit_data *ad, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548{
3549 u8 nexthdr;
3550 int ret = -EINVAL, offset;
3551 struct ipv6hdr _ipv6h, *ip6;
3552
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03003553 offset = skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003554 ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3555 if (ip6 == NULL)
3556 goto out;
3557
3558 ipv6_addr_copy(&ad->u.net.v6info.saddr, &ip6->saddr);
3559 ipv6_addr_copy(&ad->u.net.v6info.daddr, &ip6->daddr);
3560 ret = 0;
3561
3562 nexthdr = ip6->nexthdr;
3563 offset += sizeof(_ipv6h);
Herbert Xu0d3d0772005-04-24 20:16:19 -07003564 offset = ipv6_skip_exthdr(skb, offset, &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565 if (offset < 0)
3566 goto out;
3567
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003568 if (proto)
3569 *proto = nexthdr;
3570
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571 switch (nexthdr) {
3572 case IPPROTO_TCP: {
Eric Paris828dfe12008-04-17 13:17:49 -04003573 struct tcphdr _tcph, *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574
3575 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3576 if (th == NULL)
3577 break;
3578
3579 ad->u.net.sport = th->source;
3580 ad->u.net.dport = th->dest;
3581 break;
3582 }
3583
3584 case IPPROTO_UDP: {
3585 struct udphdr _udph, *uh;
3586
3587 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3588 if (uh == NULL)
3589 break;
3590
3591 ad->u.net.sport = uh->source;
3592 ad->u.net.dport = uh->dest;
3593 break;
3594 }
3595
James Morris2ee92d42006-11-13 16:09:01 -08003596 case IPPROTO_DCCP: {
3597 struct dccp_hdr _dccph, *dh;
3598
3599 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3600 if (dh == NULL)
3601 break;
3602
3603 ad->u.net.sport = dh->dccph_sport;
3604 ad->u.net.dport = dh->dccph_dport;
3605 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003606 }
James Morris2ee92d42006-11-13 16:09:01 -08003607
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608 /* includes fragments */
3609 default:
3610 break;
3611 }
3612out:
3613 return ret;
3614}
3615
3616#endif /* IPV6 */
3617
Thomas Liu2bf49692009-07-14 12:14:09 -04003618static int selinux_parse_skb(struct sk_buff *skb, struct common_audit_data *ad,
David Howellscf9481e2008-07-27 21:31:07 +10003619 char **_addrp, int src, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003620{
David Howellscf9481e2008-07-27 21:31:07 +10003621 char *addrp;
3622 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623
3624 switch (ad->u.net.family) {
3625 case PF_INET:
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003626 ret = selinux_parse_skb_ipv4(skb, ad, proto);
David Howellscf9481e2008-07-27 21:31:07 +10003627 if (ret)
3628 goto parse_error;
3629 addrp = (char *)(src ? &ad->u.net.v4info.saddr :
3630 &ad->u.net.v4info.daddr);
3631 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003632
3633#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3634 case PF_INET6:
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003635 ret = selinux_parse_skb_ipv6(skb, ad, proto);
David Howellscf9481e2008-07-27 21:31:07 +10003636 if (ret)
3637 goto parse_error;
3638 addrp = (char *)(src ? &ad->u.net.v6info.saddr :
3639 &ad->u.net.v6info.daddr);
3640 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641#endif /* IPV6 */
3642 default:
David Howellscf9481e2008-07-27 21:31:07 +10003643 addrp = NULL;
3644 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645 }
3646
David Howellscf9481e2008-07-27 21:31:07 +10003647parse_error:
3648 printk(KERN_WARNING
3649 "SELinux: failure in selinux_parse_skb(),"
3650 " unable to parse packet\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003651 return ret;
David Howellscf9481e2008-07-27 21:31:07 +10003652
3653okay:
3654 if (_addrp)
3655 *_addrp = addrp;
3656 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003657}
3658
Paul Moore4f6a9932007-03-01 14:35:22 -05003659/**
Paul Moore220deb92008-01-29 08:38:23 -05003660 * selinux_skb_peerlbl_sid - Determine the peer label of a packet
Paul Moore4f6a9932007-03-01 14:35:22 -05003661 * @skb: the packet
Paul Moore75e22912008-01-29 08:38:04 -05003662 * @family: protocol family
Paul Moore220deb92008-01-29 08:38:23 -05003663 * @sid: the packet's peer label SID
Paul Moore4f6a9932007-03-01 14:35:22 -05003664 *
3665 * Description:
Paul Moore220deb92008-01-29 08:38:23 -05003666 * Check the various different forms of network peer labeling and determine
3667 * the peer label/SID for the packet; most of the magic actually occurs in
3668 * the security server function security_net_peersid_cmp(). The function
3669 * returns zero if the value in @sid is valid (although it may be SECSID_NULL)
3670 * or -EACCES if @sid is invalid due to inconsistencies with the different
3671 * peer labels.
Paul Moore4f6a9932007-03-01 14:35:22 -05003672 *
3673 */
Paul Moore220deb92008-01-29 08:38:23 -05003674static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid)
Paul Moore4f6a9932007-03-01 14:35:22 -05003675{
Paul Moore71f1cb02008-01-29 08:51:16 -05003676 int err;
Paul Moore4f6a9932007-03-01 14:35:22 -05003677 u32 xfrm_sid;
3678 u32 nlbl_sid;
Paul Moore220deb92008-01-29 08:38:23 -05003679 u32 nlbl_type;
Paul Moore4f6a9932007-03-01 14:35:22 -05003680
3681 selinux_skb_xfrm_sid(skb, &xfrm_sid);
Paul Moore5dbe1eb2008-01-29 08:44:18 -05003682 selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
Paul Moore220deb92008-01-29 08:38:23 -05003683
Paul Moore71f1cb02008-01-29 08:51:16 -05003684 err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid);
3685 if (unlikely(err)) {
3686 printk(KERN_WARNING
3687 "SELinux: failure in selinux_skb_peerlbl_sid(),"
3688 " unable to determine packet's peer label\n");
Paul Moore220deb92008-01-29 08:38:23 -05003689 return -EACCES;
Paul Moore71f1cb02008-01-29 08:51:16 -05003690 }
Paul Moore220deb92008-01-29 08:38:23 -05003691
3692 return 0;
Paul Moore4f6a9932007-03-01 14:35:22 -05003693}
3694
Linus Torvalds1da177e2005-04-16 15:20:36 -07003695/* socket security operations */
3696static int socket_has_perm(struct task_struct *task, struct socket *sock,
3697 u32 perms)
3698{
3699 struct inode_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04003700 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11003701 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003702 int err = 0;
3703
Linus Torvalds1da177e2005-04-16 15:20:36 -07003704 isec = SOCK_INODE(sock)->i_security;
3705
3706 if (isec->sid == SECINITSID_KERNEL)
3707 goto out;
David Howells275bb412008-11-14 10:39:19 +11003708 sid = task_sid(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709
Thomas Liu2bf49692009-07-14 12:14:09 -04003710 COMMON_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711 ad.u.net.sk = sock->sk;
David Howells275bb412008-11-14 10:39:19 +11003712 err = avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003713
3714out:
3715 return err;
3716}
3717
3718static int selinux_socket_create(int family, int type,
3719 int protocol, int kern)
3720{
David Howells275bb412008-11-14 10:39:19 +11003721 const struct cred *cred = current_cred();
3722 const struct task_security_struct *tsec = cred->security;
3723 u32 sid, newsid;
3724 u16 secclass;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003725 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003726
3727 if (kern)
3728 goto out;
3729
David Howells275bb412008-11-14 10:39:19 +11003730 sid = tsec->sid;
3731 newsid = tsec->sockcreate_sid ?: sid;
3732
3733 secclass = socket_type_to_security_class(family, type, protocol);
3734 err = avc_has_perm(sid, newsid, secclass, SOCKET__CREATE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003735
3736out:
3737 return err;
3738}
3739
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07003740static int selinux_socket_post_create(struct socket *sock, int family,
3741 int type, int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742{
David Howells275bb412008-11-14 10:39:19 +11003743 const struct cred *cred = current_cred();
3744 const struct task_security_struct *tsec = cred->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745 struct inode_security_struct *isec;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003746 struct sk_security_struct *sksec;
David Howells275bb412008-11-14 10:39:19 +11003747 u32 sid, newsid;
3748 int err = 0;
3749
3750 sid = tsec->sid;
3751 newsid = tsec->sockcreate_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752
3753 isec = SOCK_INODE(sock)->i_security;
3754
David Howells275bb412008-11-14 10:39:19 +11003755 if (kern)
3756 isec->sid = SECINITSID_KERNEL;
3757 else if (newsid)
3758 isec->sid = newsid;
3759 else
3760 isec->sid = sid;
3761
Linus Torvalds1da177e2005-04-16 15:20:36 -07003762 isec->sclass = socket_type_to_security_class(family, type, protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003763 isec->initialized = 1;
3764
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003765 if (sock->sk) {
3766 sksec = sock->sk->sk_security;
3767 sksec->sid = isec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05003768 sksec->sclass = isec->sclass;
Paul Moore389fb8002009-03-27 17:10:34 -04003769 err = selinux_netlbl_socket_post_create(sock->sk, family);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003770 }
3771
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07003772 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003773}
3774
3775/* Range of port numbers used to automatically bind.
3776 Need to determine whether we should perform a name_bind
3777 permission check between the socket and the port number. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003778
3779static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
3780{
3781 u16 family;
3782 int err;
3783
3784 err = socket_has_perm(current, sock, SOCKET__BIND);
3785 if (err)
3786 goto out;
3787
3788 /*
3789 * If PF_INET or PF_INET6, check name_bind permission for the port.
James Morris13402582005-09-30 14:24:34 -04003790 * Multiple address binding for SCTP is not supported yet: we just
3791 * check the first address now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792 */
3793 family = sock->sk->sk_family;
3794 if (family == PF_INET || family == PF_INET6) {
3795 char *addrp;
3796 struct inode_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04003797 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003798 struct sockaddr_in *addr4 = NULL;
3799 struct sockaddr_in6 *addr6 = NULL;
3800 unsigned short snum;
3801 struct sock *sk = sock->sk;
James Morrise399f982008-06-12 01:39:58 +10003802 u32 sid, node_perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003803
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804 isec = SOCK_INODE(sock)->i_security;
3805
3806 if (family == PF_INET) {
3807 addr4 = (struct sockaddr_in *)address;
3808 snum = ntohs(addr4->sin_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809 addrp = (char *)&addr4->sin_addr.s_addr;
3810 } else {
3811 addr6 = (struct sockaddr_in6 *)address;
3812 snum = ntohs(addr6->sin6_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003813 addrp = (char *)&addr6->sin6_addr.s6_addr;
3814 }
3815
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003816 if (snum) {
3817 int low, high;
3818
3819 inet_get_local_port_range(&low, &high);
3820
3821 if (snum < max(PROT_SOCK, low) || snum > high) {
Paul Moore3e112172008-04-10 10:48:14 -04003822 err = sel_netport_sid(sk->sk_protocol,
3823 snum, &sid);
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003824 if (err)
3825 goto out;
Thomas Liu2bf49692009-07-14 12:14:09 -04003826 COMMON_AUDIT_DATA_INIT(&ad, NET);
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003827 ad.u.net.sport = htons(snum);
3828 ad.u.net.family = family;
3829 err = avc_has_perm(isec->sid, sid,
3830 isec->sclass,
3831 SOCKET__NAME_BIND, &ad);
3832 if (err)
3833 goto out;
3834 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003835 }
Eric Paris828dfe12008-04-17 13:17:49 -04003836
3837 switch (isec->sclass) {
James Morris13402582005-09-30 14:24:34 -04003838 case SECCLASS_TCP_SOCKET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839 node_perm = TCP_SOCKET__NODE_BIND;
3840 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003841
James Morris13402582005-09-30 14:24:34 -04003842 case SECCLASS_UDP_SOCKET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003843 node_perm = UDP_SOCKET__NODE_BIND;
3844 break;
James Morris2ee92d42006-11-13 16:09:01 -08003845
3846 case SECCLASS_DCCP_SOCKET:
3847 node_perm = DCCP_SOCKET__NODE_BIND;
3848 break;
3849
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850 default:
3851 node_perm = RAWIP_SOCKET__NODE_BIND;
3852 break;
3853 }
Eric Paris828dfe12008-04-17 13:17:49 -04003854
Paul Moore224dfbd2008-01-29 08:38:13 -05003855 err = sel_netnode_sid(addrp, family, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856 if (err)
3857 goto out;
Eric Paris828dfe12008-04-17 13:17:49 -04003858
Thomas Liu2bf49692009-07-14 12:14:09 -04003859 COMMON_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 ad.u.net.sport = htons(snum);
3861 ad.u.net.family = family;
3862
3863 if (family == PF_INET)
3864 ad.u.net.v4info.saddr = addr4->sin_addr.s_addr;
3865 else
3866 ipv6_addr_copy(&ad.u.net.v6info.saddr, &addr6->sin6_addr);
3867
3868 err = avc_has_perm(isec->sid, sid,
Eric Paris828dfe12008-04-17 13:17:49 -04003869 isec->sclass, node_perm, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870 if (err)
3871 goto out;
3872 }
3873out:
3874 return err;
3875}
3876
3877static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
3878{
Paul Moore014ab192008-10-10 10:16:33 -04003879 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003880 struct inode_security_struct *isec;
3881 int err;
3882
3883 err = socket_has_perm(current, sock, SOCKET__CONNECT);
3884 if (err)
3885 return err;
3886
3887 /*
James Morris2ee92d42006-11-13 16:09:01 -08003888 * If a TCP or DCCP socket, check name_connect permission for the port.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003889 */
3890 isec = SOCK_INODE(sock)->i_security;
James Morris2ee92d42006-11-13 16:09:01 -08003891 if (isec->sclass == SECCLASS_TCP_SOCKET ||
3892 isec->sclass == SECCLASS_DCCP_SOCKET) {
Thomas Liu2bf49692009-07-14 12:14:09 -04003893 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 struct sockaddr_in *addr4 = NULL;
3895 struct sockaddr_in6 *addr6 = NULL;
3896 unsigned short snum;
James Morris2ee92d42006-11-13 16:09:01 -08003897 u32 sid, perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003898
3899 if (sk->sk_family == PF_INET) {
3900 addr4 = (struct sockaddr_in *)address;
Stephen Smalley911656f2005-07-28 21:16:21 -07003901 if (addrlen < sizeof(struct sockaddr_in))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 return -EINVAL;
3903 snum = ntohs(addr4->sin_port);
3904 } else {
3905 addr6 = (struct sockaddr_in6 *)address;
Stephen Smalley911656f2005-07-28 21:16:21 -07003906 if (addrlen < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003907 return -EINVAL;
3908 snum = ntohs(addr6->sin6_port);
3909 }
3910
Paul Moore3e112172008-04-10 10:48:14 -04003911 err = sel_netport_sid(sk->sk_protocol, snum, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003912 if (err)
3913 goto out;
3914
James Morris2ee92d42006-11-13 16:09:01 -08003915 perm = (isec->sclass == SECCLASS_TCP_SOCKET) ?
3916 TCP_SOCKET__NAME_CONNECT : DCCP_SOCKET__NAME_CONNECT;
3917
Thomas Liu2bf49692009-07-14 12:14:09 -04003918 COMMON_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003919 ad.u.net.dport = htons(snum);
3920 ad.u.net.family = sk->sk_family;
James Morris2ee92d42006-11-13 16:09:01 -08003921 err = avc_has_perm(isec->sid, sid, isec->sclass, perm, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922 if (err)
3923 goto out;
3924 }
3925
Paul Moore014ab192008-10-10 10:16:33 -04003926 err = selinux_netlbl_socket_connect(sk, address);
3927
Linus Torvalds1da177e2005-04-16 15:20:36 -07003928out:
3929 return err;
3930}
3931
3932static int selinux_socket_listen(struct socket *sock, int backlog)
3933{
3934 return socket_has_perm(current, sock, SOCKET__LISTEN);
3935}
3936
3937static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
3938{
3939 int err;
3940 struct inode_security_struct *isec;
3941 struct inode_security_struct *newisec;
3942
3943 err = socket_has_perm(current, sock, SOCKET__ACCEPT);
3944 if (err)
3945 return err;
3946
3947 newisec = SOCK_INODE(newsock)->i_security;
3948
3949 isec = SOCK_INODE(sock)->i_security;
3950 newisec->sclass = isec->sclass;
3951 newisec->sid = isec->sid;
3952 newisec->initialized = 1;
3953
3954 return 0;
3955}
3956
3957static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
Eric Paris828dfe12008-04-17 13:17:49 -04003958 int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003959{
Paul Moore389fb8002009-03-27 17:10:34 -04003960 return socket_has_perm(current, sock, SOCKET__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961}
3962
3963static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
3964 int size, int flags)
3965{
3966 return socket_has_perm(current, sock, SOCKET__READ);
3967}
3968
3969static int selinux_socket_getsockname(struct socket *sock)
3970{
3971 return socket_has_perm(current, sock, SOCKET__GETATTR);
3972}
3973
3974static int selinux_socket_getpeername(struct socket *sock)
3975{
3976 return socket_has_perm(current, sock, SOCKET__GETATTR);
3977}
3978
Eric Paris828dfe12008-04-17 13:17:49 -04003979static int selinux_socket_setsockopt(struct socket *sock, int level, int optname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003980{
Paul Mooref8687af2006-10-30 15:22:15 -08003981 int err;
3982
3983 err = socket_has_perm(current, sock, SOCKET__SETOPT);
3984 if (err)
3985 return err;
3986
3987 return selinux_netlbl_socket_setsockopt(sock, level, optname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003988}
3989
3990static int selinux_socket_getsockopt(struct socket *sock, int level,
3991 int optname)
3992{
3993 return socket_has_perm(current, sock, SOCKET__GETOPT);
3994}
3995
3996static int selinux_socket_shutdown(struct socket *sock, int how)
3997{
3998 return socket_has_perm(current, sock, SOCKET__SHUTDOWN);
3999}
4000
4001static int selinux_socket_unix_stream_connect(struct socket *sock,
4002 struct socket *other,
4003 struct sock *newsk)
4004{
4005 struct sk_security_struct *ssec;
4006 struct inode_security_struct *isec;
4007 struct inode_security_struct *other_isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004008 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009 int err;
4010
Linus Torvalds1da177e2005-04-16 15:20:36 -07004011 isec = SOCK_INODE(sock)->i_security;
4012 other_isec = SOCK_INODE(other)->i_security;
4013
Thomas Liu2bf49692009-07-14 12:14:09 -04004014 COMMON_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004015 ad.u.net.sk = other->sk;
4016
4017 err = avc_has_perm(isec->sid, other_isec->sid,
4018 isec->sclass,
4019 UNIX_STREAM_SOCKET__CONNECTTO, &ad);
4020 if (err)
4021 return err;
4022
4023 /* connecting socket */
4024 ssec = sock->sk->sk_security;
4025 ssec->peer_sid = other_isec->sid;
Eric Paris828dfe12008-04-17 13:17:49 -04004026
Linus Torvalds1da177e2005-04-16 15:20:36 -07004027 /* server child socket */
4028 ssec = newsk->sk_security;
4029 ssec->peer_sid = isec->sid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004030 err = security_sid_mls_copy(other_isec->sid, ssec->peer_sid, &ssec->sid);
4031
4032 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004033}
4034
4035static int selinux_socket_unix_may_send(struct socket *sock,
4036 struct socket *other)
4037{
4038 struct inode_security_struct *isec;
4039 struct inode_security_struct *other_isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004040 struct common_audit_data ad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004041 int err;
4042
4043 isec = SOCK_INODE(sock)->i_security;
4044 other_isec = SOCK_INODE(other)->i_security;
4045
Thomas Liu2bf49692009-07-14 12:14:09 -04004046 COMMON_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004047 ad.u.net.sk = other->sk;
4048
4049 err = avc_has_perm(isec->sid, other_isec->sid,
4050 isec->sclass, SOCKET__SENDTO, &ad);
4051 if (err)
4052 return err;
4053
4054 return 0;
4055}
4056
Paul Mooreeffad8d2008-01-29 08:49:27 -05004057static int selinux_inet_sys_rcv_skb(int ifindex, char *addrp, u16 family,
4058 u32 peer_sid,
Thomas Liu2bf49692009-07-14 12:14:09 -04004059 struct common_audit_data *ad)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004060{
4061 int err;
4062 u32 if_sid;
4063 u32 node_sid;
4064
4065 err = sel_netif_sid(ifindex, &if_sid);
4066 if (err)
4067 return err;
4068 err = avc_has_perm(peer_sid, if_sid,
4069 SECCLASS_NETIF, NETIF__INGRESS, ad);
4070 if (err)
4071 return err;
4072
4073 err = sel_netnode_sid(addrp, family, &node_sid);
4074 if (err)
4075 return err;
4076 return avc_has_perm(peer_sid, node_sid,
4077 SECCLASS_NODE, NODE__RECVFROM, ad);
4078}
4079
Paul Moore220deb92008-01-29 08:38:23 -05004080static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
Paul Moored8395c82008-10-10 10:16:30 -04004081 u16 family)
Paul Moore220deb92008-01-29 08:38:23 -05004082{
Paul Moore277d3422008-12-31 12:54:11 -05004083 int err = 0;
Paul Moore220deb92008-01-29 08:38:23 -05004084 struct sk_security_struct *sksec = sk->sk_security;
4085 u32 peer_sid;
4086 u32 sk_sid = sksec->sid;
Thomas Liu2bf49692009-07-14 12:14:09 -04004087 struct common_audit_data ad;
Paul Moored8395c82008-10-10 10:16:30 -04004088 char *addrp;
4089
Thomas Liu2bf49692009-07-14 12:14:09 -04004090 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Dumazet8964be42009-11-20 15:35:04 -08004091 ad.u.net.netif = skb->skb_iif;
Paul Moored8395c82008-10-10 10:16:30 -04004092 ad.u.net.family = family;
4093 err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4094 if (err)
4095 return err;
Paul Moore220deb92008-01-29 08:38:23 -05004096
Paul Moore58bfbb52009-03-27 17:10:41 -04004097 if (selinux_secmark_enabled()) {
Paul Moore220deb92008-01-29 08:38:23 -05004098 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
Paul Moored8395c82008-10-10 10:16:30 -04004099 PACKET__RECV, &ad);
Paul Moore58bfbb52009-03-27 17:10:41 -04004100 if (err)
4101 return err;
4102 }
Paul Moore220deb92008-01-29 08:38:23 -05004103
4104 if (selinux_policycap_netpeer) {
4105 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106 if (err)
Paul Moore220deb92008-01-29 08:38:23 -05004107 return err;
4108 err = avc_has_perm(sk_sid, peer_sid,
Paul Moored8395c82008-10-10 10:16:30 -04004109 SECCLASS_PEER, PEER__RECV, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004110 if (err)
4111 selinux_netlbl_err(skb, err, 0);
Paul Moore220deb92008-01-29 08:38:23 -05004112 } else {
Paul Moored8395c82008-10-10 10:16:30 -04004113 err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad);
Paul Moore220deb92008-01-29 08:38:23 -05004114 if (err)
4115 return err;
Paul Moored8395c82008-10-10 10:16:30 -04004116 err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117 }
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004118
James Morris4e5ab4c2006-06-09 00:33:33 -07004119 return err;
4120}
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004121
James Morris4e5ab4c2006-06-09 00:33:33 -07004122static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
4123{
Paul Moore220deb92008-01-29 08:38:23 -05004124 int err;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004125 struct sk_security_struct *sksec = sk->sk_security;
Paul Moore220deb92008-01-29 08:38:23 -05004126 u16 family = sk->sk_family;
4127 u32 sk_sid = sksec->sid;
Thomas Liu2bf49692009-07-14 12:14:09 -04004128 struct common_audit_data ad;
Paul Moore220deb92008-01-29 08:38:23 -05004129 char *addrp;
Paul Moored8395c82008-10-10 10:16:30 -04004130 u8 secmark_active;
4131 u8 peerlbl_active;
James Morris4e5ab4c2006-06-09 00:33:33 -07004132
James Morris4e5ab4c2006-06-09 00:33:33 -07004133 if (family != PF_INET && family != PF_INET6)
Paul Moore220deb92008-01-29 08:38:23 -05004134 return 0;
James Morris4e5ab4c2006-06-09 00:33:33 -07004135
4136 /* Handle mapped IPv4 packets arriving via IPv6 sockets */
Al Viro87fcd702006-12-04 22:00:55 +00004137 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
James Morris4e5ab4c2006-06-09 00:33:33 -07004138 family = PF_INET;
4139
Paul Moored8395c82008-10-10 10:16:30 -04004140 /* If any sort of compatibility mode is enabled then handoff processing
4141 * to the selinux_sock_rcv_skb_compat() function to deal with the
4142 * special handling. We do this in an attempt to keep this function
4143 * as fast and as clean as possible. */
Paul Moore58bfbb52009-03-27 17:10:41 -04004144 if (!selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004145 return selinux_sock_rcv_skb_compat(sk, skb, family);
4146
4147 secmark_active = selinux_secmark_enabled();
4148 peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4149 if (!secmark_active && !peerlbl_active)
4150 return 0;
4151
Thomas Liu2bf49692009-07-14 12:14:09 -04004152 COMMON_AUDIT_DATA_INIT(&ad, NET);
Eric Dumazet8964be42009-11-20 15:35:04 -08004153 ad.u.net.netif = skb->skb_iif;
James Morris4e5ab4c2006-06-09 00:33:33 -07004154 ad.u.net.family = family;
Paul Moore224dfbd2008-01-29 08:38:13 -05004155 err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
James Morris4e5ab4c2006-06-09 00:33:33 -07004156 if (err)
Paul Moore220deb92008-01-29 08:38:23 -05004157 return err;
James Morris4e5ab4c2006-06-09 00:33:33 -07004158
Paul Moored8395c82008-10-10 10:16:30 -04004159 if (peerlbl_active) {
Paul Moored621d352008-01-29 08:43:36 -05004160 u32 peer_sid;
4161
4162 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
4163 if (err)
4164 return err;
Eric Dumazet8964be42009-11-20 15:35:04 -08004165 err = selinux_inet_sys_rcv_skb(skb->skb_iif, addrp, family,
Paul Mooreeffad8d2008-01-29 08:49:27 -05004166 peer_sid, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004167 if (err) {
4168 selinux_netlbl_err(skb, err, 0);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004169 return err;
Paul Mooredfaebe92008-10-10 10:16:31 -04004170 }
Paul Moored621d352008-01-29 08:43:36 -05004171 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
4172 PEER__RECV, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004173 if (err)
4174 selinux_netlbl_err(skb, err, 0);
Paul Moored621d352008-01-29 08:43:36 -05004175 }
4176
Paul Moored8395c82008-10-10 10:16:30 -04004177 if (secmark_active) {
Paul Mooreeffad8d2008-01-29 08:49:27 -05004178 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4179 PACKET__RECV, &ad);
4180 if (err)
4181 return err;
4182 }
4183
Paul Moored621d352008-01-29 08:43:36 -05004184 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004185}
4186
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004187static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *optval,
4188 int __user *optlen, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004189{
4190 int err = 0;
4191 char *scontext;
4192 u32 scontext_len;
4193 struct sk_security_struct *ssec;
4194 struct inode_security_struct *isec;
Paul Moore3de4bab2006-11-17 17:38:54 -05004195 u32 peer_sid = SECSID_NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004196
4197 isec = SOCK_INODE(sock)->i_security;
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004198
Paul Moore3de4bab2006-11-17 17:38:54 -05004199 if (isec->sclass == SECCLASS_UNIX_STREAM_SOCKET ||
4200 isec->sclass == SECCLASS_TCP_SOCKET) {
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004201 ssec = sock->sk->sk_security;
4202 peer_sid = ssec->peer_sid;
4203 }
Paul Moore3de4bab2006-11-17 17:38:54 -05004204 if (peer_sid == SECSID_NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004205 err = -ENOPROTOOPT;
4206 goto out;
4207 }
4208
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004209 err = security_sid_to_context(peer_sid, &scontext, &scontext_len);
4210
Linus Torvalds1da177e2005-04-16 15:20:36 -07004211 if (err)
4212 goto out;
4213
4214 if (scontext_len > len) {
4215 err = -ERANGE;
4216 goto out_len;
4217 }
4218
4219 if (copy_to_user(optval, scontext, scontext_len))
4220 err = -EFAULT;
4221
4222out_len:
4223 if (put_user(scontext_len, optlen))
4224 err = -EFAULT;
4225
4226 kfree(scontext);
Eric Paris828dfe12008-04-17 13:17:49 -04004227out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004228 return err;
4229}
4230
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004231static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004232{
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004233 u32 peer_secid = SECSID_NULL;
Paul Moore75e22912008-01-29 08:38:04 -05004234 u16 family;
Catherine Zhang877ce7c2006-06-29 12:27:47 -07004235
Paul Mooreaa862902008-10-10 10:16:29 -04004236 if (skb && skb->protocol == htons(ETH_P_IP))
4237 family = PF_INET;
4238 else if (skb && skb->protocol == htons(ETH_P_IPV6))
4239 family = PF_INET6;
4240 else if (sock)
Paul Moore75e22912008-01-29 08:38:04 -05004241 family = sock->sk->sk_family;
Paul Moore75e22912008-01-29 08:38:04 -05004242 else
4243 goto out;
4244
4245 if (sock && family == PF_UNIX)
Ahmed S. Darwish713a04ae2008-03-01 21:52:30 +02004246 selinux_inode_getsecid(SOCK_INODE(sock), &peer_secid);
Paul Moore3de4bab2006-11-17 17:38:54 -05004247 else if (skb)
Paul Moore220deb92008-01-29 08:38:23 -05004248 selinux_skb_peerlbl_sid(skb, family, &peer_secid);
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004249
Paul Moore75e22912008-01-29 08:38:04 -05004250out:
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004251 *secid = peer_secid;
Paul Moore75e22912008-01-29 08:38:04 -05004252 if (peer_secid == SECSID_NULL)
4253 return -EINVAL;
4254 return 0;
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004255}
4256
Al Viro7d877f32005-10-21 03:20:43 -04004257static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004258{
4259 return sk_alloc_security(sk, family, priority);
4260}
4261
4262static void selinux_sk_free_security(struct sock *sk)
4263{
4264 sk_free_security(sk);
4265}
4266
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004267static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
4268{
4269 struct sk_security_struct *ssec = sk->sk_security;
4270 struct sk_security_struct *newssec = newsk->sk_security;
4271
4272 newssec->sid = ssec->sid;
4273 newssec->peer_sid = ssec->peer_sid;
Paul Moore220deb92008-01-29 08:38:23 -05004274 newssec->sclass = ssec->sclass;
Paul Moore99f59ed2006-08-29 17:53:48 -07004275
Paul Moore389fb8002009-03-27 17:10:34 -04004276 selinux_netlbl_sk_security_reset(newssec);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004277}
4278
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004279static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004280{
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004281 if (!sk)
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004282 *secid = SECINITSID_ANY_SOCKET;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004283 else {
4284 struct sk_security_struct *sksec = sk->sk_security;
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004285
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004286 *secid = sksec->sid;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004287 }
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004288}
4289
Eric Paris828dfe12008-04-17 13:17:49 -04004290static void selinux_sock_graft(struct sock *sk, struct socket *parent)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004291{
4292 struct inode_security_struct *isec = SOCK_INODE(parent)->i_security;
4293 struct sk_security_struct *sksec = sk->sk_security;
4294
David Woodhouse2148ccc2006-09-29 15:50:25 -07004295 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 ||
4296 sk->sk_family == PF_UNIX)
4297 isec->sid = sksec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05004298 sksec->sclass = isec->sclass;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004299}
4300
Adrian Bunk9a673e52006-08-15 00:03:53 -07004301static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4302 struct request_sock *req)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004303{
4304 struct sk_security_struct *sksec = sk->sk_security;
4305 int err;
Paul Mooreaa862902008-10-10 10:16:29 -04004306 u16 family = sk->sk_family;
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07004307 u32 newsid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004308 u32 peersid;
4309
Paul Mooreaa862902008-10-10 10:16:29 -04004310 /* handle mapped IPv4 packets arriving via IPv6 sockets */
4311 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4312 family = PF_INET;
4313
4314 err = selinux_skb_peerlbl_sid(skb, family, &peersid);
Paul Moore220deb92008-01-29 08:38:23 -05004315 if (err)
4316 return err;
Venkat Yekkiralaa51c64f2006-07-27 22:01:34 -07004317 if (peersid == SECSID_NULL) {
4318 req->secid = sksec->sid;
Paul Moore3de4bab2006-11-17 17:38:54 -05004319 req->peer_secid = SECSID_NULL;
Paul Moore389fb8002009-03-27 17:10:34 -04004320 } else {
4321 err = security_sid_mls_copy(sksec->sid, peersid, &newsid);
4322 if (err)
4323 return err;
4324 req->secid = newsid;
4325 req->peer_secid = peersid;
Venkat Yekkiralaa51c64f2006-07-27 22:01:34 -07004326 }
4327
Paul Moore389fb8002009-03-27 17:10:34 -04004328 return selinux_netlbl_inet_conn_request(req, family);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004329}
4330
Adrian Bunk9a673e52006-08-15 00:03:53 -07004331static void selinux_inet_csk_clone(struct sock *newsk,
4332 const struct request_sock *req)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004333{
4334 struct sk_security_struct *newsksec = newsk->sk_security;
4335
4336 newsksec->sid = req->secid;
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004337 newsksec->peer_sid = req->peer_secid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004338 /* NOTE: Ideally, we should also get the isec->sid for the
4339 new socket in sync, but we don't have the isec available yet.
4340 So we will wait until sock_graft to do it, by which
4341 time it will have been created and available. */
Paul Moore99f59ed2006-08-29 17:53:48 -07004342
Paul Moore9f2ad662006-11-17 17:38:53 -05004343 /* We don't need to take any sort of lock here as we are the only
4344 * thread with access to newsksec */
Paul Moore389fb8002009-03-27 17:10:34 -04004345 selinux_netlbl_inet_csk_clone(newsk, req->rsk_ops->family);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004346}
4347
Paul Moore014ab192008-10-10 10:16:33 -04004348static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004349{
Paul Mooreaa862902008-10-10 10:16:29 -04004350 u16 family = sk->sk_family;
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004351 struct sk_security_struct *sksec = sk->sk_security;
4352
Paul Mooreaa862902008-10-10 10:16:29 -04004353 /* handle mapped IPv4 packets arriving via IPv6 sockets */
4354 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4355 family = PF_INET;
4356
4357 selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid);
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004358}
4359
Adrian Bunk9a673e52006-08-15 00:03:53 -07004360static void selinux_req_classify_flow(const struct request_sock *req,
4361 struct flowi *fl)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004362{
4363 fl->secid = req->secid;
4364}
4365
Paul Mooreed6d76e2009-08-28 18:12:49 -04004366static int selinux_tun_dev_create(void)
4367{
4368 u32 sid = current_sid();
4369
4370 /* we aren't taking into account the "sockcreate" SID since the socket
4371 * that is being created here is not a socket in the traditional sense,
4372 * instead it is a private sock, accessible only to the kernel, and
4373 * representing a wide range of network traffic spanning multiple
4374 * connections unlike traditional sockets - check the TUN driver to
4375 * get a better understanding of why this socket is special */
4376
4377 return avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__CREATE,
4378 NULL);
4379}
4380
4381static void selinux_tun_dev_post_create(struct sock *sk)
4382{
4383 struct sk_security_struct *sksec = sk->sk_security;
4384
4385 /* we don't currently perform any NetLabel based labeling here and it
4386 * isn't clear that we would want to do so anyway; while we could apply
4387 * labeling without the support of the TUN user the resulting labeled
4388 * traffic from the other end of the connection would almost certainly
4389 * cause confusion to the TUN user that had no idea network labeling
4390 * protocols were being used */
4391
4392 /* see the comments in selinux_tun_dev_create() about why we don't use
4393 * the sockcreate SID here */
4394
4395 sksec->sid = current_sid();
4396 sksec->sclass = SECCLASS_TUN_SOCKET;
4397}
4398
4399static int selinux_tun_dev_attach(struct sock *sk)
4400{
4401 struct sk_security_struct *sksec = sk->sk_security;
4402 u32 sid = current_sid();
4403 int err;
4404
4405 err = avc_has_perm(sid, sksec->sid, SECCLASS_TUN_SOCKET,
4406 TUN_SOCKET__RELABELFROM, NULL);
4407 if (err)
4408 return err;
4409 err = avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET,
4410 TUN_SOCKET__RELABELTO, NULL);
4411 if (err)
4412 return err;
4413
4414 sksec->sid = sid;
4415
4416 return 0;
4417}
4418
Linus Torvalds1da177e2005-04-16 15:20:36 -07004419static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb)
4420{
4421 int err = 0;
4422 u32 perm;
4423 struct nlmsghdr *nlh;
4424 struct socket *sock = sk->sk_socket;
4425 struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
Eric Paris828dfe12008-04-17 13:17:49 -04004426
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427 if (skb->len < NLMSG_SPACE(0)) {
4428 err = -EINVAL;
4429 goto out;
4430 }
Arnaldo Carvalho de Melob529ccf2007-04-25 19:08:35 -07004431 nlh = nlmsg_hdr(skb);
Eric Paris828dfe12008-04-17 13:17:49 -04004432
Linus Torvalds1da177e2005-04-16 15:20:36 -07004433 err = selinux_nlmsg_lookup(isec->sclass, nlh->nlmsg_type, &perm);
4434 if (err) {
4435 if (err == -EINVAL) {
David Woodhouse9ad9ad32005-06-22 15:04:33 +01004436 audit_log(current->audit_context, GFP_KERNEL, AUDIT_SELINUX_ERR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437 "SELinux: unrecognized netlink message"
4438 " type=%hu for sclass=%hu\n",
4439 nlh->nlmsg_type, isec->sclass);
Eric Paris39c9aed2008-11-05 09:34:42 -05004440 if (!selinux_enforcing || security_get_allow_unknown())
Linus Torvalds1da177e2005-04-16 15:20:36 -07004441 err = 0;
4442 }
4443
4444 /* Ignore */
4445 if (err == -ENOENT)
4446 err = 0;
4447 goto out;
4448 }
4449
4450 err = socket_has_perm(current, sock, perm);
4451out:
4452 return err;
4453}
4454
4455#ifdef CONFIG_NETFILTER
4456
Paul Mooreeffad8d2008-01-29 08:49:27 -05004457static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
4458 u16 family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004459{
Paul Mooredfaebe92008-10-10 10:16:31 -04004460 int err;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004461 char *addrp;
4462 u32 peer_sid;
Thomas Liu2bf49692009-07-14 12:14:09 -04004463 struct common_audit_data ad;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004464 u8 secmark_active;
Paul Moore948bf852008-10-10 10:16:32 -04004465 u8 netlbl_active;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004466 u8 peerlbl_active;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004467
Paul Mooreeffad8d2008-01-29 08:49:27 -05004468 if (!selinux_policycap_netpeer)
4469 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004470
Paul Mooreeffad8d2008-01-29 08:49:27 -05004471 secmark_active = selinux_secmark_enabled();
Paul Moore948bf852008-10-10 10:16:32 -04004472 netlbl_active = netlbl_enabled();
4473 peerlbl_active = netlbl_active || selinux_xfrm_enabled();
Paul Mooreeffad8d2008-01-29 08:49:27 -05004474 if (!secmark_active && !peerlbl_active)
4475 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004476
Paul Moored8395c82008-10-10 10:16:30 -04004477 if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
4478 return NF_DROP;
4479
Thomas Liu2bf49692009-07-14 12:14:09 -04004480 COMMON_AUDIT_DATA_INIT(&ad, NET);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004481 ad.u.net.netif = ifindex;
4482 ad.u.net.family = family;
4483 if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0)
4484 return NF_DROP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004485
Paul Mooredfaebe92008-10-10 10:16:31 -04004486 if (peerlbl_active) {
4487 err = selinux_inet_sys_rcv_skb(ifindex, addrp, family,
4488 peer_sid, &ad);
4489 if (err) {
4490 selinux_netlbl_err(skb, err, 1);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004491 return NF_DROP;
Paul Mooredfaebe92008-10-10 10:16:31 -04004492 }
4493 }
Paul Mooreeffad8d2008-01-29 08:49:27 -05004494
4495 if (secmark_active)
4496 if (avc_has_perm(peer_sid, skb->secmark,
4497 SECCLASS_PACKET, PACKET__FORWARD_IN, &ad))
4498 return NF_DROP;
4499
Paul Moore948bf852008-10-10 10:16:32 -04004500 if (netlbl_active)
4501 /* we do this in the FORWARD path and not the POST_ROUTING
4502 * path because we want to make sure we apply the necessary
4503 * labeling before IPsec is applied so we can leverage AH
4504 * protection */
4505 if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0)
4506 return NF_DROP;
4507
Paul Mooreeffad8d2008-01-29 08:49:27 -05004508 return NF_ACCEPT;
4509}
4510
4511static unsigned int selinux_ipv4_forward(unsigned int hooknum,
4512 struct sk_buff *skb,
4513 const struct net_device *in,
4514 const struct net_device *out,
4515 int (*okfn)(struct sk_buff *))
4516{
4517 return selinux_ip_forward(skb, in->ifindex, PF_INET);
4518}
4519
4520#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4521static unsigned int selinux_ipv6_forward(unsigned int hooknum,
4522 struct sk_buff *skb,
4523 const struct net_device *in,
4524 const struct net_device *out,
4525 int (*okfn)(struct sk_buff *))
4526{
4527 return selinux_ip_forward(skb, in->ifindex, PF_INET6);
4528}
4529#endif /* IPV6 */
4530
Paul Moore948bf852008-10-10 10:16:32 -04004531static unsigned int selinux_ip_output(struct sk_buff *skb,
4532 u16 family)
4533{
4534 u32 sid;
4535
4536 if (!netlbl_enabled())
4537 return NF_ACCEPT;
4538
4539 /* we do this in the LOCAL_OUT path and not the POST_ROUTING path
4540 * because we want to make sure we apply the necessary labeling
4541 * before IPsec is applied so we can leverage AH protection */
4542 if (skb->sk) {
4543 struct sk_security_struct *sksec = skb->sk->sk_security;
4544 sid = sksec->sid;
4545 } else
4546 sid = SECINITSID_KERNEL;
4547 if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0)
4548 return NF_DROP;
4549
4550 return NF_ACCEPT;
4551}
4552
4553static unsigned int selinux_ipv4_output(unsigned int hooknum,
4554 struct sk_buff *skb,
4555 const struct net_device *in,
4556 const struct net_device *out,
4557 int (*okfn)(struct sk_buff *))
4558{
4559 return selinux_ip_output(skb, PF_INET);
4560}
4561
Paul Mooreeffad8d2008-01-29 08:49:27 -05004562static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb,
4563 int ifindex,
Paul Moored8395c82008-10-10 10:16:30 -04004564 u16 family)
James Morris4e5ab4c2006-06-09 00:33:33 -07004565{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004566 struct sock *sk = skb->sk;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004567 struct sk_security_struct *sksec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004568 struct common_audit_data ad;
Paul Moored8395c82008-10-10 10:16:30 -04004569 char *addrp;
4570 u8 proto;
James Morris4e5ab4c2006-06-09 00:33:33 -07004571
Paul Mooreeffad8d2008-01-29 08:49:27 -05004572 if (sk == NULL)
4573 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004574 sksec = sk->sk_security;
James Morris4e5ab4c2006-06-09 00:33:33 -07004575
Thomas Liu2bf49692009-07-14 12:14:09 -04004576 COMMON_AUDIT_DATA_INIT(&ad, NET);
Paul Moored8395c82008-10-10 10:16:30 -04004577 ad.u.net.netif = ifindex;
4578 ad.u.net.family = family;
4579 if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
4580 return NF_DROP;
4581
Paul Moore58bfbb52009-03-27 17:10:41 -04004582 if (selinux_secmark_enabled())
Paul Mooreeffad8d2008-01-29 08:49:27 -05004583 if (avc_has_perm(sksec->sid, skb->secmark,
Paul Moored8395c82008-10-10 10:16:30 -04004584 SECCLASS_PACKET, PACKET__SEND, &ad))
Paul Mooreeffad8d2008-01-29 08:49:27 -05004585 return NF_DROP;
James Morris4e5ab4c2006-06-09 00:33:33 -07004586
Paul Mooreeffad8d2008-01-29 08:49:27 -05004587 if (selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004588 if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto))
Paul Mooreeffad8d2008-01-29 08:49:27 -05004589 return NF_DROP;
James Morris4e5ab4c2006-06-09 00:33:33 -07004590
Paul Mooreeffad8d2008-01-29 08:49:27 -05004591 return NF_ACCEPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004592}
4593
Paul Mooreeffad8d2008-01-29 08:49:27 -05004594static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
4595 u16 family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004597 u32 secmark_perm;
4598 u32 peer_sid;
4599 struct sock *sk;
Thomas Liu2bf49692009-07-14 12:14:09 -04004600 struct common_audit_data ad;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004601 char *addrp;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004602 u8 secmark_active;
4603 u8 peerlbl_active;
4604
Paul Mooreeffad8d2008-01-29 08:49:27 -05004605 /* If any sort of compatibility mode is enabled then handoff processing
4606 * to the selinux_ip_postroute_compat() function to deal with the
4607 * special handling. We do this in an attempt to keep this function
4608 * as fast and as clean as possible. */
Paul Moore58bfbb52009-03-27 17:10:41 -04004609 if (!selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004610 return selinux_ip_postroute_compat(skb, ifindex, family);
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07004611#ifdef CONFIG_XFRM
Paul Mooreeffad8d2008-01-29 08:49:27 -05004612 /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec
4613 * packet transformation so allow the packet to pass without any checks
4614 * since we'll have another chance to perform access control checks
4615 * when the packet is on it's final way out.
4616 * NOTE: there appear to be some IPv6 multicast cases where skb->dst
4617 * is NULL, in this case go ahead and apply access control. */
Eric Dumazetadf30902009-06-02 05:19:30 +00004618 if (skb_dst(skb) != NULL && skb_dst(skb)->xfrm != NULL)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004619 return NF_ACCEPT;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07004620#endif
Paul Mooreeffad8d2008-01-29 08:49:27 -05004621 secmark_active = selinux_secmark_enabled();
4622 peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4623 if (!secmark_active && !peerlbl_active)
4624 return NF_ACCEPT;
4625
Paul Moored8395c82008-10-10 10:16:30 -04004626 /* if the packet is being forwarded then get the peer label from the
4627 * packet itself; otherwise check to see if it is from a local
4628 * application or the kernel, if from an application get the peer label
4629 * from the sending socket, otherwise use the kernel's sid */
Paul Mooreeffad8d2008-01-29 08:49:27 -05004630 sk = skb->sk;
Paul Moored8395c82008-10-10 10:16:30 -04004631 if (sk == NULL) {
4632 switch (family) {
4633 case PF_INET:
4634 if (IPCB(skb)->flags & IPSKB_FORWARDED)
4635 secmark_perm = PACKET__FORWARD_OUT;
4636 else
4637 secmark_perm = PACKET__SEND;
4638 break;
4639 case PF_INET6:
4640 if (IP6CB(skb)->flags & IP6SKB_FORWARDED)
4641 secmark_perm = PACKET__FORWARD_OUT;
4642 else
4643 secmark_perm = PACKET__SEND;
4644 break;
4645 default:
4646 return NF_DROP;
4647 }
4648 if (secmark_perm == PACKET__FORWARD_OUT) {
4649 if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
4650 return NF_DROP;
4651 } else
4652 peer_sid = SECINITSID_KERNEL;
4653 } else {
Paul Mooreeffad8d2008-01-29 08:49:27 -05004654 struct sk_security_struct *sksec = sk->sk_security;
4655 peer_sid = sksec->sid;
4656 secmark_perm = PACKET__SEND;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004657 }
4658
Thomas Liu2bf49692009-07-14 12:14:09 -04004659 COMMON_AUDIT_DATA_INIT(&ad, NET);
Paul Moored8395c82008-10-10 10:16:30 -04004660 ad.u.net.netif = ifindex;
4661 ad.u.net.family = family;
4662 if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL))
4663 return NF_DROP;
4664
Paul Mooreeffad8d2008-01-29 08:49:27 -05004665 if (secmark_active)
4666 if (avc_has_perm(peer_sid, skb->secmark,
4667 SECCLASS_PACKET, secmark_perm, &ad))
4668 return NF_DROP;
4669
4670 if (peerlbl_active) {
4671 u32 if_sid;
4672 u32 node_sid;
4673
4674 if (sel_netif_sid(ifindex, &if_sid))
4675 return NF_DROP;
4676 if (avc_has_perm(peer_sid, if_sid,
4677 SECCLASS_NETIF, NETIF__EGRESS, &ad))
4678 return NF_DROP;
4679
4680 if (sel_netnode_sid(addrp, family, &node_sid))
4681 return NF_DROP;
4682 if (avc_has_perm(peer_sid, node_sid,
4683 SECCLASS_NODE, NODE__SENDTO, &ad))
4684 return NF_DROP;
4685 }
4686
4687 return NF_ACCEPT;
4688}
4689
4690static unsigned int selinux_ipv4_postroute(unsigned int hooknum,
4691 struct sk_buff *skb,
4692 const struct net_device *in,
4693 const struct net_device *out,
4694 int (*okfn)(struct sk_buff *))
4695{
4696 return selinux_ip_postroute(skb, out->ifindex, PF_INET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004697}
4698
4699#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004700static unsigned int selinux_ipv6_postroute(unsigned int hooknum,
4701 struct sk_buff *skb,
4702 const struct net_device *in,
4703 const struct net_device *out,
4704 int (*okfn)(struct sk_buff *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004705{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004706 return selinux_ip_postroute(skb, out->ifindex, PF_INET6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004707}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004708#endif /* IPV6 */
4709
4710#endif /* CONFIG_NETFILTER */
4711
Linus Torvalds1da177e2005-04-16 15:20:36 -07004712static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb)
4713{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004714 int err;
4715
Eric Paris200ac532009-02-12 15:01:04 -05004716 err = cap_netlink_send(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004717 if (err)
4718 return err;
4719
Stephen Smalley941fc5b2009-10-01 14:48:23 -04004720 return selinux_nlmsg_perm(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004721}
4722
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004723static int selinux_netlink_recv(struct sk_buff *skb, int capability)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004724{
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004725 int err;
Thomas Liu2bf49692009-07-14 12:14:09 -04004726 struct common_audit_data ad;
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004727
Eric Paris200ac532009-02-12 15:01:04 -05004728 err = cap_netlink_recv(skb, capability);
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004729 if (err)
4730 return err;
4731
Thomas Liu2bf49692009-07-14 12:14:09 -04004732 COMMON_AUDIT_DATA_INIT(&ad, CAP);
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004733 ad.u.cap = capability;
4734
4735 return avc_has_perm(NETLINK_CB(skb).sid, NETLINK_CB(skb).sid,
Eric Paris828dfe12008-04-17 13:17:49 -04004736 SECCLASS_CAPABILITY, CAP_TO_MASK(capability), &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004737}
4738
4739static int ipc_alloc_security(struct task_struct *task,
4740 struct kern_ipc_perm *perm,
4741 u16 sclass)
4742{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004743 struct ipc_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +11004744 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004745
James Morris89d155e2005-10-30 14:59:21 -08004746 isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004747 if (!isec)
4748 return -ENOMEM;
4749
David Howells275bb412008-11-14 10:39:19 +11004750 sid = task_sid(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004751 isec->sclass = sclass;
David Howells275bb412008-11-14 10:39:19 +11004752 isec->sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004753 perm->security = isec;
4754
4755 return 0;
4756}
4757
4758static void ipc_free_security(struct kern_ipc_perm *perm)
4759{
4760 struct ipc_security_struct *isec = perm->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004761 perm->security = NULL;
4762 kfree(isec);
4763}
4764
4765static int msg_msg_alloc_security(struct msg_msg *msg)
4766{
4767 struct msg_security_struct *msec;
4768
James Morris89d155e2005-10-30 14:59:21 -08004769 msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004770 if (!msec)
4771 return -ENOMEM;
4772
Linus Torvalds1da177e2005-04-16 15:20:36 -07004773 msec->sid = SECINITSID_UNLABELED;
4774 msg->security = msec;
4775
4776 return 0;
4777}
4778
4779static void msg_msg_free_security(struct msg_msg *msg)
4780{
4781 struct msg_security_struct *msec = msg->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004782
4783 msg->security = NULL;
4784 kfree(msec);
4785}
4786
4787static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
Stephen Smalley6af963f2005-05-01 08:58:39 -07004788 u32 perms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004789{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004790 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004791 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004792 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004793
Linus Torvalds1da177e2005-04-16 15:20:36 -07004794 isec = ipc_perms->security;
4795
Thomas Liu2bf49692009-07-14 12:14:09 -04004796 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797 ad.u.ipc_id = ipc_perms->key;
4798
David Howells275bb412008-11-14 10:39:19 +11004799 return avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004800}
4801
4802static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
4803{
4804 return msg_msg_alloc_security(msg);
4805}
4806
4807static void selinux_msg_msg_free_security(struct msg_msg *msg)
4808{
4809 msg_msg_free_security(msg);
4810}
4811
4812/* message queue security operations */
4813static int selinux_msg_queue_alloc_security(struct msg_queue *msq)
4814{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004815 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004816 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004817 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004818 int rc;
4819
4820 rc = ipc_alloc_security(current, &msq->q_perm, SECCLASS_MSGQ);
4821 if (rc)
4822 return rc;
4823
Linus Torvalds1da177e2005-04-16 15:20:36 -07004824 isec = msq->q_perm.security;
4825
Thomas Liu2bf49692009-07-14 12:14:09 -04004826 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004827 ad.u.ipc_id = msq->q_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004828
David Howells275bb412008-11-14 10:39:19 +11004829 rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004830 MSGQ__CREATE, &ad);
4831 if (rc) {
4832 ipc_free_security(&msq->q_perm);
4833 return rc;
4834 }
4835 return 0;
4836}
4837
4838static void selinux_msg_queue_free_security(struct msg_queue *msq)
4839{
4840 ipc_free_security(&msq->q_perm);
4841}
4842
4843static int selinux_msg_queue_associate(struct msg_queue *msq, int msqflg)
4844{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004845 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004846 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004847 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004848
Linus Torvalds1da177e2005-04-16 15:20:36 -07004849 isec = msq->q_perm.security;
4850
Thomas Liu2bf49692009-07-14 12:14:09 -04004851 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004852 ad.u.ipc_id = msq->q_perm.key;
4853
David Howells275bb412008-11-14 10:39:19 +11004854 return avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004855 MSGQ__ASSOCIATE, &ad);
4856}
4857
4858static int selinux_msg_queue_msgctl(struct msg_queue *msq, int cmd)
4859{
4860 int err;
4861 int perms;
4862
Eric Paris828dfe12008-04-17 13:17:49 -04004863 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004864 case IPC_INFO:
4865 case MSG_INFO:
4866 /* No specific object, just general system-wide information. */
4867 return task_has_system(current, SYSTEM__IPC_INFO);
4868 case IPC_STAT:
4869 case MSG_STAT:
4870 perms = MSGQ__GETATTR | MSGQ__ASSOCIATE;
4871 break;
4872 case IPC_SET:
4873 perms = MSGQ__SETATTR;
4874 break;
4875 case IPC_RMID:
4876 perms = MSGQ__DESTROY;
4877 break;
4878 default:
4879 return 0;
4880 }
4881
Stephen Smalley6af963f2005-05-01 08:58:39 -07004882 err = ipc_has_perm(&msq->q_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004883 return err;
4884}
4885
4886static int selinux_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, int msqflg)
4887{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004888 struct ipc_security_struct *isec;
4889 struct msg_security_struct *msec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004890 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004891 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004892 int rc;
4893
Linus Torvalds1da177e2005-04-16 15:20:36 -07004894 isec = msq->q_perm.security;
4895 msec = msg->security;
4896
4897 /*
4898 * First time through, need to assign label to the message
4899 */
4900 if (msec->sid == SECINITSID_UNLABELED) {
4901 /*
4902 * Compute new sid based on current process and
4903 * message queue this message will be stored in
4904 */
David Howells275bb412008-11-14 10:39:19 +11004905 rc = security_transition_sid(sid, isec->sid, SECCLASS_MSG,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004906 &msec->sid);
4907 if (rc)
4908 return rc;
4909 }
4910
Thomas Liu2bf49692009-07-14 12:14:09 -04004911 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004912 ad.u.ipc_id = msq->q_perm.key;
4913
4914 /* Can this process write to the queue? */
David Howells275bb412008-11-14 10:39:19 +11004915 rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004916 MSGQ__WRITE, &ad);
4917 if (!rc)
4918 /* Can this process send the message */
David Howells275bb412008-11-14 10:39:19 +11004919 rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG,
4920 MSG__SEND, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004921 if (!rc)
4922 /* Can the message be put in the queue? */
David Howells275bb412008-11-14 10:39:19 +11004923 rc = avc_has_perm(msec->sid, isec->sid, SECCLASS_MSGQ,
4924 MSGQ__ENQUEUE, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004925
4926 return rc;
4927}
4928
4929static int selinux_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
4930 struct task_struct *target,
4931 long type, int mode)
4932{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004933 struct ipc_security_struct *isec;
4934 struct msg_security_struct *msec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004935 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004936 u32 sid = task_sid(target);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004937 int rc;
4938
Linus Torvalds1da177e2005-04-16 15:20:36 -07004939 isec = msq->q_perm.security;
4940 msec = msg->security;
4941
Thomas Liu2bf49692009-07-14 12:14:09 -04004942 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004943 ad.u.ipc_id = msq->q_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004944
David Howells275bb412008-11-14 10:39:19 +11004945 rc = avc_has_perm(sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004946 SECCLASS_MSGQ, MSGQ__READ, &ad);
4947 if (!rc)
David Howells275bb412008-11-14 10:39:19 +11004948 rc = avc_has_perm(sid, msec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004949 SECCLASS_MSG, MSG__RECEIVE, &ad);
4950 return rc;
4951}
4952
4953/* Shared Memory security operations */
4954static int selinux_shm_alloc_security(struct shmid_kernel *shp)
4955{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004956 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004957 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004958 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004959 int rc;
4960
4961 rc = ipc_alloc_security(current, &shp->shm_perm, SECCLASS_SHM);
4962 if (rc)
4963 return rc;
4964
Linus Torvalds1da177e2005-04-16 15:20:36 -07004965 isec = shp->shm_perm.security;
4966
Thomas Liu2bf49692009-07-14 12:14:09 -04004967 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004968 ad.u.ipc_id = shp->shm_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004969
David Howells275bb412008-11-14 10:39:19 +11004970 rc = avc_has_perm(sid, isec->sid, SECCLASS_SHM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004971 SHM__CREATE, &ad);
4972 if (rc) {
4973 ipc_free_security(&shp->shm_perm);
4974 return rc;
4975 }
4976 return 0;
4977}
4978
4979static void selinux_shm_free_security(struct shmid_kernel *shp)
4980{
4981 ipc_free_security(&shp->shm_perm);
4982}
4983
4984static int selinux_shm_associate(struct shmid_kernel *shp, int shmflg)
4985{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004986 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04004987 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004988 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004989
Linus Torvalds1da177e2005-04-16 15:20:36 -07004990 isec = shp->shm_perm.security;
4991
Thomas Liu2bf49692009-07-14 12:14:09 -04004992 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004993 ad.u.ipc_id = shp->shm_perm.key;
4994
David Howells275bb412008-11-14 10:39:19 +11004995 return avc_has_perm(sid, isec->sid, SECCLASS_SHM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004996 SHM__ASSOCIATE, &ad);
4997}
4998
4999/* Note, at this point, shp is locked down */
5000static int selinux_shm_shmctl(struct shmid_kernel *shp, int cmd)
5001{
5002 int perms;
5003 int err;
5004
Eric Paris828dfe12008-04-17 13:17:49 -04005005 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005006 case IPC_INFO:
5007 case SHM_INFO:
5008 /* No specific object, just general system-wide information. */
5009 return task_has_system(current, SYSTEM__IPC_INFO);
5010 case IPC_STAT:
5011 case SHM_STAT:
5012 perms = SHM__GETATTR | SHM__ASSOCIATE;
5013 break;
5014 case IPC_SET:
5015 perms = SHM__SETATTR;
5016 break;
5017 case SHM_LOCK:
5018 case SHM_UNLOCK:
5019 perms = SHM__LOCK;
5020 break;
5021 case IPC_RMID:
5022 perms = SHM__DESTROY;
5023 break;
5024 default:
5025 return 0;
5026 }
5027
Stephen Smalley6af963f2005-05-01 08:58:39 -07005028 err = ipc_has_perm(&shp->shm_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005029 return err;
5030}
5031
5032static int selinux_shm_shmat(struct shmid_kernel *shp,
5033 char __user *shmaddr, int shmflg)
5034{
5035 u32 perms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005036
5037 if (shmflg & SHM_RDONLY)
5038 perms = SHM__READ;
5039 else
5040 perms = SHM__READ | SHM__WRITE;
5041
Stephen Smalley6af963f2005-05-01 08:58:39 -07005042 return ipc_has_perm(&shp->shm_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005043}
5044
5045/* Semaphore security operations */
5046static int selinux_sem_alloc_security(struct sem_array *sma)
5047{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005048 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04005049 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11005050 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005051 int rc;
5052
5053 rc = ipc_alloc_security(current, &sma->sem_perm, SECCLASS_SEM);
5054 if (rc)
5055 return rc;
5056
Linus Torvalds1da177e2005-04-16 15:20:36 -07005057 isec = sma->sem_perm.security;
5058
Thomas Liu2bf49692009-07-14 12:14:09 -04005059 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04005060 ad.u.ipc_id = sma->sem_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005061
David Howells275bb412008-11-14 10:39:19 +11005062 rc = avc_has_perm(sid, isec->sid, SECCLASS_SEM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005063 SEM__CREATE, &ad);
5064 if (rc) {
5065 ipc_free_security(&sma->sem_perm);
5066 return rc;
5067 }
5068 return 0;
5069}
5070
5071static void selinux_sem_free_security(struct sem_array *sma)
5072{
5073 ipc_free_security(&sma->sem_perm);
5074}
5075
5076static int selinux_sem_associate(struct sem_array *sma, int semflg)
5077{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005078 struct ipc_security_struct *isec;
Thomas Liu2bf49692009-07-14 12:14:09 -04005079 struct common_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11005080 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005081
Linus Torvalds1da177e2005-04-16 15:20:36 -07005082 isec = sma->sem_perm.security;
5083
Thomas Liu2bf49692009-07-14 12:14:09 -04005084 COMMON_AUDIT_DATA_INIT(&ad, IPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005085 ad.u.ipc_id = sma->sem_perm.key;
5086
David Howells275bb412008-11-14 10:39:19 +11005087 return avc_has_perm(sid, isec->sid, SECCLASS_SEM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005088 SEM__ASSOCIATE, &ad);
5089}
5090
5091/* Note, at this point, sma is locked down */
5092static int selinux_sem_semctl(struct sem_array *sma, int cmd)
5093{
5094 int err;
5095 u32 perms;
5096
Eric Paris828dfe12008-04-17 13:17:49 -04005097 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005098 case IPC_INFO:
5099 case SEM_INFO:
5100 /* No specific object, just general system-wide information. */
5101 return task_has_system(current, SYSTEM__IPC_INFO);
5102 case GETPID:
5103 case GETNCNT:
5104 case GETZCNT:
5105 perms = SEM__GETATTR;
5106 break;
5107 case GETVAL:
5108 case GETALL:
5109 perms = SEM__READ;
5110 break;
5111 case SETVAL:
5112 case SETALL:
5113 perms = SEM__WRITE;
5114 break;
5115 case IPC_RMID:
5116 perms = SEM__DESTROY;
5117 break;
5118 case IPC_SET:
5119 perms = SEM__SETATTR;
5120 break;
5121 case IPC_STAT:
5122 case SEM_STAT:
5123 perms = SEM__GETATTR | SEM__ASSOCIATE;
5124 break;
5125 default:
5126 return 0;
5127 }
5128
Stephen Smalley6af963f2005-05-01 08:58:39 -07005129 err = ipc_has_perm(&sma->sem_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005130 return err;
5131}
5132
5133static int selinux_sem_semop(struct sem_array *sma,
5134 struct sembuf *sops, unsigned nsops, int alter)
5135{
5136 u32 perms;
5137
5138 if (alter)
5139 perms = SEM__READ | SEM__WRITE;
5140 else
5141 perms = SEM__READ;
5142
Stephen Smalley6af963f2005-05-01 08:58:39 -07005143 return ipc_has_perm(&sma->sem_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005144}
5145
5146static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
5147{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005148 u32 av = 0;
5149
Linus Torvalds1da177e2005-04-16 15:20:36 -07005150 av = 0;
5151 if (flag & S_IRUGO)
5152 av |= IPC__UNIX_READ;
5153 if (flag & S_IWUGO)
5154 av |= IPC__UNIX_WRITE;
5155
5156 if (av == 0)
5157 return 0;
5158
Stephen Smalley6af963f2005-05-01 08:58:39 -07005159 return ipc_has_perm(ipcp, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005160}
5161
Ahmed S. Darwish713a04ae2008-03-01 21:52:30 +02005162static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
5163{
5164 struct ipc_security_struct *isec = ipcp->security;
5165 *secid = isec->sid;
5166}
5167
Eric Paris828dfe12008-04-17 13:17:49 -04005168static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005169{
5170 if (inode)
5171 inode_doinit_with_dentry(inode, dentry);
5172}
5173
5174static int selinux_getprocattr(struct task_struct *p,
Al Viro04ff9702007-03-12 16:17:58 +00005175 char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005176{
David Howells275bb412008-11-14 10:39:19 +11005177 const struct task_security_struct *__tsec;
Dustin Kirkland8c8570f2005-11-03 17:15:16 +00005178 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005179 int error;
Al Viro04ff9702007-03-12 16:17:58 +00005180 unsigned len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005181
5182 if (current != p) {
David Howells3b11a1d2008-11-14 10:39:26 +11005183 error = current_has_perm(p, PROCESS__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005184 if (error)
5185 return error;
5186 }
5187
David Howells275bb412008-11-14 10:39:19 +11005188 rcu_read_lock();
5189 __tsec = __task_cred(p)->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005190
5191 if (!strcmp(name, "current"))
David Howells275bb412008-11-14 10:39:19 +11005192 sid = __tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005193 else if (!strcmp(name, "prev"))
David Howells275bb412008-11-14 10:39:19 +11005194 sid = __tsec->osid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005195 else if (!strcmp(name, "exec"))
David Howells275bb412008-11-14 10:39:19 +11005196 sid = __tsec->exec_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005197 else if (!strcmp(name, "fscreate"))
David Howells275bb412008-11-14 10:39:19 +11005198 sid = __tsec->create_sid;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005199 else if (!strcmp(name, "keycreate"))
David Howells275bb412008-11-14 10:39:19 +11005200 sid = __tsec->keycreate_sid;
Eric Paris42c3e032006-06-26 00:26:03 -07005201 else if (!strcmp(name, "sockcreate"))
David Howells275bb412008-11-14 10:39:19 +11005202 sid = __tsec->sockcreate_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005203 else
David Howells275bb412008-11-14 10:39:19 +11005204 goto invalid;
5205 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005206
5207 if (!sid)
5208 return 0;
5209
Al Viro04ff9702007-03-12 16:17:58 +00005210 error = security_sid_to_context(sid, value, &len);
5211 if (error)
5212 return error;
5213 return len;
David Howells275bb412008-11-14 10:39:19 +11005214
5215invalid:
5216 rcu_read_unlock();
5217 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005218}
5219
5220static int selinux_setprocattr(struct task_struct *p,
5221 char *name, void *value, size_t size)
5222{
5223 struct task_security_struct *tsec;
Roland McGrath03563572008-03-26 15:46:39 -07005224 struct task_struct *tracer;
David Howellsd84f4f92008-11-14 10:39:23 +11005225 struct cred *new;
5226 u32 sid = 0, ptsid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005227 int error;
5228 char *str = value;
5229
5230 if (current != p) {
5231 /* SELinux only allows a process to change its own
5232 security attributes. */
5233 return -EACCES;
5234 }
5235
5236 /*
5237 * Basic control over ability to set these attributes at all.
5238 * current == p, but we'll pass them separately in case the
5239 * above restriction is ever removed.
5240 */
5241 if (!strcmp(name, "exec"))
David Howells3b11a1d2008-11-14 10:39:26 +11005242 error = current_has_perm(p, PROCESS__SETEXEC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005243 else if (!strcmp(name, "fscreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005244 error = current_has_perm(p, PROCESS__SETFSCREATE);
Michael LeMay4eb582c2006-06-26 00:24:57 -07005245 else if (!strcmp(name, "keycreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005246 error = current_has_perm(p, PROCESS__SETKEYCREATE);
Eric Paris42c3e032006-06-26 00:26:03 -07005247 else if (!strcmp(name, "sockcreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005248 error = current_has_perm(p, PROCESS__SETSOCKCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005249 else if (!strcmp(name, "current"))
David Howells3b11a1d2008-11-14 10:39:26 +11005250 error = current_has_perm(p, PROCESS__SETCURRENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005251 else
5252 error = -EINVAL;
5253 if (error)
5254 return error;
5255
5256 /* Obtain a SID for the context, if one was specified. */
5257 if (size && str[1] && str[1] != '\n') {
5258 if (str[size-1] == '\n') {
5259 str[size-1] = 0;
5260 size--;
5261 }
5262 error = security_context_to_sid(value, size, &sid);
Stephen Smalley12b29f32008-05-07 13:03:20 -04005263 if (error == -EINVAL && !strcmp(name, "fscreate")) {
5264 if (!capable(CAP_MAC_ADMIN))
5265 return error;
5266 error = security_context_to_sid_force(value, size,
5267 &sid);
5268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005269 if (error)
5270 return error;
5271 }
5272
David Howellsd84f4f92008-11-14 10:39:23 +11005273 new = prepare_creds();
5274 if (!new)
5275 return -ENOMEM;
5276
Linus Torvalds1da177e2005-04-16 15:20:36 -07005277 /* Permission checking based on the specified context is
5278 performed during the actual operation (execve,
5279 open/mkdir/...), when we know the full context of the
David Howellsd84f4f92008-11-14 10:39:23 +11005280 operation. See selinux_bprm_set_creds for the execve
Linus Torvalds1da177e2005-04-16 15:20:36 -07005281 checks and may_create for the file creation checks. The
5282 operation will then fail if the context is not permitted. */
David Howellsd84f4f92008-11-14 10:39:23 +11005283 tsec = new->security;
5284 if (!strcmp(name, "exec")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005285 tsec->exec_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005286 } else if (!strcmp(name, "fscreate")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005287 tsec->create_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005288 } else if (!strcmp(name, "keycreate")) {
Michael LeMay4eb582c2006-06-26 00:24:57 -07005289 error = may_create_key(sid, p);
5290 if (error)
David Howellsd84f4f92008-11-14 10:39:23 +11005291 goto abort_change;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005292 tsec->keycreate_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005293 } else if (!strcmp(name, "sockcreate")) {
Eric Paris42c3e032006-06-26 00:26:03 -07005294 tsec->sockcreate_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005295 } else if (!strcmp(name, "current")) {
5296 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005297 if (sid == 0)
David Howellsd84f4f92008-11-14 10:39:23 +11005298 goto abort_change;
KaiGai Koheid9250de2008-08-28 16:35:57 +09005299
David Howellsd84f4f92008-11-14 10:39:23 +11005300 /* Only allow single threaded processes to change context */
5301 error = -EPERM;
Oleg Nesterov5bb459b2009-07-10 03:48:23 +02005302 if (!current_is_single_threaded()) {
David Howellsd84f4f92008-11-14 10:39:23 +11005303 error = security_bounded_transition(tsec->sid, sid);
5304 if (error)
5305 goto abort_change;
Eric Paris828dfe12008-04-17 13:17:49 -04005306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005307
5308 /* Check permissions for the transition. */
5309 error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
Eric Paris828dfe12008-04-17 13:17:49 -04005310 PROCESS__DYNTRANSITION, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005311 if (error)
David Howellsd84f4f92008-11-14 10:39:23 +11005312 goto abort_change;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005313
5314 /* Check for ptracing, and update the task SID if ok.
5315 Otherwise, leave SID unchanged and fail. */
David Howellsd84f4f92008-11-14 10:39:23 +11005316 ptsid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005317 task_lock(p);
Roland McGrath0d094ef2008-07-25 19:45:49 -07005318 tracer = tracehook_tracer_task(p);
David Howellsd84f4f92008-11-14 10:39:23 +11005319 if (tracer)
5320 ptsid = task_sid(tracer);
5321 task_unlock(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005322
David Howellsd84f4f92008-11-14 10:39:23 +11005323 if (tracer) {
5324 error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS,
5325 PROCESS__PTRACE, NULL);
5326 if (error)
5327 goto abort_change;
5328 }
5329
5330 tsec->sid = sid;
5331 } else {
5332 error = -EINVAL;
5333 goto abort_change;
5334 }
5335
5336 commit_creds(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005337 return size;
David Howellsd84f4f92008-11-14 10:39:23 +11005338
5339abort_change:
5340 abort_creds(new);
5341 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005342}
5343
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005344static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
5345{
5346 return security_sid_to_context(secid, secdata, seclen);
5347}
5348
David Howells7bf570d2008-04-29 20:52:51 +01005349static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
David Howells63cb3442008-01-15 23:47:35 +00005350{
5351 return security_context_to_sid(secdata, seclen, secid);
5352}
5353
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005354static void selinux_release_secctx(char *secdata, u32 seclen)
5355{
Paul Moore088999e2007-08-01 11:12:58 -04005356 kfree(secdata);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005357}
5358
David P. Quigley1ee65e32009-09-03 14:25:57 -04005359/*
5360 * called with inode->i_mutex locked
5361 */
5362static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
5363{
5364 return selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, ctxlen, 0);
5365}
5366
5367/*
5368 * called with inode->i_mutex locked
5369 */
5370static int selinux_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
5371{
5372 return __vfs_setxattr_noperm(dentry, XATTR_NAME_SELINUX, ctx, ctxlen, 0);
5373}
5374
5375static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
5376{
5377 int len = 0;
5378 len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX,
5379 ctx, true);
5380 if (len < 0)
5381 return len;
5382 *ctxlen = len;
5383 return 0;
5384}
Michael LeMayd7200242006-06-22 14:47:17 -07005385#ifdef CONFIG_KEYS
5386
David Howellsd84f4f92008-11-14 10:39:23 +11005387static int selinux_key_alloc(struct key *k, const struct cred *cred,
David Howells7e047ef2006-06-26 00:24:50 -07005388 unsigned long flags)
Michael LeMayd7200242006-06-22 14:47:17 -07005389{
David Howellsd84f4f92008-11-14 10:39:23 +11005390 const struct task_security_struct *tsec;
Michael LeMayd7200242006-06-22 14:47:17 -07005391 struct key_security_struct *ksec;
5392
5393 ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
5394 if (!ksec)
5395 return -ENOMEM;
5396
David Howellsd84f4f92008-11-14 10:39:23 +11005397 tsec = cred->security;
5398 if (tsec->keycreate_sid)
5399 ksec->sid = tsec->keycreate_sid;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005400 else
David Howellsd84f4f92008-11-14 10:39:23 +11005401 ksec->sid = tsec->sid;
Michael LeMayd7200242006-06-22 14:47:17 -07005402
David Howells275bb412008-11-14 10:39:19 +11005403 k->security = ksec;
Michael LeMayd7200242006-06-22 14:47:17 -07005404 return 0;
5405}
5406
5407static void selinux_key_free(struct key *k)
5408{
5409 struct key_security_struct *ksec = k->security;
5410
5411 k->security = NULL;
5412 kfree(ksec);
5413}
5414
5415static int selinux_key_permission(key_ref_t key_ref,
David Howellsd84f4f92008-11-14 10:39:23 +11005416 const struct cred *cred,
5417 key_perm_t perm)
Michael LeMayd7200242006-06-22 14:47:17 -07005418{
5419 struct key *key;
Michael LeMayd7200242006-06-22 14:47:17 -07005420 struct key_security_struct *ksec;
David Howells275bb412008-11-14 10:39:19 +11005421 u32 sid;
Michael LeMayd7200242006-06-22 14:47:17 -07005422
5423 /* if no specific permissions are requested, we skip the
5424 permission check. No serious, additional covert channels
5425 appear to be created. */
5426 if (perm == 0)
5427 return 0;
5428
David Howellsd84f4f92008-11-14 10:39:23 +11005429 sid = cred_sid(cred);
David Howells275bb412008-11-14 10:39:19 +11005430
5431 key = key_ref_to_ptr(key_ref);
5432 ksec = key->security;
5433
5434 return avc_has_perm(sid, ksec->sid, SECCLASS_KEY, perm, NULL);
Michael LeMayd7200242006-06-22 14:47:17 -07005435}
5436
David Howells70a5bb72008-04-29 01:01:26 -07005437static int selinux_key_getsecurity(struct key *key, char **_buffer)
5438{
5439 struct key_security_struct *ksec = key->security;
5440 char *context = NULL;
5441 unsigned len;
5442 int rc;
5443
5444 rc = security_sid_to_context(ksec->sid, &context, &len);
5445 if (!rc)
5446 rc = len;
5447 *_buffer = context;
5448 return rc;
5449}
5450
Michael LeMayd7200242006-06-22 14:47:17 -07005451#endif
5452
Linus Torvalds1da177e2005-04-16 15:20:36 -07005453static struct security_operations selinux_ops = {
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02005454 .name = "selinux",
5455
Ingo Molnar9e488582009-05-07 19:26:19 +10005456 .ptrace_access_check = selinux_ptrace_access_check,
David Howells5cd9c582008-08-14 11:37:28 +01005457 .ptrace_traceme = selinux_ptrace_traceme,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005458 .capget = selinux_capget,
David Howellsd84f4f92008-11-14 10:39:23 +11005459 .capset = selinux_capset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005460 .sysctl = selinux_sysctl,
5461 .capable = selinux_capable,
5462 .quotactl = selinux_quotactl,
5463 .quota_on = selinux_quota_on,
5464 .syslog = selinux_syslog,
5465 .vm_enough_memory = selinux_vm_enough_memory,
5466
5467 .netlink_send = selinux_netlink_send,
Eric Paris828dfe12008-04-17 13:17:49 -04005468 .netlink_recv = selinux_netlink_recv,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005469
David Howellsa6f76f22008-11-14 10:39:24 +11005470 .bprm_set_creds = selinux_bprm_set_creds,
David Howellsa6f76f22008-11-14 10:39:24 +11005471 .bprm_committing_creds = selinux_bprm_committing_creds,
5472 .bprm_committed_creds = selinux_bprm_committed_creds,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005473 .bprm_secureexec = selinux_bprm_secureexec,
5474
5475 .sb_alloc_security = selinux_sb_alloc_security,
5476 .sb_free_security = selinux_sb_free_security,
5477 .sb_copy_data = selinux_sb_copy_data,
Eric Paris828dfe12008-04-17 13:17:49 -04005478 .sb_kern_mount = selinux_sb_kern_mount,
Eric Paris2069f452008-07-04 09:47:13 +10005479 .sb_show_options = selinux_sb_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005480 .sb_statfs = selinux_sb_statfs,
5481 .sb_mount = selinux_mount,
5482 .sb_umount = selinux_umount,
Eric Parisc9180a52007-11-30 13:00:35 -05005483 .sb_set_mnt_opts = selinux_set_mnt_opts,
Eric Paris828dfe12008-04-17 13:17:49 -04005484 .sb_clone_mnt_opts = selinux_sb_clone_mnt_opts,
Eric Parise0007522008-03-05 10:31:54 -05005485 .sb_parse_opts_str = selinux_parse_opts_str,
5486
Linus Torvalds1da177e2005-04-16 15:20:36 -07005487
5488 .inode_alloc_security = selinux_inode_alloc_security,
5489 .inode_free_security = selinux_inode_free_security,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07005490 .inode_init_security = selinux_inode_init_security,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005491 .inode_create = selinux_inode_create,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005492 .inode_link = selinux_inode_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005493 .inode_unlink = selinux_inode_unlink,
5494 .inode_symlink = selinux_inode_symlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005495 .inode_mkdir = selinux_inode_mkdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005496 .inode_rmdir = selinux_inode_rmdir,
5497 .inode_mknod = selinux_inode_mknod,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005498 .inode_rename = selinux_inode_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005499 .inode_readlink = selinux_inode_readlink,
5500 .inode_follow_link = selinux_inode_follow_link,
5501 .inode_permission = selinux_inode_permission,
5502 .inode_setattr = selinux_inode_setattr,
5503 .inode_getattr = selinux_inode_getattr,
5504 .inode_setxattr = selinux_inode_setxattr,
5505 .inode_post_setxattr = selinux_inode_post_setxattr,
5506 .inode_getxattr = selinux_inode_getxattr,
5507 .inode_listxattr = selinux_inode_listxattr,
5508 .inode_removexattr = selinux_inode_removexattr,
Eric Paris828dfe12008-04-17 13:17:49 -04005509 .inode_getsecurity = selinux_inode_getsecurity,
5510 .inode_setsecurity = selinux_inode_setsecurity,
5511 .inode_listsecurity = selinux_inode_listsecurity,
Eric Parisf5269712008-05-14 11:27:45 -04005512 .inode_getsecid = selinux_inode_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005513
5514 .file_permission = selinux_file_permission,
5515 .file_alloc_security = selinux_file_alloc_security,
5516 .file_free_security = selinux_file_free_security,
5517 .file_ioctl = selinux_file_ioctl,
5518 .file_mmap = selinux_file_mmap,
5519 .file_mprotect = selinux_file_mprotect,
5520 .file_lock = selinux_file_lock,
5521 .file_fcntl = selinux_file_fcntl,
5522 .file_set_fowner = selinux_file_set_fowner,
5523 .file_send_sigiotask = selinux_file_send_sigiotask,
5524 .file_receive = selinux_file_receive,
5525
Eric Paris828dfe12008-04-17 13:17:49 -04005526 .dentry_open = selinux_dentry_open,
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09005527
Linus Torvalds1da177e2005-04-16 15:20:36 -07005528 .task_create = selinux_task_create,
David Howellsee18d642009-09-02 09:14:21 +01005529 .cred_alloc_blank = selinux_cred_alloc_blank,
David Howellsf1752ee2008-11-14 10:39:17 +11005530 .cred_free = selinux_cred_free,
David Howellsd84f4f92008-11-14 10:39:23 +11005531 .cred_prepare = selinux_cred_prepare,
David Howellsee18d642009-09-02 09:14:21 +01005532 .cred_transfer = selinux_cred_transfer,
David Howells3a3b7ce2008-11-14 10:39:28 +11005533 .kernel_act_as = selinux_kernel_act_as,
5534 .kernel_create_files_as = selinux_kernel_create_files_as,
Eric Paris25354c42009-08-13 09:45:03 -04005535 .kernel_module_request = selinux_kernel_module_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005536 .task_setpgid = selinux_task_setpgid,
5537 .task_getpgid = selinux_task_getpgid,
Eric Paris828dfe12008-04-17 13:17:49 -04005538 .task_getsid = selinux_task_getsid,
David Quigleyf9008e42006-06-30 01:55:46 -07005539 .task_getsecid = selinux_task_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005540 .task_setnice = selinux_task_setnice,
James Morris03e68062006-06-23 02:03:58 -07005541 .task_setioprio = selinux_task_setioprio,
David Quigleya1836a42006-06-30 01:55:49 -07005542 .task_getioprio = selinux_task_getioprio,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005543 .task_setrlimit = selinux_task_setrlimit,
5544 .task_setscheduler = selinux_task_setscheduler,
5545 .task_getscheduler = selinux_task_getscheduler,
David Quigley35601542006-06-23 02:04:01 -07005546 .task_movememory = selinux_task_movememory,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005547 .task_kill = selinux_task_kill,
5548 .task_wait = selinux_task_wait,
Eric Paris828dfe12008-04-17 13:17:49 -04005549 .task_to_inode = selinux_task_to_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005550
5551 .ipc_permission = selinux_ipc_permission,
Eric Parisf5269712008-05-14 11:27:45 -04005552 .ipc_getsecid = selinux_ipc_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005553
5554 .msg_msg_alloc_security = selinux_msg_msg_alloc_security,
5555 .msg_msg_free_security = selinux_msg_msg_free_security,
5556
5557 .msg_queue_alloc_security = selinux_msg_queue_alloc_security,
5558 .msg_queue_free_security = selinux_msg_queue_free_security,
5559 .msg_queue_associate = selinux_msg_queue_associate,
5560 .msg_queue_msgctl = selinux_msg_queue_msgctl,
5561 .msg_queue_msgsnd = selinux_msg_queue_msgsnd,
5562 .msg_queue_msgrcv = selinux_msg_queue_msgrcv,
5563
5564 .shm_alloc_security = selinux_shm_alloc_security,
5565 .shm_free_security = selinux_shm_free_security,
5566 .shm_associate = selinux_shm_associate,
5567 .shm_shmctl = selinux_shm_shmctl,
5568 .shm_shmat = selinux_shm_shmat,
5569
Eric Paris828dfe12008-04-17 13:17:49 -04005570 .sem_alloc_security = selinux_sem_alloc_security,
5571 .sem_free_security = selinux_sem_free_security,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005572 .sem_associate = selinux_sem_associate,
5573 .sem_semctl = selinux_sem_semctl,
5574 .sem_semop = selinux_sem_semop,
5575
Eric Paris828dfe12008-04-17 13:17:49 -04005576 .d_instantiate = selinux_d_instantiate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005577
Eric Paris828dfe12008-04-17 13:17:49 -04005578 .getprocattr = selinux_getprocattr,
5579 .setprocattr = selinux_setprocattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005580
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005581 .secid_to_secctx = selinux_secid_to_secctx,
David Howells63cb3442008-01-15 23:47:35 +00005582 .secctx_to_secid = selinux_secctx_to_secid,
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005583 .release_secctx = selinux_release_secctx,
David P. Quigley1ee65e32009-09-03 14:25:57 -04005584 .inode_notifysecctx = selinux_inode_notifysecctx,
5585 .inode_setsecctx = selinux_inode_setsecctx,
5586 .inode_getsecctx = selinux_inode_getsecctx,
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005587
Eric Paris828dfe12008-04-17 13:17:49 -04005588 .unix_stream_connect = selinux_socket_unix_stream_connect,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005589 .unix_may_send = selinux_socket_unix_may_send,
5590
5591 .socket_create = selinux_socket_create,
5592 .socket_post_create = selinux_socket_post_create,
5593 .socket_bind = selinux_socket_bind,
5594 .socket_connect = selinux_socket_connect,
5595 .socket_listen = selinux_socket_listen,
5596 .socket_accept = selinux_socket_accept,
5597 .socket_sendmsg = selinux_socket_sendmsg,
5598 .socket_recvmsg = selinux_socket_recvmsg,
5599 .socket_getsockname = selinux_socket_getsockname,
5600 .socket_getpeername = selinux_socket_getpeername,
5601 .socket_getsockopt = selinux_socket_getsockopt,
5602 .socket_setsockopt = selinux_socket_setsockopt,
5603 .socket_shutdown = selinux_socket_shutdown,
5604 .socket_sock_rcv_skb = selinux_socket_sock_rcv_skb,
Catherine Zhang2c7946a2006-03-20 22:41:23 -08005605 .socket_getpeersec_stream = selinux_socket_getpeersec_stream,
5606 .socket_getpeersec_dgram = selinux_socket_getpeersec_dgram,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005607 .sk_alloc_security = selinux_sk_alloc_security,
5608 .sk_free_security = selinux_sk_free_security,
Venkat Yekkirala892c1412006-08-04 23:08:56 -07005609 .sk_clone_security = selinux_sk_clone_security,
Eric Paris828dfe12008-04-17 13:17:49 -04005610 .sk_getsecid = selinux_sk_getsecid,
Venkat Yekkirala4237c752006-07-24 23:32:50 -07005611 .sock_graft = selinux_sock_graft,
5612 .inet_conn_request = selinux_inet_conn_request,
5613 .inet_csk_clone = selinux_inet_csk_clone,
Venkat Yekkirala6b877692006-11-08 17:04:09 -06005614 .inet_conn_established = selinux_inet_conn_established,
Venkat Yekkirala4237c752006-07-24 23:32:50 -07005615 .req_classify_flow = selinux_req_classify_flow,
Paul Mooreed6d76e2009-08-28 18:12:49 -04005616 .tun_dev_create = selinux_tun_dev_create,
5617 .tun_dev_post_create = selinux_tun_dev_post_create,
5618 .tun_dev_attach = selinux_tun_dev_attach,
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005619
5620#ifdef CONFIG_SECURITY_NETWORK_XFRM
5621 .xfrm_policy_alloc_security = selinux_xfrm_policy_alloc,
5622 .xfrm_policy_clone_security = selinux_xfrm_policy_clone,
5623 .xfrm_policy_free_security = selinux_xfrm_policy_free,
Catherine Zhangc8c05a82006-06-08 23:39:49 -07005624 .xfrm_policy_delete_security = selinux_xfrm_policy_delete,
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005625 .xfrm_state_alloc_security = selinux_xfrm_state_alloc,
5626 .xfrm_state_free_security = selinux_xfrm_state_free,
Catherine Zhangc8c05a82006-06-08 23:39:49 -07005627 .xfrm_state_delete_security = selinux_xfrm_state_delete,
Eric Paris828dfe12008-04-17 13:17:49 -04005628 .xfrm_policy_lookup = selinux_xfrm_policy_lookup,
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07005629 .xfrm_state_pol_flow_match = selinux_xfrm_state_pol_flow_match,
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07005630 .xfrm_decode_session = selinux_xfrm_decode_session,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005631#endif
Michael LeMayd7200242006-06-22 14:47:17 -07005632
5633#ifdef CONFIG_KEYS
Eric Paris828dfe12008-04-17 13:17:49 -04005634 .key_alloc = selinux_key_alloc,
5635 .key_free = selinux_key_free,
5636 .key_permission = selinux_key_permission,
David Howells70a5bb72008-04-29 01:01:26 -07005637 .key_getsecurity = selinux_key_getsecurity,
Michael LeMayd7200242006-06-22 14:47:17 -07005638#endif
Ahmed S. Darwish9d57a7f2008-03-01 22:03:14 +02005639
5640#ifdef CONFIG_AUDIT
5641 .audit_rule_init = selinux_audit_rule_init,
5642 .audit_rule_known = selinux_audit_rule_known,
5643 .audit_rule_match = selinux_audit_rule_match,
5644 .audit_rule_free = selinux_audit_rule_free,
5645#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07005646};
5647
5648static __init int selinux_init(void)
5649{
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02005650 if (!security_module_enable(&selinux_ops)) {
5651 selinux_enabled = 0;
5652 return 0;
5653 }
5654
Linus Torvalds1da177e2005-04-16 15:20:36 -07005655 if (!selinux_enabled) {
5656 printk(KERN_INFO "SELinux: Disabled at boot.\n");
5657 return 0;
5658 }
5659
5660 printk(KERN_INFO "SELinux: Initializing.\n");
5661
5662 /* Set the security state for the initial task. */
David Howellsd84f4f92008-11-14 10:39:23 +11005663 cred_init_security();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005664
James Morris7cae7e22006-03-22 00:09:22 -08005665 sel_inode_cache = kmem_cache_create("selinux_inode_security",
5666 sizeof(struct inode_security_struct),
Paul Mundt20c2df82007-07-20 10:11:58 +09005667 0, SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005668 avc_init();
5669
Eric Paris828dfe12008-04-17 13:17:49 -04005670 if (register_security(&selinux_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005671 panic("SELinux: Unable to register with kernel.\n");
5672
Eric Paris828dfe12008-04-17 13:17:49 -04005673 if (selinux_enforcing)
Eric Parisfadcdb42007-02-22 18:11:31 -05005674 printk(KERN_DEBUG "SELinux: Starting in enforcing mode\n");
Eric Paris828dfe12008-04-17 13:17:49 -04005675 else
Eric Parisfadcdb42007-02-22 18:11:31 -05005676 printk(KERN_DEBUG "SELinux: Starting in permissive mode\n");
Michael LeMayd7200242006-06-22 14:47:17 -07005677
Linus Torvalds1da177e2005-04-16 15:20:36 -07005678 return 0;
5679}
5680
5681void selinux_complete_init(void)
5682{
Eric Parisfadcdb42007-02-22 18:11:31 -05005683 printk(KERN_DEBUG "SELinux: Completing initialization.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005684
5685 /* Set up any superblocks initialized prior to the policy load. */
Eric Parisfadcdb42007-02-22 18:11:31 -05005686 printk(KERN_DEBUG "SELinux: Setting up existing superblocks.\n");
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005687 spin_lock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005688 spin_lock(&sb_security_lock);
5689next_sb:
5690 if (!list_empty(&superblock_security_head)) {
5691 struct superblock_security_struct *sbsec =
5692 list_entry(superblock_security_head.next,
Eric Paris828dfe12008-04-17 13:17:49 -04005693 struct superblock_security_struct,
5694 list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005695 struct super_block *sb = sbsec->sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005696 sb->s_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005697 spin_unlock(&sb_security_lock);
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005698 spin_unlock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005699 down_read(&sb->s_umount);
5700 if (sb->s_root)
5701 superblock_doinit(sb, NULL);
5702 drop_super(sb);
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005703 spin_lock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005704 spin_lock(&sb_security_lock);
5705 list_del_init(&sbsec->list);
5706 goto next_sb;
5707 }
5708 spin_unlock(&sb_security_lock);
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005709 spin_unlock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005710}
5711
5712/* SELinux requires early initialization in order to label
5713 all processes and objects when they are created. */
5714security_initcall(selinux_init);
5715
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005716#if defined(CONFIG_NETFILTER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005717
Paul Mooreeffad8d2008-01-29 08:49:27 -05005718static struct nf_hook_ops selinux_ipv4_ops[] = {
5719 {
5720 .hook = selinux_ipv4_postroute,
5721 .owner = THIS_MODULE,
5722 .pf = PF_INET,
5723 .hooknum = NF_INET_POST_ROUTING,
5724 .priority = NF_IP_PRI_SELINUX_LAST,
5725 },
5726 {
5727 .hook = selinux_ipv4_forward,
5728 .owner = THIS_MODULE,
5729 .pf = PF_INET,
5730 .hooknum = NF_INET_FORWARD,
5731 .priority = NF_IP_PRI_SELINUX_FIRST,
Paul Moore948bf852008-10-10 10:16:32 -04005732 },
5733 {
5734 .hook = selinux_ipv4_output,
5735 .owner = THIS_MODULE,
5736 .pf = PF_INET,
5737 .hooknum = NF_INET_LOCAL_OUT,
5738 .priority = NF_IP_PRI_SELINUX_FIRST,
Paul Mooreeffad8d2008-01-29 08:49:27 -05005739 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005740};
5741
5742#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5743
Paul Mooreeffad8d2008-01-29 08:49:27 -05005744static struct nf_hook_ops selinux_ipv6_ops[] = {
5745 {
5746 .hook = selinux_ipv6_postroute,
5747 .owner = THIS_MODULE,
5748 .pf = PF_INET6,
5749 .hooknum = NF_INET_POST_ROUTING,
5750 .priority = NF_IP6_PRI_SELINUX_LAST,
5751 },
5752 {
5753 .hook = selinux_ipv6_forward,
5754 .owner = THIS_MODULE,
5755 .pf = PF_INET6,
5756 .hooknum = NF_INET_FORWARD,
5757 .priority = NF_IP6_PRI_SELINUX_FIRST,
5758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005759};
5760
5761#endif /* IPV6 */
5762
5763static int __init selinux_nf_ip_init(void)
5764{
5765 int err = 0;
5766
5767 if (!selinux_enabled)
5768 goto out;
Eric Parisfadcdb42007-02-22 18:11:31 -05005769
5770 printk(KERN_DEBUG "SELinux: Registering netfilter hooks\n");
5771
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005772 err = nf_register_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5773 if (err)
5774 panic("SELinux: nf_register_hooks for IPv4: error %d\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005775
5776#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005777 err = nf_register_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5778 if (err)
5779 panic("SELinux: nf_register_hooks for IPv6: error %d\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005780#endif /* IPV6 */
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005781
Linus Torvalds1da177e2005-04-16 15:20:36 -07005782out:
5783 return err;
5784}
5785
5786__initcall(selinux_nf_ip_init);
5787
5788#ifdef CONFIG_SECURITY_SELINUX_DISABLE
5789static void selinux_nf_ip_exit(void)
5790{
Eric Parisfadcdb42007-02-22 18:11:31 -05005791 printk(KERN_DEBUG "SELinux: Unregistering netfilter hooks\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005792
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005793 nf_unregister_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005794#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005795 nf_unregister_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005796#endif /* IPV6 */
5797}
5798#endif
5799
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005800#else /* CONFIG_NETFILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005801
5802#ifdef CONFIG_SECURITY_SELINUX_DISABLE
5803#define selinux_nf_ip_exit()
5804#endif
5805
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005806#endif /* CONFIG_NETFILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005807
5808#ifdef CONFIG_SECURITY_SELINUX_DISABLE
Eric Paris828dfe12008-04-17 13:17:49 -04005809static int selinux_disabled;
5810
Linus Torvalds1da177e2005-04-16 15:20:36 -07005811int selinux_disable(void)
5812{
5813 extern void exit_sel_fs(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005814
5815 if (ss_initialized) {
5816 /* Not permitted after initial policy load. */
5817 return -EINVAL;
5818 }
5819
5820 if (selinux_disabled) {
5821 /* Only do this once. */
5822 return -EINVAL;
5823 }
5824
5825 printk(KERN_INFO "SELinux: Disabled at runtime.\n");
5826
5827 selinux_disabled = 1;
Stephen Smalley30d55282006-05-03 10:52:36 -04005828 selinux_enabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005829
wzt.wzt@gmail.com189b3b12010-02-23 23:15:28 +08005830 reset_security_ops();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005831
Eric Parisaf8ff042009-09-20 21:23:01 -04005832 /* Try to destroy the avc node cache */
5833 avc_disable();
5834
Linus Torvalds1da177e2005-04-16 15:20:36 -07005835 /* Unregister netfilter hooks. */
5836 selinux_nf_ip_exit();
5837
5838 /* Unregister selinuxfs. */
5839 exit_sel_fs();
5840
5841 return 0;
5842}
5843#endif