blob: ba808ef6babb58799f615aa4ec615824cfb20f66 [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 Mooreeffad8d2008-01-29 08:49:27 -050016 * Copyright (C) 2006, 2007 Hewlett-Packard Development Company, L.P.
Eric Paris828dfe12008-04-17 13:17:49 -040017 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80#include "avc.h"
81#include "objsec.h"
82#include "netif.h"
Paul Moore224dfbd2008-01-29 08:38:13 -050083#include "netnode.h"
Paul Moore3e112172008-04-10 10:48:14 -040084#include "netport.h"
Trent Jaegerd28d1e02005-12-13 23:12:40 -080085#include "xfrm.h"
Paul Moorec60475b2007-02-28 15:14:23 -050086#include "netlabel.h"
Ahmed S. Darwish9d57a7f2008-03-01 22:03:14 +020087#include "audit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89#define XATTR_SELINUX_SUFFIX "selinux"
90#define XATTR_NAME_SELINUX XATTR_SECURITY_PREFIX XATTR_SELINUX_SUFFIX
91
David P. Quigley11689d42009-01-16 09:22:03 -050092#define NUM_SEL_MNT_OPTS 5
Eric Parisc9180a52007-11-30 13:00:35 -050093
Linus Torvalds1da177e2005-04-16 15:20:36 -070094extern unsigned int policydb_loaded_version;
95extern 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
James Morris6f0f0fd2008-07-10 17:02:07 +0900130/*
131 * Minimal support for a secondary security module,
132 * just to allow the use of the capability module.
133 */
Eric Paris828dfe12008-04-17 13:17:49 -0400134static struct security_operations *secondary_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136/* Lists of inode and superblock security structures initialized
137 before the policy was loaded. */
138static LIST_HEAD(superblock_security_head);
139static DEFINE_SPINLOCK(sb_security_lock);
140
Christoph Lametere18b8902006-12-06 20:33:20 -0800141static struct kmem_cache *sel_inode_cache;
James Morris7cae7e22006-03-22 00:09:22 -0800142
Paul Moored621d352008-01-29 08:43:36 -0500143/**
144 * selinux_secmark_enabled - Check to see if SECMARK is currently enabled
145 *
146 * Description:
147 * This function checks the SECMARK reference counter to see if any SECMARK
148 * targets are currently configured, if the reference counter is greater than
149 * zero SECMARK is considered to be enabled. Returns true (1) if SECMARK is
150 * enabled, false (0) if SECMARK is disabled.
151 *
152 */
153static int selinux_secmark_enabled(void)
154{
155 return (atomic_read(&selinux_secmark_refcount) > 0);
156}
157
David Howellsd84f4f92008-11-14 10:39:23 +1100158/*
159 * initialise the security for the init task
160 */
161static void cred_init_security(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
David Howells3b11a1d2008-11-14 10:39:26 +1100163 struct cred *cred = (struct cred *) current->real_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 struct task_security_struct *tsec;
165
James Morris89d155e2005-10-30 14:59:21 -0800166 tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 if (!tsec)
David Howellsd84f4f92008-11-14 10:39:23 +1100168 panic("SELinux: Failed to initialize initial task.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
David Howellsd84f4f92008-11-14 10:39:23 +1100170 tsec->osid = tsec->sid = SECINITSID_KERNEL;
David Howellsf1752ee2008-11-14 10:39:17 +1100171 cred->security = tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172}
173
David Howells275bb412008-11-14 10:39:19 +1100174/*
David Howells88e67f32008-11-14 10:39:21 +1100175 * get the security ID of a set of credentials
176 */
177static inline u32 cred_sid(const struct cred *cred)
178{
179 const struct task_security_struct *tsec;
180
181 tsec = cred->security;
182 return tsec->sid;
183}
184
185/*
David Howells3b11a1d2008-11-14 10:39:26 +1100186 * get the objective security ID of a task
David Howells275bb412008-11-14 10:39:19 +1100187 */
188static inline u32 task_sid(const struct task_struct *task)
189{
David Howells275bb412008-11-14 10:39:19 +1100190 u32 sid;
191
192 rcu_read_lock();
David Howells88e67f32008-11-14 10:39:21 +1100193 sid = cred_sid(__task_cred(task));
David Howells275bb412008-11-14 10:39:19 +1100194 rcu_read_unlock();
195 return sid;
196}
197
198/*
David Howells3b11a1d2008-11-14 10:39:26 +1100199 * get the subjective security ID of the current task
David Howells275bb412008-11-14 10:39:19 +1100200 */
201static inline u32 current_sid(void)
202{
203 const struct task_security_struct *tsec = current_cred()->security;
204
205 return tsec->sid;
206}
207
David Howells88e67f32008-11-14 10:39:21 +1100208/* Allocate and free functions for each kind of security blob. */
209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210static int inode_alloc_security(struct inode *inode)
211{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 struct inode_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +1100213 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Josef Bacika02fe132008-04-04 09:35:05 +1100215 isec = kmem_cache_zalloc(sel_inode_cache, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if (!isec)
217 return -ENOMEM;
218
Eric Paris23970742006-09-25 23:32:01 -0700219 mutex_init(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 INIT_LIST_HEAD(&isec->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 isec->inode = inode;
222 isec->sid = SECINITSID_UNLABELED;
223 isec->sclass = SECCLASS_FILE;
David Howells275bb412008-11-14 10:39:19 +1100224 isec->task_sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 inode->i_security = isec;
226
227 return 0;
228}
229
230static void inode_free_security(struct inode *inode)
231{
232 struct inode_security_struct *isec = inode->i_security;
233 struct superblock_security_struct *sbsec = inode->i_sb->s_security;
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 spin_lock(&sbsec->isec_lock);
236 if (!list_empty(&isec->list))
237 list_del_init(&isec->list);
238 spin_unlock(&sbsec->isec_lock);
239
240 inode->i_security = NULL;
James Morris7cae7e22006-03-22 00:09:22 -0800241 kmem_cache_free(sel_inode_cache, isec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242}
243
244static int file_alloc_security(struct file *file)
245{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 struct file_security_struct *fsec;
David Howells275bb412008-11-14 10:39:19 +1100247 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Stephen Smalley26d2a4b2006-02-01 03:05:55 -0800249 fsec = kzalloc(sizeof(struct file_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 if (!fsec)
251 return -ENOMEM;
252
David Howells275bb412008-11-14 10:39:19 +1100253 fsec->sid = sid;
254 fsec->fown_sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 file->f_security = fsec;
256
257 return 0;
258}
259
260static void file_free_security(struct file *file)
261{
262 struct file_security_struct *fsec = file->f_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 file->f_security = NULL;
264 kfree(fsec);
265}
266
267static int superblock_alloc_security(struct super_block *sb)
268{
269 struct superblock_security_struct *sbsec;
270
James Morris89d155e2005-10-30 14:59:21 -0800271 sbsec = kzalloc(sizeof(struct superblock_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 if (!sbsec)
273 return -ENOMEM;
274
Eric Parisbc7e9822006-09-25 23:32:02 -0700275 mutex_init(&sbsec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 INIT_LIST_HEAD(&sbsec->list);
277 INIT_LIST_HEAD(&sbsec->isec_head);
278 spin_lock_init(&sbsec->isec_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 sbsec->sb = sb;
280 sbsec->sid = SECINITSID_UNLABELED;
281 sbsec->def_sid = SECINITSID_FILE;
Eric Parisc312feb2006-07-10 04:43:53 -0700282 sbsec->mntpoint_sid = SECINITSID_UNLABELED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 sb->s_security = sbsec;
284
285 return 0;
286}
287
288static void superblock_free_security(struct super_block *sb)
289{
290 struct superblock_security_struct *sbsec = sb->s_security;
291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 spin_lock(&sb_security_lock);
293 if (!list_empty(&sbsec->list))
294 list_del_init(&sbsec->list);
295 spin_unlock(&sb_security_lock);
296
297 sb->s_security = NULL;
298 kfree(sbsec);
299}
300
Al Viro7d877f32005-10-21 03:20:43 -0400301static int sk_alloc_security(struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302{
303 struct sk_security_struct *ssec;
304
James Morris89d155e2005-10-30 14:59:21 -0800305 ssec = kzalloc(sizeof(*ssec), priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (!ssec)
307 return -ENOMEM;
308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 ssec->peer_sid = SECINITSID_UNLABELED;
Venkat Yekkirala892c1412006-08-04 23:08:56 -0700310 ssec->sid = SECINITSID_UNLABELED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 sk->sk_security = ssec;
312
Paul Moore389fb802009-03-27 17:10:34 -0400313 selinux_netlbl_sk_security_reset(ssec);
Paul Moore99f59ed2006-08-29 17:53:48 -0700314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 return 0;
316}
317
318static void sk_free_security(struct sock *sk)
319{
320 struct sk_security_struct *ssec = sk->sk_security;
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 sk->sk_security = NULL;
Paul Moore6c5b3fc2008-10-10 10:16:33 -0400323 selinux_netlbl_sk_security_free(ssec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 kfree(ssec);
325}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327/* The security server must be initialized before
328 any labeling or access decisions can be provided. */
329extern int ss_initialized;
330
331/* The file system's label must be initialized prior to use. */
332
333static char *labeling_behaviors[6] = {
334 "uses xattr",
335 "uses transition SIDs",
336 "uses task SIDs",
337 "uses genfs_contexts",
338 "not configured for labeling",
339 "uses mountpoint labeling",
340};
341
342static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry);
343
344static inline int inode_doinit(struct inode *inode)
345{
346 return inode_doinit_with_dentry(inode, NULL);
347}
348
349enum {
Eric Paris31e87932007-09-19 17:19:12 -0400350 Opt_error = -1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 Opt_context = 1,
352 Opt_fscontext = 2,
Eric Parisc9180a52007-11-30 13:00:35 -0500353 Opt_defcontext = 3,
354 Opt_rootcontext = 4,
David P. Quigley11689d42009-01-16 09:22:03 -0500355 Opt_labelsupport = 5,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356};
357
Steven Whitehousea447c092008-10-13 10:46:57 +0100358static const match_table_t tokens = {
Eric Paris832cbd92008-04-01 13:24:09 -0400359 {Opt_context, CONTEXT_STR "%s"},
360 {Opt_fscontext, FSCONTEXT_STR "%s"},
361 {Opt_defcontext, DEFCONTEXT_STR "%s"},
362 {Opt_rootcontext, ROOTCONTEXT_STR "%s"},
David P. Quigley11689d42009-01-16 09:22:03 -0500363 {Opt_labelsupport, LABELSUPP_STR},
Eric Paris31e87932007-09-19 17:19:12 -0400364 {Opt_error, NULL},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365};
366
367#define SEL_MOUNT_FAIL_MSG "SELinux: duplicate or incompatible mount options\n"
368
Eric Parisc312feb2006-07-10 04:43:53 -0700369static int may_context_mount_sb_relabel(u32 sid,
370 struct superblock_security_struct *sbsec,
David Howells275bb412008-11-14 10:39:19 +1100371 const struct cred *cred)
Eric Parisc312feb2006-07-10 04:43:53 -0700372{
David Howells275bb412008-11-14 10:39:19 +1100373 const struct task_security_struct *tsec = cred->security;
Eric Parisc312feb2006-07-10 04:43:53 -0700374 int rc;
375
376 rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
377 FILESYSTEM__RELABELFROM, NULL);
378 if (rc)
379 return rc;
380
381 rc = avc_has_perm(tsec->sid, sid, SECCLASS_FILESYSTEM,
382 FILESYSTEM__RELABELTO, NULL);
383 return rc;
384}
385
Eric Paris08089252006-07-10 04:43:55 -0700386static int may_context_mount_inode_relabel(u32 sid,
387 struct superblock_security_struct *sbsec,
David Howells275bb412008-11-14 10:39:19 +1100388 const struct cred *cred)
Eric Paris08089252006-07-10 04:43:55 -0700389{
David Howells275bb412008-11-14 10:39:19 +1100390 const struct task_security_struct *tsec = cred->security;
Eric Paris08089252006-07-10 04:43:55 -0700391 int rc;
392 rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
393 FILESYSTEM__RELABELFROM, NULL);
394 if (rc)
395 return rc;
396
397 rc = avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM,
398 FILESYSTEM__ASSOCIATE, NULL);
399 return rc;
400}
401
Eric Parisc9180a52007-11-30 13:00:35 -0500402static int sb_finish_set_opts(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
404 struct superblock_security_struct *sbsec = sb->s_security;
405 struct dentry *root = sb->s_root;
Eric Parisc9180a52007-11-30 13:00:35 -0500406 struct inode *root_inode = root->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 int rc = 0;
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
410 /* Make sure that the xattr handler exists and that no
411 error other than -ENODATA is returned by getxattr on
412 the root directory. -ENODATA is ok, as this may be
413 the first boot of the SELinux kernel before we have
414 assigned xattr values to the filesystem. */
Eric Parisc9180a52007-11-30 13:00:35 -0500415 if (!root_inode->i_op->getxattr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
417 "xattr support\n", sb->s_id, sb->s_type->name);
418 rc = -EOPNOTSUPP;
419 goto out;
420 }
Eric Parisc9180a52007-11-30 13:00:35 -0500421 rc = root_inode->i_op->getxattr(root, XATTR_NAME_SELINUX, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 if (rc < 0 && rc != -ENODATA) {
423 if (rc == -EOPNOTSUPP)
424 printk(KERN_WARNING "SELinux: (dev %s, type "
425 "%s) has no security xattr handler\n",
426 sb->s_id, sb->s_type->name);
427 else
428 printk(KERN_WARNING "SELinux: (dev %s, type "
429 "%s) getxattr errno %d\n", sb->s_id,
430 sb->s_type->name, -rc);
431 goto out;
432 }
433 }
434
David P. Quigley11689d42009-01-16 09:22:03 -0500435 sbsec->flags |= (SE_SBINITIALIZED | SE_SBLABELSUPP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Eric Parisc9180a52007-11-30 13:00:35 -0500437 if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
Eric Parisfadcdb42007-02-22 18:11:31 -0500438 printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 sb->s_id, sb->s_type->name);
Eric Parisc9180a52007-11-30 13:00:35 -0500440 else
Eric Parisfadcdb42007-02-22 18:11:31 -0500441 printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 sb->s_id, sb->s_type->name,
443 labeling_behaviors[sbsec->behavior-1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
David P. Quigley11689d42009-01-16 09:22:03 -0500445 if (sbsec->behavior == SECURITY_FS_USE_GENFS ||
446 sbsec->behavior == SECURITY_FS_USE_MNTPOINT ||
447 sbsec->behavior == SECURITY_FS_USE_NONE ||
448 sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
449 sbsec->flags &= ~SE_SBLABELSUPP;
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 /* Initialize the root inode. */
Eric Parisc9180a52007-11-30 13:00:35 -0500452 rc = inode_doinit_with_dentry(root_inode, root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 /* Initialize any other inodes associated with the superblock, e.g.
455 inodes created prior to initial policy load or inodes created
456 during get_sb by a pseudo filesystem that directly
457 populates itself. */
458 spin_lock(&sbsec->isec_lock);
459next_inode:
460 if (!list_empty(&sbsec->isec_head)) {
461 struct inode_security_struct *isec =
462 list_entry(sbsec->isec_head.next,
Eric Parisc9180a52007-11-30 13:00:35 -0500463 struct inode_security_struct, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 struct inode *inode = isec->inode;
465 spin_unlock(&sbsec->isec_lock);
466 inode = igrab(inode);
467 if (inode) {
Eric Parisc9180a52007-11-30 13:00:35 -0500468 if (!IS_PRIVATE(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 inode_doinit(inode);
470 iput(inode);
471 }
472 spin_lock(&sbsec->isec_lock);
473 list_del_init(&isec->list);
474 goto next_inode;
475 }
476 spin_unlock(&sbsec->isec_lock);
477out:
Eric Parisc9180a52007-11-30 13:00:35 -0500478 return rc;
479}
480
481/*
482 * This function should allow an FS to ask what it's mount security
483 * options were so it can use those later for submounts, displaying
484 * mount options, or whatever.
485 */
486static int selinux_get_mnt_opts(const struct super_block *sb,
Eric Parise0007522008-03-05 10:31:54 -0500487 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500488{
489 int rc = 0, i;
490 struct superblock_security_struct *sbsec = sb->s_security;
491 char *context = NULL;
492 u32 len;
493 char tmp;
494
Eric Parise0007522008-03-05 10:31:54 -0500495 security_init_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500496
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500497 if (!(sbsec->flags & SE_SBINITIALIZED))
Eric Parisc9180a52007-11-30 13:00:35 -0500498 return -EINVAL;
499
500 if (!ss_initialized)
501 return -EINVAL;
502
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500503 tmp = sbsec->flags & SE_MNTMASK;
Eric Parisc9180a52007-11-30 13:00:35 -0500504 /* count the number of mount options for this sb */
505 for (i = 0; i < 8; i++) {
506 if (tmp & 0x01)
Eric Parise0007522008-03-05 10:31:54 -0500507 opts->num_mnt_opts++;
Eric Parisc9180a52007-11-30 13:00:35 -0500508 tmp >>= 1;
509 }
David P. Quigley11689d42009-01-16 09:22:03 -0500510 /* Check if the Label support flag is set */
511 if (sbsec->flags & SE_SBLABELSUPP)
512 opts->num_mnt_opts++;
Eric Parisc9180a52007-11-30 13:00:35 -0500513
Eric Parise0007522008-03-05 10:31:54 -0500514 opts->mnt_opts = kcalloc(opts->num_mnt_opts, sizeof(char *), GFP_ATOMIC);
515 if (!opts->mnt_opts) {
Eric Parisc9180a52007-11-30 13:00:35 -0500516 rc = -ENOMEM;
517 goto out_free;
518 }
519
Eric Parise0007522008-03-05 10:31:54 -0500520 opts->mnt_opts_flags = kcalloc(opts->num_mnt_opts, sizeof(int), GFP_ATOMIC);
521 if (!opts->mnt_opts_flags) {
Eric Parisc9180a52007-11-30 13:00:35 -0500522 rc = -ENOMEM;
523 goto out_free;
524 }
525
526 i = 0;
527 if (sbsec->flags & FSCONTEXT_MNT) {
528 rc = security_sid_to_context(sbsec->sid, &context, &len);
529 if (rc)
530 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500531 opts->mnt_opts[i] = context;
532 opts->mnt_opts_flags[i++] = FSCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500533 }
534 if (sbsec->flags & CONTEXT_MNT) {
535 rc = security_sid_to_context(sbsec->mntpoint_sid, &context, &len);
536 if (rc)
537 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500538 opts->mnt_opts[i] = context;
539 opts->mnt_opts_flags[i++] = CONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500540 }
541 if (sbsec->flags & DEFCONTEXT_MNT) {
542 rc = security_sid_to_context(sbsec->def_sid, &context, &len);
543 if (rc)
544 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500545 opts->mnt_opts[i] = context;
546 opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500547 }
548 if (sbsec->flags & ROOTCONTEXT_MNT) {
549 struct inode *root = sbsec->sb->s_root->d_inode;
550 struct inode_security_struct *isec = root->i_security;
551
552 rc = security_sid_to_context(isec->sid, &context, &len);
553 if (rc)
554 goto out_free;
Eric Parise0007522008-03-05 10:31:54 -0500555 opts->mnt_opts[i] = context;
556 opts->mnt_opts_flags[i++] = ROOTCONTEXT_MNT;
Eric Parisc9180a52007-11-30 13:00:35 -0500557 }
David P. Quigley11689d42009-01-16 09:22:03 -0500558 if (sbsec->flags & SE_SBLABELSUPP) {
559 opts->mnt_opts[i] = NULL;
560 opts->mnt_opts_flags[i++] = SE_SBLABELSUPP;
561 }
Eric Parisc9180a52007-11-30 13:00:35 -0500562
Eric Parise0007522008-03-05 10:31:54 -0500563 BUG_ON(i != opts->num_mnt_opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500564
565 return 0;
566
567out_free:
Eric Parise0007522008-03-05 10:31:54 -0500568 security_free_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500569 return rc;
570}
571
572static int bad_option(struct superblock_security_struct *sbsec, char flag,
573 u32 old_sid, u32 new_sid)
574{
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500575 char mnt_flags = sbsec->flags & SE_MNTMASK;
576
Eric Parisc9180a52007-11-30 13:00:35 -0500577 /* check if the old mount command had the same options */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500578 if (sbsec->flags & SE_SBINITIALIZED)
Eric Parisc9180a52007-11-30 13:00:35 -0500579 if (!(sbsec->flags & flag) ||
580 (old_sid != new_sid))
581 return 1;
582
583 /* check if we were passed the same options twice,
584 * aka someone passed context=a,context=b
585 */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500586 if (!(sbsec->flags & SE_SBINITIALIZED))
587 if (mnt_flags & flag)
Eric Parisc9180a52007-11-30 13:00:35 -0500588 return 1;
589 return 0;
590}
Eric Parise0007522008-03-05 10:31:54 -0500591
Eric Parisc9180a52007-11-30 13:00:35 -0500592/*
593 * Allow filesystems with binary mount data to explicitly set mount point
594 * labeling information.
595 */
Eric Parise0007522008-03-05 10:31:54 -0500596static int selinux_set_mnt_opts(struct super_block *sb,
597 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500598{
David Howells275bb412008-11-14 10:39:19 +1100599 const struct cred *cred = current_cred();
Eric Parisc9180a52007-11-30 13:00:35 -0500600 int rc = 0, i;
Eric Parisc9180a52007-11-30 13:00:35 -0500601 struct superblock_security_struct *sbsec = sb->s_security;
602 const char *name = sb->s_type->name;
James Morris089be432008-07-15 18:32:49 +1000603 struct inode *inode = sbsec->sb->s_root->d_inode;
604 struct inode_security_struct *root_isec = inode->i_security;
Eric Parisc9180a52007-11-30 13:00:35 -0500605 u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
606 u32 defcontext_sid = 0;
Eric Parise0007522008-03-05 10:31:54 -0500607 char **mount_options = opts->mnt_opts;
608 int *flags = opts->mnt_opts_flags;
609 int num_opts = opts->num_mnt_opts;
Eric Parisc9180a52007-11-30 13:00:35 -0500610
611 mutex_lock(&sbsec->lock);
612
613 if (!ss_initialized) {
614 if (!num_opts) {
615 /* Defer initialization until selinux_complete_init,
616 after the initial policy is loaded and the security
617 server is ready to handle calls. */
618 spin_lock(&sb_security_lock);
619 if (list_empty(&sbsec->list))
620 list_add(&sbsec->list, &superblock_security_head);
621 spin_unlock(&sb_security_lock);
622 goto out;
623 }
624 rc = -EINVAL;
Eric Paris744ba352008-04-17 11:52:44 -0400625 printk(KERN_WARNING "SELinux: Unable to set superblock options "
626 "before the security server is initialized\n");
Eric Parisc9180a52007-11-30 13:00:35 -0500627 goto out;
628 }
629
630 /*
Eric Parise0007522008-03-05 10:31:54 -0500631 * Binary mount data FS will come through this function twice. Once
632 * from an explicit call and once from the generic calls from the vfs.
633 * Since the generic VFS calls will not contain any security mount data
634 * we need to skip the double mount verification.
635 *
636 * This does open a hole in which we will not notice if the first
637 * mount using this sb set explict options and a second mount using
638 * this sb does not set any security options. (The first options
639 * will be used for both mounts)
640 */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500641 if ((sbsec->flags & SE_SBINITIALIZED) && (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
Eric Parise0007522008-03-05 10:31:54 -0500642 && (num_opts == 0))
Eric Parisf5269712008-05-14 11:27:45 -0400643 goto out;
Eric Parise0007522008-03-05 10:31:54 -0500644
645 /*
Eric Parisc9180a52007-11-30 13:00:35 -0500646 * parse the mount options, check if they are valid sids.
647 * also check if someone is trying to mount the same sb more
648 * than once with different security options.
649 */
650 for (i = 0; i < num_opts; i++) {
651 u32 sid;
David P. Quigley11689d42009-01-16 09:22:03 -0500652
653 if (flags[i] == SE_SBLABELSUPP)
654 continue;
Eric Parisc9180a52007-11-30 13:00:35 -0500655 rc = security_context_to_sid(mount_options[i],
656 strlen(mount_options[i]), &sid);
657 if (rc) {
658 printk(KERN_WARNING "SELinux: security_context_to_sid"
659 "(%s) failed for (dev %s, type %s) errno=%d\n",
660 mount_options[i], sb->s_id, name, rc);
661 goto out;
662 }
663 switch (flags[i]) {
664 case FSCONTEXT_MNT:
665 fscontext_sid = sid;
666
667 if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid,
668 fscontext_sid))
669 goto out_double_mount;
670
671 sbsec->flags |= FSCONTEXT_MNT;
672 break;
673 case CONTEXT_MNT:
674 context_sid = sid;
675
676 if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid,
677 context_sid))
678 goto out_double_mount;
679
680 sbsec->flags |= CONTEXT_MNT;
681 break;
682 case ROOTCONTEXT_MNT:
683 rootcontext_sid = sid;
684
685 if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid,
686 rootcontext_sid))
687 goto out_double_mount;
688
689 sbsec->flags |= ROOTCONTEXT_MNT;
690
691 break;
692 case DEFCONTEXT_MNT:
693 defcontext_sid = sid;
694
695 if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid,
696 defcontext_sid))
697 goto out_double_mount;
698
699 sbsec->flags |= DEFCONTEXT_MNT;
700
701 break;
702 default:
703 rc = -EINVAL;
704 goto out;
705 }
706 }
707
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500708 if (sbsec->flags & SE_SBINITIALIZED) {
Eric Parisc9180a52007-11-30 13:00:35 -0500709 /* previously mounted with options, but not on this attempt? */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500710 if ((sbsec->flags & SE_MNTMASK) && !num_opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500711 goto out_double_mount;
712 rc = 0;
713 goto out;
714 }
715
James Morris089be432008-07-15 18:32:49 +1000716 if (strcmp(sb->s_type->name, "proc") == 0)
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500717 sbsec->flags |= SE_SBPROC;
Eric Parisc9180a52007-11-30 13:00:35 -0500718
719 /* Determine the labeling behavior to use for this filesystem type. */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500720 rc = security_fs_use((sbsec->flags & SE_SBPROC) ? "proc" : sb->s_type->name, &sbsec->behavior, &sbsec->sid);
Eric Parisc9180a52007-11-30 13:00:35 -0500721 if (rc) {
722 printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n",
James Morris089be432008-07-15 18:32:49 +1000723 __func__, sb->s_type->name, rc);
Eric Parisc9180a52007-11-30 13:00:35 -0500724 goto out;
725 }
726
727 /* sets the context of the superblock for the fs being mounted. */
728 if (fscontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100729 rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500730 if (rc)
731 goto out;
732
733 sbsec->sid = fscontext_sid;
734 }
735
736 /*
737 * Switch to using mount point labeling behavior.
738 * sets the label used on all file below the mountpoint, and will set
739 * the superblock context if not already set.
740 */
741 if (context_sid) {
742 if (!fscontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100743 rc = may_context_mount_sb_relabel(context_sid, sbsec,
744 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500745 if (rc)
746 goto out;
747 sbsec->sid = context_sid;
748 } else {
David Howells275bb412008-11-14 10:39:19 +1100749 rc = may_context_mount_inode_relabel(context_sid, sbsec,
750 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500751 if (rc)
752 goto out;
753 }
754 if (!rootcontext_sid)
755 rootcontext_sid = context_sid;
756
757 sbsec->mntpoint_sid = context_sid;
758 sbsec->behavior = SECURITY_FS_USE_MNTPOINT;
759 }
760
761 if (rootcontext_sid) {
David Howells275bb412008-11-14 10:39:19 +1100762 rc = may_context_mount_inode_relabel(rootcontext_sid, sbsec,
763 cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500764 if (rc)
765 goto out;
766
767 root_isec->sid = rootcontext_sid;
768 root_isec->initialized = 1;
769 }
770
771 if (defcontext_sid) {
772 if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
773 rc = -EINVAL;
774 printk(KERN_WARNING "SELinux: defcontext option is "
775 "invalid for this filesystem type\n");
776 goto out;
777 }
778
779 if (defcontext_sid != sbsec->def_sid) {
780 rc = may_context_mount_inode_relabel(defcontext_sid,
David Howells275bb412008-11-14 10:39:19 +1100781 sbsec, cred);
Eric Parisc9180a52007-11-30 13:00:35 -0500782 if (rc)
783 goto out;
784 }
785
786 sbsec->def_sid = defcontext_sid;
787 }
788
789 rc = sb_finish_set_opts(sb);
790out:
Eric Parisbc7e9822006-09-25 23:32:02 -0700791 mutex_unlock(&sbsec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 return rc;
Eric Parisc9180a52007-11-30 13:00:35 -0500793out_double_mount:
794 rc = -EINVAL;
795 printk(KERN_WARNING "SELinux: mount invalid. Same superblock, different "
796 "security settings for (dev %s, type %s)\n", sb->s_id, name);
797 goto out;
798}
799
800static void selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
801 struct super_block *newsb)
802{
803 const struct superblock_security_struct *oldsbsec = oldsb->s_security;
804 struct superblock_security_struct *newsbsec = newsb->s_security;
805
806 int set_fscontext = (oldsbsec->flags & FSCONTEXT_MNT);
807 int set_context = (oldsbsec->flags & CONTEXT_MNT);
808 int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT);
809
Eric Paris0f5e6422008-04-21 16:24:11 -0400810 /*
811 * if the parent was able to be mounted it clearly had no special lsm
812 * mount options. thus we can safely put this sb on the list and deal
813 * with it later
814 */
815 if (!ss_initialized) {
816 spin_lock(&sb_security_lock);
817 if (list_empty(&newsbsec->list))
818 list_add(&newsbsec->list, &superblock_security_head);
819 spin_unlock(&sb_security_lock);
820 return;
821 }
Eric Parisc9180a52007-11-30 13:00:35 -0500822
Eric Parisc9180a52007-11-30 13:00:35 -0500823 /* how can we clone if the old one wasn't set up?? */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500824 BUG_ON(!(oldsbsec->flags & SE_SBINITIALIZED));
Eric Parisc9180a52007-11-30 13:00:35 -0500825
Eric Paris5a552612008-04-09 14:08:35 -0400826 /* if fs is reusing a sb, just let its options stand... */
David P. Quigley0d90a7e2009-01-16 09:22:02 -0500827 if (newsbsec->flags & SE_SBINITIALIZED)
Eric Paris5a552612008-04-09 14:08:35 -0400828 return;
829
Eric Parisc9180a52007-11-30 13:00:35 -0500830 mutex_lock(&newsbsec->lock);
831
832 newsbsec->flags = oldsbsec->flags;
833
834 newsbsec->sid = oldsbsec->sid;
835 newsbsec->def_sid = oldsbsec->def_sid;
836 newsbsec->behavior = oldsbsec->behavior;
837
838 if (set_context) {
839 u32 sid = oldsbsec->mntpoint_sid;
840
841 if (!set_fscontext)
842 newsbsec->sid = sid;
843 if (!set_rootcontext) {
844 struct inode *newinode = newsb->s_root->d_inode;
845 struct inode_security_struct *newisec = newinode->i_security;
846 newisec->sid = sid;
847 }
848 newsbsec->mntpoint_sid = sid;
849 }
850 if (set_rootcontext) {
851 const struct inode *oldinode = oldsb->s_root->d_inode;
852 const struct inode_security_struct *oldisec = oldinode->i_security;
853 struct inode *newinode = newsb->s_root->d_inode;
854 struct inode_security_struct *newisec = newinode->i_security;
855
856 newisec->sid = oldisec->sid;
857 }
858
859 sb_finish_set_opts(newsb);
860 mutex_unlock(&newsbsec->lock);
861}
862
Adrian Bunk2e1479d2008-03-17 22:29:23 +0200863static int selinux_parse_opts_str(char *options,
864 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500865{
Eric Parise0007522008-03-05 10:31:54 -0500866 char *p;
Eric Parisc9180a52007-11-30 13:00:35 -0500867 char *context = NULL, *defcontext = NULL;
868 char *fscontext = NULL, *rootcontext = NULL;
Eric Parise0007522008-03-05 10:31:54 -0500869 int rc, num_mnt_opts = 0;
Eric Parisc9180a52007-11-30 13:00:35 -0500870
Eric Parise0007522008-03-05 10:31:54 -0500871 opts->num_mnt_opts = 0;
Eric Parisc9180a52007-11-30 13:00:35 -0500872
873 /* Standard string-based options. */
874 while ((p = strsep(&options, "|")) != NULL) {
875 int token;
876 substring_t args[MAX_OPT_ARGS];
877
878 if (!*p)
879 continue;
880
881 token = match_token(p, tokens, args);
882
883 switch (token) {
884 case Opt_context:
885 if (context || defcontext) {
886 rc = -EINVAL;
887 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
888 goto out_err;
889 }
890 context = match_strdup(&args[0]);
891 if (!context) {
892 rc = -ENOMEM;
893 goto out_err;
894 }
895 break;
896
897 case Opt_fscontext:
898 if (fscontext) {
899 rc = -EINVAL;
900 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
901 goto out_err;
902 }
903 fscontext = match_strdup(&args[0]);
904 if (!fscontext) {
905 rc = -ENOMEM;
906 goto out_err;
907 }
908 break;
909
910 case Opt_rootcontext:
911 if (rootcontext) {
912 rc = -EINVAL;
913 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
914 goto out_err;
915 }
916 rootcontext = match_strdup(&args[0]);
917 if (!rootcontext) {
918 rc = -ENOMEM;
919 goto out_err;
920 }
921 break;
922
923 case Opt_defcontext:
924 if (context || defcontext) {
925 rc = -EINVAL;
926 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
927 goto out_err;
928 }
929 defcontext = match_strdup(&args[0]);
930 if (!defcontext) {
931 rc = -ENOMEM;
932 goto out_err;
933 }
934 break;
David P. Quigley11689d42009-01-16 09:22:03 -0500935 case Opt_labelsupport:
936 break;
Eric Parisc9180a52007-11-30 13:00:35 -0500937 default:
938 rc = -EINVAL;
939 printk(KERN_WARNING "SELinux: unknown mount option\n");
940 goto out_err;
941
942 }
943 }
944
Eric Parise0007522008-03-05 10:31:54 -0500945 rc = -ENOMEM;
946 opts->mnt_opts = kcalloc(NUM_SEL_MNT_OPTS, sizeof(char *), GFP_ATOMIC);
947 if (!opts->mnt_opts)
948 goto out_err;
949
950 opts->mnt_opts_flags = kcalloc(NUM_SEL_MNT_OPTS, sizeof(int), GFP_ATOMIC);
951 if (!opts->mnt_opts_flags) {
952 kfree(opts->mnt_opts);
953 goto out_err;
Eric Parisc9180a52007-11-30 13:00:35 -0500954 }
955
Eric Parise0007522008-03-05 10:31:54 -0500956 if (fscontext) {
957 opts->mnt_opts[num_mnt_opts] = fscontext;
958 opts->mnt_opts_flags[num_mnt_opts++] = FSCONTEXT_MNT;
959 }
960 if (context) {
961 opts->mnt_opts[num_mnt_opts] = context;
962 opts->mnt_opts_flags[num_mnt_opts++] = CONTEXT_MNT;
963 }
964 if (rootcontext) {
965 opts->mnt_opts[num_mnt_opts] = rootcontext;
966 opts->mnt_opts_flags[num_mnt_opts++] = ROOTCONTEXT_MNT;
967 }
968 if (defcontext) {
969 opts->mnt_opts[num_mnt_opts] = defcontext;
970 opts->mnt_opts_flags[num_mnt_opts++] = DEFCONTEXT_MNT;
971 }
972
973 opts->num_mnt_opts = num_mnt_opts;
974 return 0;
975
Eric Parisc9180a52007-11-30 13:00:35 -0500976out_err:
977 kfree(context);
978 kfree(defcontext);
979 kfree(fscontext);
980 kfree(rootcontext);
981 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982}
Eric Parise0007522008-03-05 10:31:54 -0500983/*
984 * string mount options parsing and call set the sbsec
985 */
986static int superblock_doinit(struct super_block *sb, void *data)
987{
988 int rc = 0;
989 char *options = data;
990 struct security_mnt_opts opts;
991
992 security_init_mnt_opts(&opts);
993
994 if (!data)
995 goto out;
996
997 BUG_ON(sb->s_type->fs_flags & FS_BINARY_MOUNTDATA);
998
999 rc = selinux_parse_opts_str(options, &opts);
1000 if (rc)
1001 goto out_err;
1002
1003out:
1004 rc = selinux_set_mnt_opts(sb, &opts);
1005
1006out_err:
1007 security_free_mnt_opts(&opts);
1008 return rc;
1009}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
Adrian Bunk3583a712008-07-22 20:21:23 +03001011static void selinux_write_opts(struct seq_file *m,
1012 struct security_mnt_opts *opts)
Eric Paris2069f452008-07-04 09:47:13 +10001013{
1014 int i;
1015 char *prefix;
1016
1017 for (i = 0; i < opts->num_mnt_opts; i++) {
David P. Quigley11689d42009-01-16 09:22:03 -05001018 char *has_comma;
1019
1020 if (opts->mnt_opts[i])
1021 has_comma = strchr(opts->mnt_opts[i], ',');
1022 else
1023 has_comma = NULL;
Eric Paris2069f452008-07-04 09:47:13 +10001024
1025 switch (opts->mnt_opts_flags[i]) {
1026 case CONTEXT_MNT:
1027 prefix = CONTEXT_STR;
1028 break;
1029 case FSCONTEXT_MNT:
1030 prefix = FSCONTEXT_STR;
1031 break;
1032 case ROOTCONTEXT_MNT:
1033 prefix = ROOTCONTEXT_STR;
1034 break;
1035 case DEFCONTEXT_MNT:
1036 prefix = DEFCONTEXT_STR;
1037 break;
David P. Quigley11689d42009-01-16 09:22:03 -05001038 case SE_SBLABELSUPP:
1039 seq_putc(m, ',');
1040 seq_puts(m, LABELSUPP_STR);
1041 continue;
Eric Paris2069f452008-07-04 09:47:13 +10001042 default:
1043 BUG();
1044 };
1045 /* we need a comma before each option */
1046 seq_putc(m, ',');
1047 seq_puts(m, prefix);
1048 if (has_comma)
1049 seq_putc(m, '\"');
1050 seq_puts(m, opts->mnt_opts[i]);
1051 if (has_comma)
1052 seq_putc(m, '\"');
1053 }
1054}
1055
1056static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb)
1057{
1058 struct security_mnt_opts opts;
1059 int rc;
1060
1061 rc = selinux_get_mnt_opts(sb, &opts);
Eric Paris383795c2008-07-29 17:07:26 -04001062 if (rc) {
1063 /* before policy load we may get EINVAL, don't show anything */
1064 if (rc == -EINVAL)
1065 rc = 0;
Eric Paris2069f452008-07-04 09:47:13 +10001066 return rc;
Eric Paris383795c2008-07-29 17:07:26 -04001067 }
Eric Paris2069f452008-07-04 09:47:13 +10001068
1069 selinux_write_opts(m, &opts);
1070
1071 security_free_mnt_opts(&opts);
1072
1073 return rc;
1074}
1075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076static inline u16 inode_mode_to_security_class(umode_t mode)
1077{
1078 switch (mode & S_IFMT) {
1079 case S_IFSOCK:
1080 return SECCLASS_SOCK_FILE;
1081 case S_IFLNK:
1082 return SECCLASS_LNK_FILE;
1083 case S_IFREG:
1084 return SECCLASS_FILE;
1085 case S_IFBLK:
1086 return SECCLASS_BLK_FILE;
1087 case S_IFDIR:
1088 return SECCLASS_DIR;
1089 case S_IFCHR:
1090 return SECCLASS_CHR_FILE;
1091 case S_IFIFO:
1092 return SECCLASS_FIFO_FILE;
1093
1094 }
1095
1096 return SECCLASS_FILE;
1097}
1098
James Morris13402582005-09-30 14:24:34 -04001099static inline int default_protocol_stream(int protocol)
1100{
1101 return (protocol == IPPROTO_IP || protocol == IPPROTO_TCP);
1102}
1103
1104static inline int default_protocol_dgram(int protocol)
1105{
1106 return (protocol == IPPROTO_IP || protocol == IPPROTO_UDP);
1107}
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109static inline u16 socket_type_to_security_class(int family, int type, int protocol)
1110{
1111 switch (family) {
1112 case PF_UNIX:
1113 switch (type) {
1114 case SOCK_STREAM:
1115 case SOCK_SEQPACKET:
1116 return SECCLASS_UNIX_STREAM_SOCKET;
1117 case SOCK_DGRAM:
1118 return SECCLASS_UNIX_DGRAM_SOCKET;
1119 }
1120 break;
1121 case PF_INET:
1122 case PF_INET6:
1123 switch (type) {
1124 case SOCK_STREAM:
James Morris13402582005-09-30 14:24:34 -04001125 if (default_protocol_stream(protocol))
1126 return SECCLASS_TCP_SOCKET;
1127 else
1128 return SECCLASS_RAWIP_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 case SOCK_DGRAM:
James Morris13402582005-09-30 14:24:34 -04001130 if (default_protocol_dgram(protocol))
1131 return SECCLASS_UDP_SOCKET;
1132 else
1133 return SECCLASS_RAWIP_SOCKET;
James Morris2ee92d42006-11-13 16:09:01 -08001134 case SOCK_DCCP:
1135 return SECCLASS_DCCP_SOCKET;
James Morris13402582005-09-30 14:24:34 -04001136 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 return SECCLASS_RAWIP_SOCKET;
1138 }
1139 break;
1140 case PF_NETLINK:
1141 switch (protocol) {
1142 case NETLINK_ROUTE:
1143 return SECCLASS_NETLINK_ROUTE_SOCKET;
1144 case NETLINK_FIREWALL:
1145 return SECCLASS_NETLINK_FIREWALL_SOCKET;
James Morris216efaa2005-08-15 20:34:48 -07001146 case NETLINK_INET_DIAG:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 return SECCLASS_NETLINK_TCPDIAG_SOCKET;
1148 case NETLINK_NFLOG:
1149 return SECCLASS_NETLINK_NFLOG_SOCKET;
1150 case NETLINK_XFRM:
1151 return SECCLASS_NETLINK_XFRM_SOCKET;
1152 case NETLINK_SELINUX:
1153 return SECCLASS_NETLINK_SELINUX_SOCKET;
1154 case NETLINK_AUDIT:
1155 return SECCLASS_NETLINK_AUDIT_SOCKET;
1156 case NETLINK_IP6_FW:
1157 return SECCLASS_NETLINK_IP6FW_SOCKET;
1158 case NETLINK_DNRTMSG:
1159 return SECCLASS_NETLINK_DNRT_SOCKET;
James Morris0c9b7942005-04-16 15:24:13 -07001160 case NETLINK_KOBJECT_UEVENT:
1161 return SECCLASS_NETLINK_KOBJECT_UEVENT_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 default:
1163 return SECCLASS_NETLINK_SOCKET;
1164 }
1165 case PF_PACKET:
1166 return SECCLASS_PACKET_SOCKET;
1167 case PF_KEY:
1168 return SECCLASS_KEY_SOCKET;
Christopher J. PeBenito3e3ff152006-06-09 00:25:03 -07001169 case PF_APPLETALK:
1170 return SECCLASS_APPLETALK_SOCKET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172
1173 return SECCLASS_SOCKET;
1174}
1175
1176#ifdef CONFIG_PROC_FS
1177static int selinux_proc_get_sid(struct proc_dir_entry *de,
1178 u16 tclass,
1179 u32 *sid)
1180{
1181 int buflen, rc;
1182 char *buffer, *path, *end;
1183
Eric Paris828dfe12008-04-17 13:17:49 -04001184 buffer = (char *)__get_free_page(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 if (!buffer)
1186 return -ENOMEM;
1187
1188 buflen = PAGE_SIZE;
1189 end = buffer+buflen;
1190 *--end = '\0';
1191 buflen--;
1192 path = end-1;
1193 *path = '/';
1194 while (de && de != de->parent) {
1195 buflen -= de->namelen + 1;
1196 if (buflen < 0)
1197 break;
1198 end -= de->namelen;
1199 memcpy(end, de->name, de->namelen);
1200 *--end = '/';
1201 path = end;
1202 de = de->parent;
1203 }
1204 rc = security_genfs_sid("proc", path, tclass, sid);
1205 free_page((unsigned long)buffer);
1206 return rc;
1207}
1208#else
1209static int selinux_proc_get_sid(struct proc_dir_entry *de,
1210 u16 tclass,
1211 u32 *sid)
1212{
1213 return -EINVAL;
1214}
1215#endif
1216
1217/* The inode's security attributes must be initialized before first use. */
1218static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry)
1219{
1220 struct superblock_security_struct *sbsec = NULL;
1221 struct inode_security_struct *isec = inode->i_security;
1222 u32 sid;
1223 struct dentry *dentry;
1224#define INITCONTEXTLEN 255
1225 char *context = NULL;
1226 unsigned len = 0;
1227 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
1229 if (isec->initialized)
1230 goto out;
1231
Eric Paris23970742006-09-25 23:32:01 -07001232 mutex_lock(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 if (isec->initialized)
Eric Paris23970742006-09-25 23:32:01 -07001234 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
1236 sbsec = inode->i_sb->s_security;
David P. Quigley0d90a7e2009-01-16 09:22:02 -05001237 if (!(sbsec->flags & SE_SBINITIALIZED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 /* Defer initialization until selinux_complete_init,
1239 after the initial policy is loaded and the security
1240 server is ready to handle calls. */
1241 spin_lock(&sbsec->isec_lock);
1242 if (list_empty(&isec->list))
1243 list_add(&isec->list, &sbsec->isec_head);
1244 spin_unlock(&sbsec->isec_lock);
Eric Paris23970742006-09-25 23:32:01 -07001245 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 }
1247
1248 switch (sbsec->behavior) {
1249 case SECURITY_FS_USE_XATTR:
1250 if (!inode->i_op->getxattr) {
1251 isec->sid = sbsec->def_sid;
1252 break;
1253 }
1254
1255 /* Need a dentry, since the xattr API requires one.
1256 Life would be simpler if we could just pass the inode. */
1257 if (opt_dentry) {
1258 /* Called from d_instantiate or d_splice_alias. */
1259 dentry = dget(opt_dentry);
1260 } else {
1261 /* Called from selinux_complete_init, try to find a dentry. */
1262 dentry = d_find_alias(inode);
1263 }
1264 if (!dentry) {
Eric Parisdf7f54c2009-03-09 14:35:58 -04001265 /*
1266 * this is can be hit on boot when a file is accessed
1267 * before the policy is loaded. When we load policy we
1268 * may find inodes that have no dentry on the
1269 * sbsec->isec_head list. No reason to complain as these
1270 * will get fixed up the next time we go through
1271 * inode_doinit with a dentry, before these inodes could
1272 * be used again by userspace.
1273 */
Eric Paris23970742006-09-25 23:32:01 -07001274 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 }
1276
1277 len = INITCONTEXTLEN;
Eric Paris4cb912f2009-02-12 14:50:05 -05001278 context = kmalloc(len+1, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 if (!context) {
1280 rc = -ENOMEM;
1281 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001282 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
Eric Paris4cb912f2009-02-12 14:50:05 -05001284 context[len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1286 context, len);
1287 if (rc == -ERANGE) {
1288 /* Need a larger buffer. Query for the right size. */
1289 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1290 NULL, 0);
1291 if (rc < 0) {
1292 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001293 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 }
1295 kfree(context);
1296 len = rc;
Eric Paris4cb912f2009-02-12 14:50:05 -05001297 context = kmalloc(len+1, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 if (!context) {
1299 rc = -ENOMEM;
1300 dput(dentry);
Eric Paris23970742006-09-25 23:32:01 -07001301 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
Eric Paris4cb912f2009-02-12 14:50:05 -05001303 context[len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 rc = inode->i_op->getxattr(dentry,
1305 XATTR_NAME_SELINUX,
1306 context, len);
1307 }
1308 dput(dentry);
1309 if (rc < 0) {
1310 if (rc != -ENODATA) {
Eric Paris744ba352008-04-17 11:52:44 -04001311 printk(KERN_WARNING "SELinux: %s: getxattr returned "
Harvey Harrisondd6f9532008-03-06 10:03:59 +11001312 "%d for dev=%s ino=%ld\n", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 -rc, inode->i_sb->s_id, inode->i_ino);
1314 kfree(context);
Eric Paris23970742006-09-25 23:32:01 -07001315 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 }
1317 /* Map ENODATA to the default file SID */
1318 sid = sbsec->def_sid;
1319 rc = 0;
1320 } else {
James Morrisf5c1d5b2005-07-28 01:07:37 -07001321 rc = security_context_to_sid_default(context, rc, &sid,
Stephen Smalley869ab512008-04-04 08:46:05 -04001322 sbsec->def_sid,
1323 GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 if (rc) {
Eric Paris4ba0a8a2009-02-12 15:01:10 -05001325 char *dev = inode->i_sb->s_id;
1326 unsigned long ino = inode->i_ino;
1327
1328 if (rc == -EINVAL) {
1329 if (printk_ratelimit())
1330 printk(KERN_NOTICE "SELinux: inode=%lu on dev=%s was found to have an invalid "
1331 "context=%s. This indicates you may need to relabel the inode or the "
1332 "filesystem in question.\n", ino, dev, context);
1333 } else {
1334 printk(KERN_WARNING "SELinux: %s: context_to_sid(%s) "
1335 "returned %d for dev=%s ino=%ld\n",
1336 __func__, context, -rc, dev, ino);
1337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 kfree(context);
1339 /* Leave with the unlabeled SID */
1340 rc = 0;
1341 break;
1342 }
1343 }
1344 kfree(context);
1345 isec->sid = sid;
1346 break;
1347 case SECURITY_FS_USE_TASK:
1348 isec->sid = isec->task_sid;
1349 break;
1350 case SECURITY_FS_USE_TRANS:
1351 /* Default to the fs SID. */
1352 isec->sid = sbsec->sid;
1353
1354 /* Try to obtain a transition SID. */
1355 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1356 rc = security_transition_sid(isec->task_sid,
1357 sbsec->sid,
1358 isec->sclass,
1359 &sid);
1360 if (rc)
Eric Paris23970742006-09-25 23:32:01 -07001361 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 isec->sid = sid;
1363 break;
Eric Parisc312feb2006-07-10 04:43:53 -07001364 case SECURITY_FS_USE_MNTPOINT:
1365 isec->sid = sbsec->mntpoint_sid;
1366 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 default:
Eric Parisc312feb2006-07-10 04:43:53 -07001368 /* Default to the fs superblock SID. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 isec->sid = sbsec->sid;
1370
David P. Quigley0d90a7e2009-01-16 09:22:02 -05001371 if ((sbsec->flags & SE_SBPROC) && !S_ISLNK(inode->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 struct proc_inode *proci = PROC_I(inode);
1373 if (proci->pde) {
1374 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1375 rc = selinux_proc_get_sid(proci->pde,
1376 isec->sclass,
1377 &sid);
1378 if (rc)
Eric Paris23970742006-09-25 23:32:01 -07001379 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 isec->sid = sid;
1381 }
1382 }
1383 break;
1384 }
1385
1386 isec->initialized = 1;
1387
Eric Paris23970742006-09-25 23:32:01 -07001388out_unlock:
1389 mutex_unlock(&isec->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390out:
1391 if (isec->sclass == SECCLASS_FILE)
1392 isec->sclass = inode_mode_to_security_class(inode->i_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 return rc;
1394}
1395
1396/* Convert a Linux signal to an access vector. */
1397static inline u32 signal_to_av(int sig)
1398{
1399 u32 perm = 0;
1400
1401 switch (sig) {
1402 case SIGCHLD:
1403 /* Commonly granted from child to parent. */
1404 perm = PROCESS__SIGCHLD;
1405 break;
1406 case SIGKILL:
1407 /* Cannot be caught or ignored */
1408 perm = PROCESS__SIGKILL;
1409 break;
1410 case SIGSTOP:
1411 /* Cannot be caught or ignored */
1412 perm = PROCESS__SIGSTOP;
1413 break;
1414 default:
1415 /* All other signals. */
1416 perm = PROCESS__SIGNAL;
1417 break;
1418 }
1419
1420 return perm;
1421}
1422
David Howells275bb412008-11-14 10:39:19 +11001423/*
David Howellsd84f4f92008-11-14 10:39:23 +11001424 * Check permission between a pair of credentials
1425 * fork check, ptrace check, etc.
1426 */
1427static int cred_has_perm(const struct cred *actor,
1428 const struct cred *target,
1429 u32 perms)
1430{
1431 u32 asid = cred_sid(actor), tsid = cred_sid(target);
1432
1433 return avc_has_perm(asid, tsid, SECCLASS_PROCESS, perms, NULL);
1434}
1435
1436/*
David Howells88e67f32008-11-14 10:39:21 +11001437 * Check permission between a pair of tasks, e.g. signal checks,
David Howells275bb412008-11-14 10:39:19 +11001438 * fork check, ptrace check, etc.
1439 * tsk1 is the actor and tsk2 is the target
David Howells3b11a1d2008-11-14 10:39:26 +11001440 * - this uses the default subjective creds of tsk1
David Howells275bb412008-11-14 10:39:19 +11001441 */
1442static int task_has_perm(const struct task_struct *tsk1,
1443 const struct task_struct *tsk2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 u32 perms)
1445{
David Howells275bb412008-11-14 10:39:19 +11001446 const struct task_security_struct *__tsec1, *__tsec2;
1447 u32 sid1, sid2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
David Howells275bb412008-11-14 10:39:19 +11001449 rcu_read_lock();
1450 __tsec1 = __task_cred(tsk1)->security; sid1 = __tsec1->sid;
1451 __tsec2 = __task_cred(tsk2)->security; sid2 = __tsec2->sid;
1452 rcu_read_unlock();
1453 return avc_has_perm(sid1, sid2, SECCLASS_PROCESS, perms, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454}
1455
David Howells3b11a1d2008-11-14 10:39:26 +11001456/*
1457 * Check permission between current and another task, e.g. signal checks,
1458 * fork check, ptrace check, etc.
1459 * current is the actor and tsk2 is the target
1460 * - this uses current's subjective creds
1461 */
1462static int current_has_perm(const struct task_struct *tsk,
1463 u32 perms)
1464{
1465 u32 sid, tsid;
1466
1467 sid = current_sid();
1468 tsid = task_sid(tsk);
1469 return avc_has_perm(sid, tsid, SECCLASS_PROCESS, perms, NULL);
1470}
1471
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001472#if CAP_LAST_CAP > 63
1473#error Fix SELinux to handle capabilities > 63.
1474#endif
1475
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476/* Check whether a task is allowed to use a capability. */
1477static int task_has_capability(struct task_struct *tsk,
David Howells3699c532009-01-06 22:27:01 +00001478 const struct cred *cred,
Eric Paris06112162008-11-11 22:02:50 +11001479 int cap, int audit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 struct avc_audit_data ad;
Eric Paris06112162008-11-11 22:02:50 +11001482 struct av_decision avd;
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001483 u16 sclass;
David Howells3699c532009-01-06 22:27:01 +00001484 u32 sid = cred_sid(cred);
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001485 u32 av = CAP_TO_MASK(cap);
Eric Paris06112162008-11-11 22:02:50 +11001486 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
Eric Paris828dfe12008-04-17 13:17:49 -04001488 AVC_AUDIT_DATA_INIT(&ad, CAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 ad.tsk = tsk;
1490 ad.u.cap = cap;
1491
Stephen Smalleyb68e4182008-02-07 11:21:04 -05001492 switch (CAP_TO_INDEX(cap)) {
1493 case 0:
1494 sclass = SECCLASS_CAPABILITY;
1495 break;
1496 case 1:
1497 sclass = SECCLASS_CAPABILITY2;
1498 break;
1499 default:
1500 printk(KERN_ERR
1501 "SELinux: out of range capability %d\n", cap);
1502 BUG();
1503 }
Eric Paris06112162008-11-11 22:02:50 +11001504
David Howells275bb412008-11-14 10:39:19 +11001505 rc = avc_has_perm_noaudit(sid, sid, sclass, av, 0, &avd);
Eric Paris06112162008-11-11 22:02:50 +11001506 if (audit == SECURITY_CAP_AUDIT)
David Howells275bb412008-11-14 10:39:19 +11001507 avc_audit(sid, sid, sclass, av, &avd, rc, &ad);
Eric Paris06112162008-11-11 22:02:50 +11001508 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509}
1510
1511/* Check whether a task is allowed to use a system operation. */
1512static int task_has_system(struct task_struct *tsk,
1513 u32 perms)
1514{
David Howells275bb412008-11-14 10:39:19 +11001515 u32 sid = task_sid(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
David Howells275bb412008-11-14 10:39:19 +11001517 return avc_has_perm(sid, SECINITSID_KERNEL,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 SECCLASS_SYSTEM, perms, NULL);
1519}
1520
1521/* Check whether a task has a particular permission to an inode.
1522 The 'adp' parameter is optional and allows other audit
1523 data to be passed (e.g. the dentry). */
David Howells88e67f32008-11-14 10:39:21 +11001524static int inode_has_perm(const struct cred *cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 struct inode *inode,
1526 u32 perms,
1527 struct avc_audit_data *adp)
1528{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 struct inode_security_struct *isec;
1530 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11001531 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
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;
1541 AVC_AUDIT_DATA_INIT(&ad, FS);
1542 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;
1557 struct avc_audit_data ad;
David Howells88e67f32008-11-14 10:39:21 +11001558
Eric Paris828dfe12008-04-17 13:17:49 -04001559 AVC_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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 struct avc_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
1583 AVC_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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 struct avc_audit_data ad;
1615 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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 AVC_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;
1667 struct avc_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
1675 AVC_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;
1710 struct avc_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
1721 AVC_AUDIT_DATA_INIT(&ad, FS);
1722
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,
1763 struct avc_audit_data *ad)
1764{
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
David Howells5cd9c582008-08-14 11:37:28 +01001857static int selinux_ptrace_may_access(struct task_struct *child,
1858 unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 int rc;
1861
Eric Paris200ac532009-02-12 15:01:04 -05001862 rc = cap_ptrace_may_access(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
1983 rc = secondary_ops->sysctl(table, op);
1984 if (rc)
1985 return rc;
1986
David Howells275bb412008-11-14 10:39:19 +11001987 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988
Eric W. Biederman3fbfa982007-02-14 00:34:14 -08001989 rc = selinux_sysctl_get_sid(table, (op == 0001) ?
1990 SECCLASS_DIR : SECCLASS_FILE, &tsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 if (rc) {
1992 /* Default to the well-defined sysctl SID. */
1993 tsid = SECINITSID_SYSCTL;
1994 }
1995
1996 /* The op values are "defined" in sysctl.c, thereby creating
1997 * a bad coupling between this module and sysctl.c */
Eric Paris828dfe12008-04-17 13:17:49 -04001998 if (op == 001) {
David Howells275bb412008-11-14 10:39:19 +11001999 error = avc_has_perm(sid, tsid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 SECCLASS_DIR, DIR__SEARCH, NULL);
2001 } else {
2002 av = 0;
2003 if (op & 004)
2004 av |= FILE__READ;
2005 if (op & 002)
2006 av |= FILE__WRITE;
2007 if (av)
David Howells275bb412008-11-14 10:39:19 +11002008 error = avc_has_perm(sid, tsid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 SECCLASS_FILE, av, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04002010 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011
2012 return error;
2013}
2014
2015static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
2016{
David Howells88e67f32008-11-14 10:39:21 +11002017 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 int rc = 0;
2019
2020 if (!sb)
2021 return 0;
2022
2023 switch (cmds) {
Eric Paris828dfe12008-04-17 13:17:49 -04002024 case Q_SYNC:
2025 case Q_QUOTAON:
2026 case Q_QUOTAOFF:
2027 case Q_SETINFO:
2028 case Q_SETQUOTA:
David Howells88e67f32008-11-14 10:39:21 +11002029 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAMOD, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04002030 break;
2031 case Q_GETFMT:
2032 case Q_GETINFO:
2033 case Q_GETQUOTA:
David Howells88e67f32008-11-14 10:39:21 +11002034 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAGET, NULL);
Eric Paris828dfe12008-04-17 13:17:49 -04002035 break;
2036 default:
2037 rc = 0; /* let the kernel handle invalid cmds */
2038 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 }
2040 return rc;
2041}
2042
2043static int selinux_quota_on(struct dentry *dentry)
2044{
David Howells88e67f32008-11-14 10:39:21 +11002045 const struct cred *cred = current_cred();
2046
2047 return dentry_has_perm(cred, NULL, dentry, FILE__QUOTAON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048}
2049
2050static int selinux_syslog(int type)
2051{
2052 int rc;
2053
Eric Paris200ac532009-02-12 15:01:04 -05002054 rc = cap_syslog(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 if (rc)
2056 return rc;
2057
2058 switch (type) {
Eric Paris828dfe12008-04-17 13:17:49 -04002059 case 3: /* Read last kernel messages */
2060 case 10: /* Return size of the log buffer */
2061 rc = task_has_system(current, SYSTEM__SYSLOG_READ);
2062 break;
2063 case 6: /* Disable logging to console */
2064 case 7: /* Enable logging to console */
2065 case 8: /* Set level of messages printed to console */
2066 rc = task_has_system(current, SYSTEM__SYSLOG_CONSOLE);
2067 break;
2068 case 0: /* Close log */
2069 case 1: /* Open log */
2070 case 2: /* Read from log */
2071 case 4: /* Read/clear last kernel messages */
2072 case 5: /* Clear ring buffer */
2073 default:
2074 rc = task_has_system(current, SYSTEM__SYSLOG_MOD);
2075 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 }
2077 return rc;
2078}
2079
2080/*
2081 * Check that a process has enough memory to allocate a new virtual
2082 * mapping. 0 means there is enough memory for the allocation to
2083 * succeed and -ENOMEM implies there is not.
2084 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 * Do not audit the selinux permission check, as this is applied to all
2086 * processes that allocate mappings.
2087 */
Alan Cox34b4e4a2007-08-22 14:01:28 -07002088static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089{
2090 int rc, cap_sys_admin = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091
David Howells3699c532009-01-06 22:27:01 +00002092 rc = selinux_capable(current, current_cred(), CAP_SYS_ADMIN,
2093 SECURITY_CAP_NOAUDIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 if (rc == 0)
2095 cap_sys_admin = 1;
2096
Alan Cox34b4e4a2007-08-22 14:01:28 -07002097 return __vm_enough_memory(mm, pages, cap_sys_admin);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098}
2099
2100/* binprm security operations */
2101
David Howellsa6f76f22008-11-14 10:39:24 +11002102static int selinux_bprm_set_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103{
David Howellsa6f76f22008-11-14 10:39:24 +11002104 const struct task_security_struct *old_tsec;
2105 struct task_security_struct *new_tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 struct inode_security_struct *isec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 struct avc_audit_data ad;
David Howellsa6f76f22008-11-14 10:39:24 +11002108 struct inode *inode = bprm->file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 int rc;
2110
Eric Paris200ac532009-02-12 15:01:04 -05002111 rc = cap_bprm_set_creds(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 if (rc)
2113 return rc;
2114
David Howellsa6f76f22008-11-14 10:39:24 +11002115 /* SELinux context only depends on initial program or script and not
2116 * the script interpreter */
2117 if (bprm->cred_prepared)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 return 0;
2119
David Howellsa6f76f22008-11-14 10:39:24 +11002120 old_tsec = current_security();
2121 new_tsec = bprm->cred->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 isec = inode->i_security;
2123
2124 /* Default to the current task SID. */
David Howellsa6f76f22008-11-14 10:39:24 +11002125 new_tsec->sid = old_tsec->sid;
2126 new_tsec->osid = old_tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127
Michael LeMay28eba5b2006-06-27 02:53:42 -07002128 /* Reset fs, key, and sock SIDs on execve. */
David Howellsa6f76f22008-11-14 10:39:24 +11002129 new_tsec->create_sid = 0;
2130 new_tsec->keycreate_sid = 0;
2131 new_tsec->sockcreate_sid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
David Howellsa6f76f22008-11-14 10:39:24 +11002133 if (old_tsec->exec_sid) {
2134 new_tsec->sid = old_tsec->exec_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 /* Reset exec SID on execve. */
David Howellsa6f76f22008-11-14 10:39:24 +11002136 new_tsec->exec_sid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 } else {
2138 /* Check for a default transition on this program. */
David Howellsa6f76f22008-11-14 10:39:24 +11002139 rc = security_transition_sid(old_tsec->sid, isec->sid,
2140 SECCLASS_PROCESS, &new_tsec->sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 if (rc)
2142 return rc;
2143 }
2144
2145 AVC_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002146 ad.u.fs.path = bprm->file->f_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
Josef Sipek3d5ff522006-12-08 02:37:38 -08002148 if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
David Howellsa6f76f22008-11-14 10:39:24 +11002149 new_tsec->sid = old_tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150
David Howellsa6f76f22008-11-14 10:39:24 +11002151 if (new_tsec->sid == old_tsec->sid) {
2152 rc = avc_has_perm(old_tsec->sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 SECCLASS_FILE, FILE__EXECUTE_NO_TRANS, &ad);
2154 if (rc)
2155 return rc;
2156 } else {
2157 /* Check permissions for the transition. */
David Howellsa6f76f22008-11-14 10:39:24 +11002158 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 SECCLASS_PROCESS, PROCESS__TRANSITION, &ad);
2160 if (rc)
2161 return rc;
2162
David Howellsa6f76f22008-11-14 10:39:24 +11002163 rc = avc_has_perm(new_tsec->sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 SECCLASS_FILE, FILE__ENTRYPOINT, &ad);
2165 if (rc)
2166 return rc;
2167
David Howellsa6f76f22008-11-14 10:39:24 +11002168 /* Check for shared state */
2169 if (bprm->unsafe & LSM_UNSAFE_SHARE) {
2170 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2171 SECCLASS_PROCESS, PROCESS__SHARE,
2172 NULL);
2173 if (rc)
2174 return -EPERM;
2175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176
David Howellsa6f76f22008-11-14 10:39:24 +11002177 /* Make sure that anyone attempting to ptrace over a task that
2178 * changes its SID has the appropriate permit */
2179 if (bprm->unsafe &
2180 (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
2181 struct task_struct *tracer;
2182 struct task_security_struct *sec;
2183 u32 ptsid = 0;
2184
2185 rcu_read_lock();
2186 tracer = tracehook_tracer_task(current);
2187 if (likely(tracer != NULL)) {
2188 sec = __task_cred(tracer)->security;
2189 ptsid = sec->sid;
2190 }
2191 rcu_read_unlock();
2192
2193 if (ptsid != 0) {
2194 rc = avc_has_perm(ptsid, new_tsec->sid,
2195 SECCLASS_PROCESS,
2196 PROCESS__PTRACE, NULL);
2197 if (rc)
2198 return -EPERM;
2199 }
2200 }
2201
2202 /* Clear any possibly unsafe personality bits on exec: */
2203 bprm->per_clear |= PER_CLEAR_ON_SETID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 }
2205
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 return 0;
2207}
2208
Eric Paris828dfe12008-04-17 13:17:49 -04002209static int selinux_bprm_secureexec(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210{
David Howells275bb412008-11-14 10:39:19 +11002211 const struct cred *cred = current_cred();
2212 const struct task_security_struct *tsec = cred->security;
2213 u32 sid, osid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 int atsecure = 0;
2215
David Howells275bb412008-11-14 10:39:19 +11002216 sid = tsec->sid;
2217 osid = tsec->osid;
2218
2219 if (osid != sid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 /* Enable secure mode for SIDs transitions unless
2221 the noatsecure permission is granted between
2222 the two SIDs, i.e. ahp returns 0. */
David Howells275bb412008-11-14 10:39:19 +11002223 atsecure = avc_has_perm(osid, sid,
David Howellsa6f76f22008-11-14 10:39:24 +11002224 SECCLASS_PROCESS,
2225 PROCESS__NOATSECURE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 }
2227
Eric Paris200ac532009-02-12 15:01:04 -05002228 return (atsecure || cap_bprm_secureexec(bprm));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229}
2230
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231extern struct vfsmount *selinuxfs_mount;
2232extern struct dentry *selinux_null;
2233
2234/* Derived from fs/exec.c:flush_old_files. */
David Howells745ca242008-11-14 10:39:22 +11002235static inline void flush_unauthorized_files(const struct cred *cred,
2236 struct files_struct *files)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237{
2238 struct avc_audit_data ad;
2239 struct file *file, *devnull = NULL;
Stephen Smalleyb20c8122006-09-25 23:32:03 -07002240 struct tty_struct *tty;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002241 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 long j = -1;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002243 int drop_tty = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002245 tty = get_current_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 if (tty) {
2247 file_list_lock();
Eric Paris37dd0bd2008-10-31 17:40:00 -04002248 if (!list_empty(&tty->tty_files)) {
2249 struct inode *inode;
2250
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 /* Revalidate access to controlling tty.
2252 Use inode_has_perm on the tty inode directly rather
2253 than using file_has_perm, as this particular open
2254 file may belong to another process and we are only
2255 interested in the inode-based check here. */
Eric Paris37dd0bd2008-10-31 17:40:00 -04002256 file = list_first_entry(&tty->tty_files, struct file, f_u.fu_list);
2257 inode = file->f_path.dentry->d_inode;
David Howells88e67f32008-11-14 10:39:21 +11002258 if (inode_has_perm(cred, inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 FILE__READ | FILE__WRITE, NULL)) {
Peter Zijlstra24ec8392006-12-08 02:36:04 -08002260 drop_tty = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 }
2262 }
2263 file_list_unlock();
Alan Cox452a00d2008-10-13 10:39:13 +01002264 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 }
Eric W. Biederman98a27ba2007-05-08 00:26:56 -07002266 /* Reset controlling tty. */
2267 if (drop_tty)
2268 no_tty();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269
2270 /* Revalidate access to inherited open files. */
2271
Eric Paris828dfe12008-04-17 13:17:49 -04002272 AVC_AUDIT_DATA_INIT(&ad, FS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273
2274 spin_lock(&files->file_lock);
2275 for (;;) {
2276 unsigned long set, i;
2277 int fd;
2278
2279 j++;
2280 i = j * __NFDBITS;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002281 fdt = files_fdtable(files);
Vadim Lobanovbbea9f62006-12-10 02:21:12 -08002282 if (i >= fdt->max_fds)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 break;
Dipankar Sarmabadf1662005-09-09 13:04:10 -07002284 set = fdt->open_fds->fds_bits[j];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 if (!set)
2286 continue;
2287 spin_unlock(&files->file_lock);
Eric Paris828dfe12008-04-17 13:17:49 -04002288 for ( ; set ; i++, set >>= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 if (set & 1) {
2290 file = fget(i);
2291 if (!file)
2292 continue;
David Howells88e67f32008-11-14 10:39:21 +11002293 if (file_has_perm(cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 file,
2295 file_to_av(file))) {
2296 sys_close(i);
2297 fd = get_unused_fd();
2298 if (fd != i) {
2299 if (fd >= 0)
2300 put_unused_fd(fd);
2301 fput(file);
2302 continue;
2303 }
2304 if (devnull) {
Nick Piggin095975d2006-01-08 01:02:19 -08002305 get_file(devnull);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 } else {
David Howells745ca242008-11-14 10:39:22 +11002307 devnull = dentry_open(
2308 dget(selinux_null),
2309 mntget(selinuxfs_mount),
2310 O_RDWR, cred);
Akinobu Mitafc5d81e2006-11-27 15:16:48 +09002311 if (IS_ERR(devnull)) {
2312 devnull = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 put_unused_fd(fd);
2314 fput(file);
2315 continue;
2316 }
2317 }
2318 fd_install(fd, devnull);
2319 }
2320 fput(file);
2321 }
2322 }
2323 spin_lock(&files->file_lock);
2324
2325 }
2326 spin_unlock(&files->file_lock);
2327}
2328
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329/*
David Howellsa6f76f22008-11-14 10:39:24 +11002330 * Prepare a process for imminent new credential changes due to exec
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 */
David Howellsa6f76f22008-11-14 10:39:24 +11002332static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333{
David Howellsa6f76f22008-11-14 10:39:24 +11002334 struct task_security_struct *new_tsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 struct rlimit *rlim, *initrlim;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 int rc, i;
2337
David Howellsa6f76f22008-11-14 10:39:24 +11002338 new_tsec = bprm->cred->security;
2339 if (new_tsec->sid == new_tsec->osid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 return;
2341
2342 /* Close files for which the new task SID is not authorized. */
David Howellsa6f76f22008-11-14 10:39:24 +11002343 flush_unauthorized_files(bprm->cred, current->files);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344
David Howellsa6f76f22008-11-14 10:39:24 +11002345 /* Always clear parent death signal on SID transitions. */
2346 current->pdeath_signal = 0;
2347
2348 /* Check whether the new SID can inherit resource limits from the old
2349 * SID. If not, reset all soft limits to the lower of the current
2350 * task's hard limit and the init task's soft limit.
2351 *
2352 * Note that the setting of hard limits (even to lower them) can be
2353 * controlled by the setrlimit check. The inclusion of the init task's
2354 * soft limit into the computation is to avoid resetting soft limits
2355 * higher than the default soft limit for cases where the default is
2356 * lower than the hard limit, e.g. RLIMIT_CORE or RLIMIT_STACK.
2357 */
2358 rc = avc_has_perm(new_tsec->osid, new_tsec->sid, SECCLASS_PROCESS,
2359 PROCESS__RLIMITINH, NULL);
2360 if (rc) {
2361 for (i = 0; i < RLIM_NLIMITS; i++) {
2362 rlim = current->signal->rlim + i;
2363 initrlim = init_task.signal->rlim + i;
2364 rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
2365 }
2366 update_rlimit_cpu(rlim->rlim_cur);
2367 }
2368}
2369
2370/*
2371 * Clean up the process immediately after the installation of new credentials
2372 * due to exec
2373 */
2374static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
2375{
2376 const struct task_security_struct *tsec = current_security();
2377 struct itimerval itimer;
2378 struct sighand_struct *psig;
2379 u32 osid, sid;
2380 int rc, i;
2381 unsigned long flags;
2382
David Howellsa6f76f22008-11-14 10:39:24 +11002383 osid = tsec->osid;
2384 sid = tsec->sid;
2385
2386 if (sid == osid)
2387 return;
2388
2389 /* Check whether the new SID can inherit signal state from the old SID.
2390 * If not, clear itimers to avoid subsequent signal generation and
2391 * flush and unblock signals.
2392 *
2393 * This must occur _after_ the task SID has been updated so that any
2394 * kill done after the flush will be checked against the new SID.
2395 */
2396 rc = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__SIGINH, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397 if (rc) {
2398 memset(&itimer, 0, sizeof itimer);
2399 for (i = 0; i < 3; i++)
2400 do_setitimer(i, &itimer, NULL);
2401 flush_signals(current);
2402 spin_lock_irq(&current->sighand->siglock);
2403 flush_signal_handlers(current, 1);
2404 sigemptyset(&current->blocked);
2405 recalc_sigpending();
2406 spin_unlock_irq(&current->sighand->siglock);
2407 }
2408
David Howellsa6f76f22008-11-14 10:39:24 +11002409 /* Wake up the parent if it is waiting so that it can recheck
2410 * wait permission to the new task SID. */
Eric Paris41d9f9c2008-11-04 15:18:26 -05002411 read_lock_irq(&tasklist_lock);
2412 psig = current->parent->sighand;
2413 spin_lock_irqsave(&psig->siglock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 wake_up_interruptible(&current->parent->signal->wait_chldexit);
Eric Paris41d9f9c2008-11-04 15:18:26 -05002415 spin_unlock_irqrestore(&psig->siglock, flags);
2416 read_unlock_irq(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417}
2418
2419/* superblock security operations */
2420
2421static int selinux_sb_alloc_security(struct super_block *sb)
2422{
2423 return superblock_alloc_security(sb);
2424}
2425
2426static void selinux_sb_free_security(struct super_block *sb)
2427{
2428 superblock_free_security(sb);
2429}
2430
2431static inline int match_prefix(char *prefix, int plen, char *option, int olen)
2432{
2433 if (plen > olen)
2434 return 0;
2435
2436 return !memcmp(prefix, option, plen);
2437}
2438
2439static inline int selinux_option(char *option, int len)
2440{
Eric Paris832cbd92008-04-01 13:24:09 -04002441 return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) ||
2442 match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) ||
2443 match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) ||
David P. Quigley11689d42009-01-16 09:22:03 -05002444 match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) ||
2445 match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446}
2447
2448static inline void take_option(char **to, char *from, int *first, int len)
2449{
2450 if (!*first) {
2451 **to = ',';
2452 *to += 1;
Cory Olmo3528a952006-09-29 01:58:44 -07002453 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 *first = 0;
2455 memcpy(*to, from, len);
2456 *to += len;
2457}
2458
Eric Paris828dfe12008-04-17 13:17:49 -04002459static inline void take_selinux_option(char **to, char *from, int *first,
2460 int len)
Cory Olmo3528a952006-09-29 01:58:44 -07002461{
2462 int current_size = 0;
2463
2464 if (!*first) {
2465 **to = '|';
2466 *to += 1;
Eric Paris828dfe12008-04-17 13:17:49 -04002467 } else
Cory Olmo3528a952006-09-29 01:58:44 -07002468 *first = 0;
2469
2470 while (current_size < len) {
2471 if (*from != '"') {
2472 **to = *from;
2473 *to += 1;
2474 }
2475 from += 1;
2476 current_size += 1;
2477 }
2478}
2479
Eric Parise0007522008-03-05 10:31:54 -05002480static int selinux_sb_copy_data(char *orig, char *copy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481{
2482 int fnosec, fsec, rc = 0;
2483 char *in_save, *in_curr, *in_end;
2484 char *sec_curr, *nosec_save, *nosec;
Cory Olmo3528a952006-09-29 01:58:44 -07002485 int open_quote = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486
2487 in_curr = orig;
2488 sec_curr = copy;
2489
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 nosec = (char *)get_zeroed_page(GFP_KERNEL);
2491 if (!nosec) {
2492 rc = -ENOMEM;
2493 goto out;
2494 }
2495
2496 nosec_save = nosec;
2497 fnosec = fsec = 1;
2498 in_save = in_end = orig;
2499
2500 do {
Cory Olmo3528a952006-09-29 01:58:44 -07002501 if (*in_end == '"')
2502 open_quote = !open_quote;
2503 if ((*in_end == ',' && open_quote == 0) ||
2504 *in_end == '\0') {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 int len = in_end - in_curr;
2506
2507 if (selinux_option(in_curr, len))
Cory Olmo3528a952006-09-29 01:58:44 -07002508 take_selinux_option(&sec_curr, in_curr, &fsec, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 else
2510 take_option(&nosec, in_curr, &fnosec, len);
2511
2512 in_curr = in_end + 1;
2513 }
2514 } while (*in_end++);
2515
Eric Paris6931dfc2005-06-30 02:58:51 -07002516 strcpy(in_save, nosec_save);
Gerald Schaeferda3caa22005-06-21 17:15:18 -07002517 free_page((unsigned long)nosec_save);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518out:
2519 return rc;
2520}
2521
James Morris12204e22008-12-19 10:44:42 +11002522static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523{
David Howells88e67f32008-11-14 10:39:21 +11002524 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 struct avc_audit_data ad;
2526 int rc;
2527
2528 rc = superblock_doinit(sb, data);
2529 if (rc)
2530 return rc;
2531
James Morris74192242008-12-19 11:41:10 +11002532 /* Allow all mounts performed by the kernel */
2533 if (flags & MS_KERNMOUNT)
2534 return 0;
2535
Eric Paris828dfe12008-04-17 13:17:49 -04002536 AVC_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002537 ad.u.fs.path.dentry = sb->s_root;
David Howells88e67f32008-11-14 10:39:21 +11002538 return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539}
2540
David Howells726c3342006-06-23 02:02:58 -07002541static int selinux_sb_statfs(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542{
David Howells88e67f32008-11-14 10:39:21 +11002543 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 struct avc_audit_data ad;
2545
Eric Paris828dfe12008-04-17 13:17:49 -04002546 AVC_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002547 ad.u.fs.path.dentry = dentry->d_sb->s_root;
David Howells88e67f32008-11-14 10:39:21 +11002548 return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549}
2550
Eric Paris828dfe12008-04-17 13:17:49 -04002551static int selinux_mount(char *dev_name,
Al Virob5266eb2008-03-22 17:48:24 -04002552 struct path *path,
Eric Paris828dfe12008-04-17 13:17:49 -04002553 char *type,
2554 unsigned long flags,
2555 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556{
David Howells88e67f32008-11-14 10:39:21 +11002557 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
2559 if (flags & MS_REMOUNT)
David Howells88e67f32008-11-14 10:39:21 +11002560 return superblock_has_perm(cred, path->mnt->mnt_sb,
Eric Paris828dfe12008-04-17 13:17:49 -04002561 FILESYSTEM__REMOUNT, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 else
David Howells88e67f32008-11-14 10:39:21 +11002563 return dentry_has_perm(cred, path->mnt, path->dentry,
Eric Paris828dfe12008-04-17 13:17:49 -04002564 FILE__MOUNTON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565}
2566
2567static int selinux_umount(struct vfsmount *mnt, int flags)
2568{
David Howells88e67f32008-11-14 10:39:21 +11002569 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570
David Howells88e67f32008-11-14 10:39:21 +11002571 return superblock_has_perm(cred, mnt->mnt_sb,
Eric Paris828dfe12008-04-17 13:17:49 -04002572 FILESYSTEM__UNMOUNT, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573}
2574
2575/* inode security operations */
2576
2577static int selinux_inode_alloc_security(struct inode *inode)
2578{
2579 return inode_alloc_security(inode);
2580}
2581
2582static void selinux_inode_free_security(struct inode *inode)
2583{
2584 inode_free_security(inode);
2585}
2586
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002587static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
2588 char **name, void **value,
2589 size_t *len)
2590{
David Howells275bb412008-11-14 10:39:19 +11002591 const struct cred *cred = current_cred();
2592 const struct task_security_struct *tsec = cred->security;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002593 struct inode_security_struct *dsec;
2594 struct superblock_security_struct *sbsec;
David Howells275bb412008-11-14 10:39:19 +11002595 u32 sid, newsid, clen;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002596 int rc;
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002597 char *namep = NULL, *context;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002598
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002599 dsec = dir->i_security;
2600 sbsec = dir->i_sb->s_security;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002601
David Howells275bb412008-11-14 10:39:19 +11002602 sid = tsec->sid;
2603 newsid = tsec->create_sid;
2604
David P. Quigleycd895962009-01-16 09:22:04 -05002605 if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
David Howells275bb412008-11-14 10:39:19 +11002606 rc = security_transition_sid(sid, dsec->sid,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002607 inode_mode_to_security_class(inode->i_mode),
2608 &newsid);
2609 if (rc) {
2610 printk(KERN_WARNING "%s: "
2611 "security_transition_sid failed, rc=%d (dev=%s "
2612 "ino=%ld)\n",
Harvey Harrisondd6f9532008-03-06 10:03:59 +11002613 __func__,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002614 -rc, inode->i_sb->s_id, inode->i_ino);
2615 return rc;
2616 }
2617 }
2618
Eric Paris296fddf2006-09-25 23:32:00 -07002619 /* Possibly defer initialization to selinux_complete_init. */
David P. Quigley0d90a7e2009-01-16 09:22:02 -05002620 if (sbsec->flags & SE_SBINITIALIZED) {
Eric Paris296fddf2006-09-25 23:32:00 -07002621 struct inode_security_struct *isec = inode->i_security;
2622 isec->sclass = inode_mode_to_security_class(inode->i_mode);
2623 isec->sid = newsid;
2624 isec->initialized = 1;
2625 }
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002626
David P. Quigleycd895962009-01-16 09:22:04 -05002627 if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
Stephen Smalley25a74f32005-11-08 21:34:33 -08002628 return -EOPNOTSUPP;
2629
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002630 if (name) {
Josef Bacika02fe132008-04-04 09:35:05 +11002631 namep = kstrdup(XATTR_SELINUX_SUFFIX, GFP_NOFS);
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002632 if (!namep)
2633 return -ENOMEM;
2634 *name = namep;
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002635 }
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002636
2637 if (value && len) {
Stephen Smalley12b29f32008-05-07 13:03:20 -04002638 rc = security_sid_to_context_force(newsid, &context, &clen);
Stephen Smalley570bc1c2005-09-09 13:01:43 -07002639 if (rc) {
2640 kfree(namep);
2641 return rc;
2642 }
2643 *value = context;
2644 *len = clen;
2645 }
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002646
Stephen Smalley5e41ff92005-09-09 13:01:35 -07002647 return 0;
2648}
2649
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650static int selinux_inode_create(struct inode *dir, struct dentry *dentry, int mask)
2651{
2652 return may_create(dir, dentry, SECCLASS_FILE);
2653}
2654
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2656{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 return may_link(dir, old_dentry, MAY_LINK);
2658}
2659
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry)
2661{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662 return may_link(dir, dentry, MAY_UNLINK);
2663}
2664
2665static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name)
2666{
2667 return may_create(dir, dentry, SECCLASS_LNK_FILE);
2668}
2669
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, int mask)
2671{
2672 return may_create(dir, dentry, SECCLASS_DIR);
2673}
2674
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry)
2676{
2677 return may_link(dir, dentry, MAY_RMDIR);
2678}
2679
2680static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2681{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 return may_create(dir, dentry, inode_mode_to_security_class(mode));
2683}
2684
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry,
Eric Paris828dfe12008-04-17 13:17:49 -04002686 struct inode *new_inode, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687{
2688 return may_rename(old_inode, old_dentry, new_inode, new_dentry);
2689}
2690
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691static int selinux_inode_readlink(struct dentry *dentry)
2692{
David Howells88e67f32008-11-14 10:39:21 +11002693 const struct cred *cred = current_cred();
2694
2695 return dentry_has_perm(cred, NULL, dentry, FILE__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696}
2697
2698static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *nameidata)
2699{
David Howells88e67f32008-11-14 10:39:21 +11002700 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701
David Howells88e67f32008-11-14 10:39:21 +11002702 return dentry_has_perm(cred, NULL, dentry, FILE__READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703}
2704
Al Virob77b0642008-07-17 09:37:02 -04002705static int selinux_inode_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706{
David Howells88e67f32008-11-14 10:39:21 +11002707 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708
2709 if (!mask) {
2710 /* No permission to check. Existence test. */
2711 return 0;
2712 }
2713
David Howells88e67f32008-11-14 10:39:21 +11002714 return inode_has_perm(cred, inode,
Eric Paris8b6a5a32008-10-29 17:06:46 -04002715 file_mask_to_av(inode->i_mode, mask), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716}
2717
2718static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
2719{
David Howells88e67f32008-11-14 10:39:21 +11002720 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721
2722 if (iattr->ia_valid & ATTR_FORCE)
2723 return 0;
2724
2725 if (iattr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID |
2726 ATTR_ATIME_SET | ATTR_MTIME_SET))
David Howells88e67f32008-11-14 10:39:21 +11002727 return dentry_has_perm(cred, NULL, dentry, FILE__SETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728
David Howells88e67f32008-11-14 10:39:21 +11002729 return dentry_has_perm(cred, NULL, dentry, FILE__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730}
2731
2732static int selinux_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
2733{
David Howells88e67f32008-11-14 10:39:21 +11002734 const struct cred *cred = current_cred();
2735
2736 return dentry_has_perm(cred, mnt, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737}
2738
David Howells8f0cfa52008-04-29 00:59:41 -07002739static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name)
Serge E. Hallynb5376772007-10-16 23:31:36 -07002740{
David Howells88e67f32008-11-14 10:39:21 +11002741 const struct cred *cred = current_cred();
2742
Serge E. Hallynb5376772007-10-16 23:31:36 -07002743 if (!strncmp(name, XATTR_SECURITY_PREFIX,
2744 sizeof XATTR_SECURITY_PREFIX - 1)) {
2745 if (!strcmp(name, XATTR_NAME_CAPS)) {
2746 if (!capable(CAP_SETFCAP))
2747 return -EPERM;
2748 } else if (!capable(CAP_SYS_ADMIN)) {
2749 /* A different attribute in the security namespace.
2750 Restrict to administrator. */
2751 return -EPERM;
2752 }
2753 }
2754
2755 /* Not an attribute we recognize, so just check the
2756 ordinary setattr permission. */
David Howells88e67f32008-11-14 10:39:21 +11002757 return dentry_has_perm(cred, NULL, dentry, FILE__SETATTR);
Serge E. Hallynb5376772007-10-16 23:31:36 -07002758}
2759
David Howells8f0cfa52008-04-29 00:59:41 -07002760static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
2761 const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 struct inode *inode = dentry->d_inode;
2764 struct inode_security_struct *isec = inode->i_security;
2765 struct superblock_security_struct *sbsec;
2766 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11002767 u32 newsid, sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 int rc = 0;
2769
Serge E. Hallynb5376772007-10-16 23:31:36 -07002770 if (strcmp(name, XATTR_NAME_SELINUX))
2771 return selinux_inode_setotherxattr(dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772
2773 sbsec = inode->i_sb->s_security;
David P. Quigleycd895962009-01-16 09:22:04 -05002774 if (!(sbsec->flags & SE_SBLABELSUPP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775 return -EOPNOTSUPP;
2776
Satyam Sharma3bd858a2007-07-17 15:00:08 +05302777 if (!is_owner_or_cap(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 return -EPERM;
2779
Eric Paris828dfe12008-04-17 13:17:49 -04002780 AVC_AUDIT_DATA_INIT(&ad, FS);
Jan Blunck44707fd2008-02-14 19:38:33 -08002781 ad.u.fs.path.dentry = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782
David Howells275bb412008-11-14 10:39:19 +11002783 rc = avc_has_perm(sid, isec->sid, isec->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 FILE__RELABELFROM, &ad);
2785 if (rc)
2786 return rc;
2787
2788 rc = security_context_to_sid(value, size, &newsid);
Stephen Smalley12b29f32008-05-07 13:03:20 -04002789 if (rc == -EINVAL) {
2790 if (!capable(CAP_MAC_ADMIN))
2791 return rc;
2792 rc = security_context_to_sid_force(value, size, &newsid);
2793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794 if (rc)
2795 return rc;
2796
David Howells275bb412008-11-14 10:39:19 +11002797 rc = avc_has_perm(sid, newsid, isec->sclass,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 FILE__RELABELTO, &ad);
2799 if (rc)
2800 return rc;
2801
David Howells275bb412008-11-14 10:39:19 +11002802 rc = security_validate_transition(isec->sid, newsid, sid,
Eric Paris828dfe12008-04-17 13:17:49 -04002803 isec->sclass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 if (rc)
2805 return rc;
2806
2807 return avc_has_perm(newsid,
2808 sbsec->sid,
2809 SECCLASS_FILESYSTEM,
2810 FILESYSTEM__ASSOCIATE,
2811 &ad);
2812}
2813
David Howells8f0cfa52008-04-29 00:59:41 -07002814static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
Eric Parisf5269712008-05-14 11:27:45 -04002815 const void *value, size_t size,
David Howells8f0cfa52008-04-29 00:59:41 -07002816 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817{
2818 struct inode *inode = dentry->d_inode;
2819 struct inode_security_struct *isec = inode->i_security;
2820 u32 newsid;
2821 int rc;
2822
2823 if (strcmp(name, XATTR_NAME_SELINUX)) {
2824 /* Not an attribute we recognize, so nothing to do. */
2825 return;
2826 }
2827
Stephen Smalley12b29f32008-05-07 13:03:20 -04002828 rc = security_context_to_sid_force(value, size, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 if (rc) {
Stephen Smalley12b29f32008-05-07 13:03:20 -04002830 printk(KERN_ERR "SELinux: unable to map context to SID"
2831 "for (%s, %lu), rc=%d\n",
2832 inode->i_sb->s_id, inode->i_ino, -rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 return;
2834 }
2835
2836 isec->sid = newsid;
2837 return;
2838}
2839
David Howells8f0cfa52008-04-29 00:59:41 -07002840static int selinux_inode_getxattr(struct dentry *dentry, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841{
David Howells88e67f32008-11-14 10:39:21 +11002842 const struct cred *cred = current_cred();
2843
2844 return dentry_has_perm(cred, NULL, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845}
2846
Eric Paris828dfe12008-04-17 13:17:49 -04002847static int selinux_inode_listxattr(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848{
David Howells88e67f32008-11-14 10:39:21 +11002849 const struct cred *cred = current_cred();
2850
2851 return dentry_has_perm(cred, NULL, dentry, FILE__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852}
2853
David Howells8f0cfa52008-04-29 00:59:41 -07002854static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855{
Serge E. Hallynb5376772007-10-16 23:31:36 -07002856 if (strcmp(name, XATTR_NAME_SELINUX))
2857 return selinux_inode_setotherxattr(dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858
2859 /* No one is allowed to remove a SELinux security label.
2860 You can change the label, but all data must be labeled. */
2861 return -EACCES;
2862}
2863
James Morrisd381d8a2005-10-30 14:59:22 -08002864/*
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002865 * Copy the inode security context value to the user.
James Morrisd381d8a2005-10-30 14:59:22 -08002866 *
2867 * Permission check is handled by selinux_inode_getxattr hook.
2868 */
David P. Quigley42492592008-02-04 22:29:39 -08002869static int selinux_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870{
David P. Quigley42492592008-02-04 22:29:39 -08002871 u32 size;
2872 int error;
2873 char *context = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 struct inode_security_struct *isec = inode->i_security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875
Dustin Kirkland8c8570f2005-11-03 17:15:16 +00002876 if (strcmp(name, XATTR_SELINUX_SUFFIX))
2877 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002879 /*
2880 * If the caller has CAP_MAC_ADMIN, then get the raw context
2881 * value even if it is not defined by current policy; otherwise,
2882 * use the in-core value under current policy.
2883 * Use the non-auditing forms of the permission checks since
2884 * getxattr may be called by unprivileged processes commonly
2885 * and lack of permission just means that we fall back to the
2886 * in-core context value, not a denial.
2887 */
David Howells3699c532009-01-06 22:27:01 +00002888 error = selinux_capable(current, current_cred(), CAP_MAC_ADMIN,
2889 SECURITY_CAP_NOAUDIT);
Stephen Smalleyabc69bb2008-05-21 14:16:12 -04002890 if (!error)
2891 error = security_sid_to_context_force(isec->sid, &context,
2892 &size);
2893 else
2894 error = security_sid_to_context(isec->sid, &context, &size);
David P. Quigley42492592008-02-04 22:29:39 -08002895 if (error)
2896 return error;
2897 error = size;
2898 if (alloc) {
2899 *buffer = context;
2900 goto out_nofree;
2901 }
2902 kfree(context);
2903out_nofree:
2904 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905}
2906
2907static int selinux_inode_setsecurity(struct inode *inode, const char *name,
Eric Paris828dfe12008-04-17 13:17:49 -04002908 const void *value, size_t size, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909{
2910 struct inode_security_struct *isec = inode->i_security;
2911 u32 newsid;
2912 int rc;
2913
2914 if (strcmp(name, XATTR_SELINUX_SUFFIX))
2915 return -EOPNOTSUPP;
2916
2917 if (!value || !size)
2918 return -EACCES;
2919
Eric Paris828dfe12008-04-17 13:17:49 -04002920 rc = security_context_to_sid((void *)value, size, &newsid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921 if (rc)
2922 return rc;
2923
2924 isec->sid = newsid;
2925 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. Darwish713a04a2008-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
2949 if (!mask) {
2950 /* No permission to check. Existence test. */
2951 return 0;
2952 }
2953
2954 /* file_mask_to_av won't add FILE__WRITE if MAY_APPEND is set */
2955 if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE))
2956 mask |= MAY_APPEND;
2957
Paul Moore389fb802009-03-27 17:10:34 -04002958 return file_has_perm(cred, file,
2959 file_mask_to_av(inode->i_mode, mask));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960}
2961
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09002962static int selinux_file_permission(struct file *file, int mask)
2963{
Paul Moore389fb802009-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
2968 return selinux_revalidate_file_permission(file, mask);
2969}
2970
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971static int selinux_file_alloc_security(struct file *file)
2972{
2973 return file_alloc_security(file);
2974}
2975
2976static void selinux_file_free_security(struct file *file)
2977{
2978 file_free_security(file);
2979}
2980
2981static int selinux_file_ioctl(struct file *file, unsigned int cmd,
2982 unsigned long arg)
2983{
David Howells88e67f32008-11-14 10:39:21 +11002984 const struct cred *cred = current_cred();
Stephen Smalley242631c2008-06-05 09:21:28 -04002985 u32 av = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986
Stephen Smalley242631c2008-06-05 09:21:28 -04002987 if (_IOC_DIR(cmd) & _IOC_WRITE)
2988 av |= FILE__WRITE;
2989 if (_IOC_DIR(cmd) & _IOC_READ)
2990 av |= FILE__READ;
2991 if (!av)
2992 av = FILE__IOCTL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993
David Howells88e67f32008-11-14 10:39:21 +11002994 return file_has_perm(cred, file, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995}
2996
2997static int file_map_prot_check(struct file *file, unsigned long prot, int shared)
2998{
David Howells88e67f32008-11-14 10:39:21 +11002999 const struct cred *cred = current_cred();
David Howellsd84f4f92008-11-14 10:39:23 +11003000 int rc = 0;
David Howells88e67f32008-11-14 10:39:21 +11003001
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002#ifndef CONFIG_PPC32
3003 if ((prot & PROT_EXEC) && (!file || (!shared && (prot & PROT_WRITE)))) {
3004 /*
3005 * We are making executable an anonymous mapping or a
3006 * private file mapping that will also be writable.
3007 * This has an additional check.
3008 */
David Howellsd84f4f92008-11-14 10:39:23 +11003009 rc = cred_has_perm(cred, cred, PROCESS__EXECMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010 if (rc)
David Howellsd84f4f92008-11-14 10:39:23 +11003011 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 }
3013#endif
3014
3015 if (file) {
3016 /* read access is always possible with a mapping */
3017 u32 av = FILE__READ;
3018
3019 /* write access only matters if the mapping is shared */
3020 if (shared && (prot & PROT_WRITE))
3021 av |= FILE__WRITE;
3022
3023 if (prot & PROT_EXEC)
3024 av |= FILE__EXECUTE;
3025
David Howells88e67f32008-11-14 10:39:21 +11003026 return file_has_perm(cred, file, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 }
David Howellsd84f4f92008-11-14 10:39:23 +11003028
3029error:
3030 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031}
3032
3033static int selinux_file_mmap(struct file *file, unsigned long reqprot,
Eric Parised032182007-06-28 15:55:21 -04003034 unsigned long prot, unsigned long flags,
3035 unsigned long addr, unsigned long addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036{
Eric Parised032182007-06-28 15:55:21 -04003037 int rc = 0;
David Howells275bb412008-11-14 10:39:19 +11003038 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039
Eric Parised032182007-06-28 15:55:21 -04003040 if (addr < mmap_min_addr)
3041 rc = avc_has_perm(sid, sid, SECCLASS_MEMPROTECT,
3042 MEMPROTECT__MMAP_ZERO, NULL);
3043 if (rc || addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 return rc;
3045
3046 if (selinux_checkreqprot)
3047 prot = reqprot;
3048
3049 return file_map_prot_check(file, prot,
3050 (flags & MAP_TYPE) == MAP_SHARED);
3051}
3052
3053static int selinux_file_mprotect(struct vm_area_struct *vma,
3054 unsigned long reqprot,
3055 unsigned long prot)
3056{
David Howells88e67f32008-11-14 10:39:21 +11003057 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058
3059 if (selinux_checkreqprot)
3060 prot = reqprot;
3061
3062#ifndef CONFIG_PPC32
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003063 if ((prot & PROT_EXEC) && !(vma->vm_flags & VM_EXEC)) {
James Morrisd541bbe2009-01-29 12:19:51 +11003064 int rc = 0;
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003065 if (vma->vm_start >= vma->vm_mm->start_brk &&
3066 vma->vm_end <= vma->vm_mm->brk) {
David Howellsd84f4f92008-11-14 10:39:23 +11003067 rc = cred_has_perm(cred, cred, PROCESS__EXECHEAP);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003068 } else if (!vma->vm_file &&
3069 vma->vm_start <= vma->vm_mm->start_stack &&
3070 vma->vm_end >= vma->vm_mm->start_stack) {
David Howells3b11a1d2008-11-14 10:39:26 +11003071 rc = current_has_perm(current, PROCESS__EXECSTACK);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003072 } else if (vma->vm_file && vma->anon_vma) {
3073 /*
3074 * We are making executable a file mapping that has
3075 * had some COW done. Since pages might have been
3076 * written, check ability to execute the possibly
3077 * modified content. This typically should only
3078 * occur for text relocations.
3079 */
David Howellsd84f4f92008-11-14 10:39:23 +11003080 rc = file_has_perm(cred, vma->vm_file, FILE__EXECMOD);
Stephen Smalleydb4c9642006-02-01 03:05:54 -08003081 }
Lorenzo Hernandez García-Hierro6b992192005-06-25 14:54:34 -07003082 if (rc)
3083 return rc;
3084 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085#endif
3086
3087 return file_map_prot_check(vma->vm_file, prot, vma->vm_flags&VM_SHARED);
3088}
3089
3090static int selinux_file_lock(struct file *file, unsigned int cmd)
3091{
David Howells88e67f32008-11-14 10:39:21 +11003092 const struct cred *cred = current_cred();
3093
3094 return file_has_perm(cred, file, FILE__LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095}
3096
3097static int selinux_file_fcntl(struct file *file, unsigned int cmd,
3098 unsigned long arg)
3099{
David Howells88e67f32008-11-14 10:39:21 +11003100 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003101 int err = 0;
3102
3103 switch (cmd) {
Eric Paris828dfe12008-04-17 13:17:49 -04003104 case F_SETFL:
3105 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3106 err = -EINVAL;
3107 break;
3108 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109
Eric Paris828dfe12008-04-17 13:17:49 -04003110 if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) {
David Howells88e67f32008-11-14 10:39:21 +11003111 err = file_has_perm(cred, file, FILE__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003113 }
3114 /* fall through */
3115 case F_SETOWN:
3116 case F_SETSIG:
3117 case F_GETFL:
3118 case F_GETOWN:
3119 case F_GETSIG:
3120 /* Just check FD__USE permission */
David Howells88e67f32008-11-14 10:39:21 +11003121 err = file_has_perm(cred, file, 0);
Eric Paris828dfe12008-04-17 13:17:49 -04003122 break;
3123 case F_GETLK:
3124 case F_SETLK:
3125 case F_SETLKW:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126#if BITS_PER_LONG == 32
Eric Paris828dfe12008-04-17 13:17:49 -04003127 case F_GETLK64:
3128 case F_SETLK64:
3129 case F_SETLKW64:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130#endif
Eric Paris828dfe12008-04-17 13:17:49 -04003131 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3132 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003133 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003134 }
David Howells88e67f32008-11-14 10:39:21 +11003135 err = file_has_perm(cred, file, FILE__LOCK);
Eric Paris828dfe12008-04-17 13:17:49 -04003136 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 }
3138
3139 return err;
3140}
3141
3142static int selinux_file_set_fowner(struct file *file)
3143{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144 struct file_security_struct *fsec;
3145
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146 fsec = file->f_security;
David Howells275bb412008-11-14 10:39:19 +11003147 fsec->fown_sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148
3149 return 0;
3150}
3151
3152static int selinux_file_send_sigiotask(struct task_struct *tsk,
3153 struct fown_struct *fown, int signum)
3154{
Eric Paris828dfe12008-04-17 13:17:49 -04003155 struct file *file;
David Howells275bb412008-11-14 10:39:19 +11003156 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 u32 perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158 struct file_security_struct *fsec;
3159
3160 /* struct fown_struct is never outside the context of a struct file */
Eric Paris828dfe12008-04-17 13:17:49 -04003161 file = container_of(fown, struct file, f_owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 fsec = file->f_security;
3164
3165 if (!signum)
3166 perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */
3167 else
3168 perm = signal_to_av(signum);
3169
David Howells275bb412008-11-14 10:39:19 +11003170 return avc_has_perm(fsec->fown_sid, sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 SECCLASS_PROCESS, perm, NULL);
3172}
3173
3174static int selinux_file_receive(struct file *file)
3175{
David Howells88e67f32008-11-14 10:39:21 +11003176 const struct cred *cred = current_cred();
3177
3178 return file_has_perm(cred, file, file_to_av(file));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179}
3180
David Howells745ca242008-11-14 10:39:22 +11003181static int selinux_dentry_open(struct file *file, const struct cred *cred)
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003182{
3183 struct file_security_struct *fsec;
3184 struct inode *inode;
3185 struct inode_security_struct *isec;
David Howellsd84f4f92008-11-14 10:39:23 +11003186
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003187 inode = file->f_path.dentry->d_inode;
3188 fsec = file->f_security;
3189 isec = inode->i_security;
3190 /*
3191 * Save inode label and policy sequence number
3192 * at open-time so that selinux_file_permission
3193 * can determine whether revalidation is necessary.
3194 * Task label is already saved in the file security
3195 * struct as its SID.
3196 */
3197 fsec->isid = isec->sid;
3198 fsec->pseqno = avc_policy_seqno();
3199 /*
3200 * Since the inode label or policy seqno may have changed
3201 * between the selinux_inode_permission check and the saving
3202 * of state above, recheck that access is still permitted.
3203 * Otherwise, access might never be revalidated against the
3204 * new inode label or new policy.
3205 * This check is not redundant - do not remove.
3206 */
David Howells88e67f32008-11-14 10:39:21 +11003207 return inode_has_perm(cred, inode, open_file_to_av(file), NULL);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09003208}
3209
Linus Torvalds1da177e2005-04-16 15:20:36 -07003210/* task security operations */
3211
3212static int selinux_task_create(unsigned long clone_flags)
3213{
David Howells3b11a1d2008-11-14 10:39:26 +11003214 return current_has_perm(current, PROCESS__FORK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215}
3216
David Howellsf1752ee2008-11-14 10:39:17 +11003217/*
3218 * detach and free the LSM part of a set of credentials
3219 */
3220static void selinux_cred_free(struct cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221{
David Howellsf1752ee2008-11-14 10:39:17 +11003222 struct task_security_struct *tsec = cred->security;
3223 cred->security = NULL;
3224 kfree(tsec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225}
3226
David Howellsd84f4f92008-11-14 10:39:23 +11003227/*
3228 * prepare a new set of credentials for modification
3229 */
3230static int selinux_cred_prepare(struct cred *new, const struct cred *old,
3231 gfp_t gfp)
3232{
3233 const struct task_security_struct *old_tsec;
3234 struct task_security_struct *tsec;
3235
3236 old_tsec = old->security;
3237
3238 tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp);
3239 if (!tsec)
3240 return -ENOMEM;
3241
3242 new->security = tsec;
3243 return 0;
3244}
3245
3246/*
David Howells3a3b7ce2008-11-14 10:39:28 +11003247 * set the security data for a kernel service
3248 * - all the creation contexts are set to unlabelled
3249 */
3250static int selinux_kernel_act_as(struct cred *new, u32 secid)
3251{
3252 struct task_security_struct *tsec = new->security;
3253 u32 sid = current_sid();
3254 int ret;
3255
3256 ret = avc_has_perm(sid, secid,
3257 SECCLASS_KERNEL_SERVICE,
3258 KERNEL_SERVICE__USE_AS_OVERRIDE,
3259 NULL);
3260 if (ret == 0) {
3261 tsec->sid = secid;
3262 tsec->create_sid = 0;
3263 tsec->keycreate_sid = 0;
3264 tsec->sockcreate_sid = 0;
3265 }
3266 return ret;
3267}
3268
3269/*
3270 * set the file creation context in a security record to the same as the
3271 * objective context of the specified inode
3272 */
3273static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
3274{
3275 struct inode_security_struct *isec = inode->i_security;
3276 struct task_security_struct *tsec = new->security;
3277 u32 sid = current_sid();
3278 int ret;
3279
3280 ret = avc_has_perm(sid, isec->sid,
3281 SECCLASS_KERNEL_SERVICE,
3282 KERNEL_SERVICE__CREATE_FILES_AS,
3283 NULL);
3284
3285 if (ret == 0)
3286 tsec->create_sid = isec->sid;
3287 return 0;
3288}
3289
Linus Torvalds1da177e2005-04-16 15:20:36 -07003290static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
3291{
David Howells3b11a1d2008-11-14 10:39:26 +11003292 return current_has_perm(p, PROCESS__SETPGID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003293}
3294
3295static int selinux_task_getpgid(struct task_struct *p)
3296{
David Howells3b11a1d2008-11-14 10:39:26 +11003297 return current_has_perm(p, PROCESS__GETPGID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298}
3299
3300static int selinux_task_getsid(struct task_struct *p)
3301{
David Howells3b11a1d2008-11-14 10:39:26 +11003302 return current_has_perm(p, PROCESS__GETSESSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303}
3304
David Quigleyf9008e42006-06-30 01:55:46 -07003305static void selinux_task_getsecid(struct task_struct *p, u32 *secid)
3306{
David Howells275bb412008-11-14 10:39:19 +11003307 *secid = task_sid(p);
David Quigleyf9008e42006-06-30 01:55:46 -07003308}
3309
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310static int selinux_task_setnice(struct task_struct *p, int nice)
3311{
3312 int rc;
3313
Eric Paris200ac532009-02-12 15:01:04 -05003314 rc = cap_task_setnice(p, nice);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 if (rc)
3316 return rc;
3317
David Howells3b11a1d2008-11-14 10:39:26 +11003318 return current_has_perm(p, PROCESS__SETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319}
3320
James Morris03e68062006-06-23 02:03:58 -07003321static int selinux_task_setioprio(struct task_struct *p, int ioprio)
3322{
Serge E. Hallynb5376772007-10-16 23:31:36 -07003323 int rc;
3324
Eric Paris200ac532009-02-12 15:01:04 -05003325 rc = cap_task_setioprio(p, ioprio);
Serge E. Hallynb5376772007-10-16 23:31:36 -07003326 if (rc)
3327 return rc;
3328
David Howells3b11a1d2008-11-14 10:39:26 +11003329 return current_has_perm(p, PROCESS__SETSCHED);
James Morris03e68062006-06-23 02:03:58 -07003330}
3331
David Quigleya1836a42006-06-30 01:55:49 -07003332static int selinux_task_getioprio(struct task_struct *p)
3333{
David Howells3b11a1d2008-11-14 10:39:26 +11003334 return current_has_perm(p, PROCESS__GETSCHED);
David Quigleya1836a42006-06-30 01:55:49 -07003335}
3336
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337static int selinux_task_setrlimit(unsigned int resource, struct rlimit *new_rlim)
3338{
3339 struct rlimit *old_rlim = current->signal->rlim + resource;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340
3341 /* Control the ability to change the hard limit (whether
3342 lowering or raising it), so that the hard limit can
3343 later be used as a safe reset point for the soft limit
David Howellsd84f4f92008-11-14 10:39:23 +11003344 upon context transitions. See selinux_bprm_committing_creds. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345 if (old_rlim->rlim_max != new_rlim->rlim_max)
David Howells3b11a1d2008-11-14 10:39:26 +11003346 return current_has_perm(current, PROCESS__SETRLIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003347
3348 return 0;
3349}
3350
3351static int selinux_task_setscheduler(struct task_struct *p, int policy, struct sched_param *lp)
3352{
Serge E. Hallynb5376772007-10-16 23:31:36 -07003353 int rc;
3354
Eric Paris200ac532009-02-12 15:01:04 -05003355 rc = cap_task_setscheduler(p, policy, lp);
Serge E. Hallynb5376772007-10-16 23:31:36 -07003356 if (rc)
3357 return rc;
3358
David Howells3b11a1d2008-11-14 10:39:26 +11003359 return current_has_perm(p, PROCESS__SETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003360}
3361
3362static int selinux_task_getscheduler(struct task_struct *p)
3363{
David Howells3b11a1d2008-11-14 10:39:26 +11003364 return current_has_perm(p, PROCESS__GETSCHED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365}
3366
David Quigley35601542006-06-23 02:04:01 -07003367static int selinux_task_movememory(struct task_struct *p)
3368{
David Howells3b11a1d2008-11-14 10:39:26 +11003369 return current_has_perm(p, PROCESS__SETSCHED);
David Quigley35601542006-06-23 02:04:01 -07003370}
3371
David Quigleyf9008e42006-06-30 01:55:46 -07003372static int selinux_task_kill(struct task_struct *p, struct siginfo *info,
3373 int sig, u32 secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374{
3375 u32 perm;
3376 int rc;
3377
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378 if (!sig)
3379 perm = PROCESS__SIGNULL; /* null signal; existence test */
3380 else
3381 perm = signal_to_av(sig);
David Quigleyf9008e42006-06-30 01:55:46 -07003382 if (secid)
David Howells275bb412008-11-14 10:39:19 +11003383 rc = avc_has_perm(secid, task_sid(p),
3384 SECCLASS_PROCESS, perm, NULL);
David Quigleyf9008e42006-06-30 01:55:46 -07003385 else
David Howells3b11a1d2008-11-14 10:39:26 +11003386 rc = current_has_perm(p, perm);
David Quigleyf9008e42006-06-30 01:55:46 -07003387 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388}
3389
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390static int selinux_task_wait(struct task_struct *p)
3391{
Eric Paris8a535142007-10-22 16:10:31 -04003392 return task_has_perm(p, current, PROCESS__SIGCHLD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393}
3394
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395static void selinux_task_to_inode(struct task_struct *p,
3396 struct inode *inode)
3397{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 struct inode_security_struct *isec = inode->i_security;
David Howells275bb412008-11-14 10:39:19 +11003399 u32 sid = task_sid(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400
David Howells275bb412008-11-14 10:39:19 +11003401 isec->sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 isec->initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403}
3404
Linus Torvalds1da177e2005-04-16 15:20:36 -07003405/* Returns error only if unable to parse addresses */
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003406static int selinux_parse_skb_ipv4(struct sk_buff *skb,
3407 struct avc_audit_data *ad, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408{
3409 int offset, ihlen, ret = -EINVAL;
3410 struct iphdr _iph, *ih;
3411
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03003412 offset = skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413 ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
3414 if (ih == NULL)
3415 goto out;
3416
3417 ihlen = ih->ihl * 4;
3418 if (ihlen < sizeof(_iph))
3419 goto out;
3420
3421 ad->u.net.v4info.saddr = ih->saddr;
3422 ad->u.net.v4info.daddr = ih->daddr;
3423 ret = 0;
3424
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003425 if (proto)
3426 *proto = ih->protocol;
3427
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428 switch (ih->protocol) {
Eric Paris828dfe12008-04-17 13:17:49 -04003429 case IPPROTO_TCP: {
3430 struct tcphdr _tcph, *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431
Eric Paris828dfe12008-04-17 13:17:49 -04003432 if (ntohs(ih->frag_off) & IP_OFFSET)
3433 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434
3435 offset += ihlen;
3436 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3437 if (th == NULL)
3438 break;
3439
3440 ad->u.net.sport = th->source;
3441 ad->u.net.dport = th->dest;
3442 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444
Eric Paris828dfe12008-04-17 13:17:49 -04003445 case IPPROTO_UDP: {
3446 struct udphdr _udph, *uh;
3447
3448 if (ntohs(ih->frag_off) & IP_OFFSET)
3449 break;
3450
3451 offset += ihlen;
3452 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3453 if (uh == NULL)
3454 break;
3455
3456 ad->u.net.sport = uh->source;
3457 ad->u.net.dport = uh->dest;
3458 break;
3459 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460
James Morris2ee92d42006-11-13 16:09:01 -08003461 case IPPROTO_DCCP: {
3462 struct dccp_hdr _dccph, *dh;
3463
3464 if (ntohs(ih->frag_off) & IP_OFFSET)
3465 break;
3466
3467 offset += ihlen;
3468 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3469 if (dh == NULL)
3470 break;
3471
3472 ad->u.net.sport = dh->dccph_sport;
3473 ad->u.net.dport = dh->dccph_dport;
3474 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003475 }
James Morris2ee92d42006-11-13 16:09:01 -08003476
Eric Paris828dfe12008-04-17 13:17:49 -04003477 default:
3478 break;
3479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480out:
3481 return ret;
3482}
3483
3484#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3485
3486/* Returns error only if unable to parse addresses */
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003487static int selinux_parse_skb_ipv6(struct sk_buff *skb,
3488 struct avc_audit_data *ad, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489{
3490 u8 nexthdr;
3491 int ret = -EINVAL, offset;
3492 struct ipv6hdr _ipv6h, *ip6;
3493
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03003494 offset = skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3496 if (ip6 == NULL)
3497 goto out;
3498
3499 ipv6_addr_copy(&ad->u.net.v6info.saddr, &ip6->saddr);
3500 ipv6_addr_copy(&ad->u.net.v6info.daddr, &ip6->daddr);
3501 ret = 0;
3502
3503 nexthdr = ip6->nexthdr;
3504 offset += sizeof(_ipv6h);
Herbert Xu0d3d0772005-04-24 20:16:19 -07003505 offset = ipv6_skip_exthdr(skb, offset, &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 if (offset < 0)
3507 goto out;
3508
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003509 if (proto)
3510 *proto = nexthdr;
3511
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 switch (nexthdr) {
3513 case IPPROTO_TCP: {
Eric Paris828dfe12008-04-17 13:17:49 -04003514 struct tcphdr _tcph, *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515
3516 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3517 if (th == NULL)
3518 break;
3519
3520 ad->u.net.sport = th->source;
3521 ad->u.net.dport = th->dest;
3522 break;
3523 }
3524
3525 case IPPROTO_UDP: {
3526 struct udphdr _udph, *uh;
3527
3528 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3529 if (uh == NULL)
3530 break;
3531
3532 ad->u.net.sport = uh->source;
3533 ad->u.net.dport = uh->dest;
3534 break;
3535 }
3536
James Morris2ee92d42006-11-13 16:09:01 -08003537 case IPPROTO_DCCP: {
3538 struct dccp_hdr _dccph, *dh;
3539
3540 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3541 if (dh == NULL)
3542 break;
3543
3544 ad->u.net.sport = dh->dccph_sport;
3545 ad->u.net.dport = dh->dccph_dport;
3546 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003547 }
James Morris2ee92d42006-11-13 16:09:01 -08003548
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 /* includes fragments */
3550 default:
3551 break;
3552 }
3553out:
3554 return ret;
3555}
3556
3557#endif /* IPV6 */
3558
3559static int selinux_parse_skb(struct sk_buff *skb, struct avc_audit_data *ad,
David Howellscf9481e2008-07-27 21:31:07 +10003560 char **_addrp, int src, u8 *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561{
David Howellscf9481e2008-07-27 21:31:07 +10003562 char *addrp;
3563 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564
3565 switch (ad->u.net.family) {
3566 case PF_INET:
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003567 ret = selinux_parse_skb_ipv4(skb, ad, proto);
David Howellscf9481e2008-07-27 21:31:07 +10003568 if (ret)
3569 goto parse_error;
3570 addrp = (char *)(src ? &ad->u.net.v4info.saddr :
3571 &ad->u.net.v4info.daddr);
3572 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573
3574#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3575 case PF_INET6:
Venkat Yekkirala67f83cb2006-11-08 17:04:26 -06003576 ret = selinux_parse_skb_ipv6(skb, ad, proto);
David Howellscf9481e2008-07-27 21:31:07 +10003577 if (ret)
3578 goto parse_error;
3579 addrp = (char *)(src ? &ad->u.net.v6info.saddr :
3580 &ad->u.net.v6info.daddr);
3581 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582#endif /* IPV6 */
3583 default:
David Howellscf9481e2008-07-27 21:31:07 +10003584 addrp = NULL;
3585 goto okay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586 }
3587
David Howellscf9481e2008-07-27 21:31:07 +10003588parse_error:
3589 printk(KERN_WARNING
3590 "SELinux: failure in selinux_parse_skb(),"
3591 " unable to parse packet\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 return ret;
David Howellscf9481e2008-07-27 21:31:07 +10003593
3594okay:
3595 if (_addrp)
3596 *_addrp = addrp;
3597 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003598}
3599
Paul Moore4f6a9932007-03-01 14:35:22 -05003600/**
Paul Moore220deb92008-01-29 08:38:23 -05003601 * selinux_skb_peerlbl_sid - Determine the peer label of a packet
Paul Moore4f6a9932007-03-01 14:35:22 -05003602 * @skb: the packet
Paul Moore75e22912008-01-29 08:38:04 -05003603 * @family: protocol family
Paul Moore220deb92008-01-29 08:38:23 -05003604 * @sid: the packet's peer label SID
Paul Moore4f6a9932007-03-01 14:35:22 -05003605 *
3606 * Description:
Paul Moore220deb92008-01-29 08:38:23 -05003607 * Check the various different forms of network peer labeling and determine
3608 * the peer label/SID for the packet; most of the magic actually occurs in
3609 * the security server function security_net_peersid_cmp(). The function
3610 * returns zero if the value in @sid is valid (although it may be SECSID_NULL)
3611 * or -EACCES if @sid is invalid due to inconsistencies with the different
3612 * peer labels.
Paul Moore4f6a9932007-03-01 14:35:22 -05003613 *
3614 */
Paul Moore220deb92008-01-29 08:38:23 -05003615static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid)
Paul Moore4f6a9932007-03-01 14:35:22 -05003616{
Paul Moore71f1cb02008-01-29 08:51:16 -05003617 int err;
Paul Moore4f6a9932007-03-01 14:35:22 -05003618 u32 xfrm_sid;
3619 u32 nlbl_sid;
Paul Moore220deb92008-01-29 08:38:23 -05003620 u32 nlbl_type;
Paul Moore4f6a9932007-03-01 14:35:22 -05003621
3622 selinux_skb_xfrm_sid(skb, &xfrm_sid);
Paul Moore5dbe1eb2008-01-29 08:44:18 -05003623 selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
Paul Moore220deb92008-01-29 08:38:23 -05003624
Paul Moore71f1cb02008-01-29 08:51:16 -05003625 err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid);
3626 if (unlikely(err)) {
3627 printk(KERN_WARNING
3628 "SELinux: failure in selinux_skb_peerlbl_sid(),"
3629 " unable to determine packet's peer label\n");
Paul Moore220deb92008-01-29 08:38:23 -05003630 return -EACCES;
Paul Moore71f1cb02008-01-29 08:51:16 -05003631 }
Paul Moore220deb92008-01-29 08:38:23 -05003632
3633 return 0;
Paul Moore4f6a9932007-03-01 14:35:22 -05003634}
3635
Linus Torvalds1da177e2005-04-16 15:20:36 -07003636/* socket security operations */
3637static int socket_has_perm(struct task_struct *task, struct socket *sock,
3638 u32 perms)
3639{
3640 struct inode_security_struct *isec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11003642 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643 int err = 0;
3644
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645 isec = SOCK_INODE(sock)->i_security;
3646
3647 if (isec->sid == SECINITSID_KERNEL)
3648 goto out;
David Howells275bb412008-11-14 10:39:19 +11003649 sid = task_sid(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650
Eric Paris828dfe12008-04-17 13:17:49 -04003651 AVC_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003652 ad.u.net.sk = sock->sk;
David Howells275bb412008-11-14 10:39:19 +11003653 err = avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654
3655out:
3656 return err;
3657}
3658
3659static int selinux_socket_create(int family, int type,
3660 int protocol, int kern)
3661{
David Howells275bb412008-11-14 10:39:19 +11003662 const struct cred *cred = current_cred();
3663 const struct task_security_struct *tsec = cred->security;
3664 u32 sid, newsid;
3665 u16 secclass;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003667
3668 if (kern)
3669 goto out;
3670
David Howells275bb412008-11-14 10:39:19 +11003671 sid = tsec->sid;
3672 newsid = tsec->sockcreate_sid ?: sid;
3673
3674 secclass = socket_type_to_security_class(family, type, protocol);
3675 err = avc_has_perm(sid, newsid, secclass, SOCKET__CREATE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003676
3677out:
3678 return err;
3679}
3680
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07003681static int selinux_socket_post_create(struct socket *sock, int family,
3682 int type, int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003683{
David Howells275bb412008-11-14 10:39:19 +11003684 const struct cred *cred = current_cred();
3685 const struct task_security_struct *tsec = cred->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 struct inode_security_struct *isec;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003687 struct sk_security_struct *sksec;
David Howells275bb412008-11-14 10:39:19 +11003688 u32 sid, newsid;
3689 int err = 0;
3690
3691 sid = tsec->sid;
3692 newsid = tsec->sockcreate_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003693
3694 isec = SOCK_INODE(sock)->i_security;
3695
David Howells275bb412008-11-14 10:39:19 +11003696 if (kern)
3697 isec->sid = SECINITSID_KERNEL;
3698 else if (newsid)
3699 isec->sid = newsid;
3700 else
3701 isec->sid = sid;
3702
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703 isec->sclass = socket_type_to_security_class(family, type, protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003704 isec->initialized = 1;
3705
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003706 if (sock->sk) {
3707 sksec = sock->sk->sk_security;
3708 sksec->sid = isec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05003709 sksec->sclass = isec->sclass;
Paul Moore389fb802009-03-27 17:10:34 -04003710 err = selinux_netlbl_socket_post_create(sock->sk, family);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07003711 }
3712
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07003713 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003714}
3715
3716/* Range of port numbers used to automatically bind.
3717 Need to determine whether we should perform a name_bind
3718 permission check between the socket and the port number. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003719
3720static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
3721{
3722 u16 family;
3723 int err;
3724
3725 err = socket_has_perm(current, sock, SOCKET__BIND);
3726 if (err)
3727 goto out;
3728
3729 /*
3730 * If PF_INET or PF_INET6, check name_bind permission for the port.
James Morris13402582005-09-30 14:24:34 -04003731 * Multiple address binding for SCTP is not supported yet: we just
3732 * check the first address now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003733 */
3734 family = sock->sk->sk_family;
3735 if (family == PF_INET || family == PF_INET6) {
3736 char *addrp;
3737 struct inode_security_struct *isec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738 struct avc_audit_data ad;
3739 struct sockaddr_in *addr4 = NULL;
3740 struct sockaddr_in6 *addr6 = NULL;
3741 unsigned short snum;
3742 struct sock *sk = sock->sk;
James Morrise399f982008-06-12 01:39:58 +10003743 u32 sid, node_perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003744
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745 isec = SOCK_INODE(sock)->i_security;
3746
3747 if (family == PF_INET) {
3748 addr4 = (struct sockaddr_in *)address;
3749 snum = ntohs(addr4->sin_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750 addrp = (char *)&addr4->sin_addr.s_addr;
3751 } else {
3752 addr6 = (struct sockaddr_in6 *)address;
3753 snum = ntohs(addr6->sin6_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003754 addrp = (char *)&addr6->sin6_addr.s6_addr;
3755 }
3756
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003757 if (snum) {
3758 int low, high;
3759
3760 inet_get_local_port_range(&low, &high);
3761
3762 if (snum < max(PROT_SOCK, low) || snum > high) {
Paul Moore3e112172008-04-10 10:48:14 -04003763 err = sel_netport_sid(sk->sk_protocol,
3764 snum, &sid);
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003765 if (err)
3766 goto out;
Eric Paris828dfe12008-04-17 13:17:49 -04003767 AVC_AUDIT_DATA_INIT(&ad, NET);
Stephen Hemminger227b60f2007-10-10 17:30:46 -07003768 ad.u.net.sport = htons(snum);
3769 ad.u.net.family = family;
3770 err = avc_has_perm(isec->sid, sid,
3771 isec->sclass,
3772 SOCKET__NAME_BIND, &ad);
3773 if (err)
3774 goto out;
3775 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 }
Eric Paris828dfe12008-04-17 13:17:49 -04003777
3778 switch (isec->sclass) {
James Morris13402582005-09-30 14:24:34 -04003779 case SECCLASS_TCP_SOCKET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003780 node_perm = TCP_SOCKET__NODE_BIND;
3781 break;
Eric Paris828dfe12008-04-17 13:17:49 -04003782
James Morris13402582005-09-30 14:24:34 -04003783 case SECCLASS_UDP_SOCKET:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784 node_perm = UDP_SOCKET__NODE_BIND;
3785 break;
James Morris2ee92d42006-11-13 16:09:01 -08003786
3787 case SECCLASS_DCCP_SOCKET:
3788 node_perm = DCCP_SOCKET__NODE_BIND;
3789 break;
3790
Linus Torvalds1da177e2005-04-16 15:20:36 -07003791 default:
3792 node_perm = RAWIP_SOCKET__NODE_BIND;
3793 break;
3794 }
Eric Paris828dfe12008-04-17 13:17:49 -04003795
Paul Moore224dfbd2008-01-29 08:38:13 -05003796 err = sel_netnode_sid(addrp, family, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003797 if (err)
3798 goto out;
Eric Paris828dfe12008-04-17 13:17:49 -04003799
3800 AVC_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801 ad.u.net.sport = htons(snum);
3802 ad.u.net.family = family;
3803
3804 if (family == PF_INET)
3805 ad.u.net.v4info.saddr = addr4->sin_addr.s_addr;
3806 else
3807 ipv6_addr_copy(&ad.u.net.v6info.saddr, &addr6->sin6_addr);
3808
3809 err = avc_has_perm(isec->sid, sid,
Eric Paris828dfe12008-04-17 13:17:49 -04003810 isec->sclass, node_perm, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811 if (err)
3812 goto out;
3813 }
3814out:
3815 return err;
3816}
3817
3818static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
3819{
Paul Moore014ab192008-10-10 10:16:33 -04003820 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003821 struct inode_security_struct *isec;
3822 int err;
3823
3824 err = socket_has_perm(current, sock, SOCKET__CONNECT);
3825 if (err)
3826 return err;
3827
3828 /*
James Morris2ee92d42006-11-13 16:09:01 -08003829 * If a TCP or DCCP socket, check name_connect permission for the port.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003830 */
3831 isec = SOCK_INODE(sock)->i_security;
James Morris2ee92d42006-11-13 16:09:01 -08003832 if (isec->sclass == SECCLASS_TCP_SOCKET ||
3833 isec->sclass == SECCLASS_DCCP_SOCKET) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003834 struct avc_audit_data ad;
3835 struct sockaddr_in *addr4 = NULL;
3836 struct sockaddr_in6 *addr6 = NULL;
3837 unsigned short snum;
James Morris2ee92d42006-11-13 16:09:01 -08003838 u32 sid, perm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839
3840 if (sk->sk_family == PF_INET) {
3841 addr4 = (struct sockaddr_in *)address;
Stephen Smalley911656f2005-07-28 21:16:21 -07003842 if (addrlen < sizeof(struct sockaddr_in))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003843 return -EINVAL;
3844 snum = ntohs(addr4->sin_port);
3845 } else {
3846 addr6 = (struct sockaddr_in6 *)address;
Stephen Smalley911656f2005-07-28 21:16:21 -07003847 if (addrlen < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848 return -EINVAL;
3849 snum = ntohs(addr6->sin6_port);
3850 }
3851
Paul Moore3e112172008-04-10 10:48:14 -04003852 err = sel_netport_sid(sk->sk_protocol, snum, &sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853 if (err)
3854 goto out;
3855
James Morris2ee92d42006-11-13 16:09:01 -08003856 perm = (isec->sclass == SECCLASS_TCP_SOCKET) ?
3857 TCP_SOCKET__NAME_CONNECT : DCCP_SOCKET__NAME_CONNECT;
3858
Eric Paris828dfe12008-04-17 13:17:49 -04003859 AVC_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 ad.u.net.dport = htons(snum);
3861 ad.u.net.family = sk->sk_family;
James Morris2ee92d42006-11-13 16:09:01 -08003862 err = avc_has_perm(isec->sid, sid, isec->sclass, perm, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003863 if (err)
3864 goto out;
3865 }
3866
Paul Moore014ab192008-10-10 10:16:33 -04003867 err = selinux_netlbl_socket_connect(sk, address);
3868
Linus Torvalds1da177e2005-04-16 15:20:36 -07003869out:
3870 return err;
3871}
3872
3873static int selinux_socket_listen(struct socket *sock, int backlog)
3874{
3875 return socket_has_perm(current, sock, SOCKET__LISTEN);
3876}
3877
3878static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
3879{
3880 int err;
3881 struct inode_security_struct *isec;
3882 struct inode_security_struct *newisec;
3883
3884 err = socket_has_perm(current, sock, SOCKET__ACCEPT);
3885 if (err)
3886 return err;
3887
3888 newisec = SOCK_INODE(newsock)->i_security;
3889
3890 isec = SOCK_INODE(sock)->i_security;
3891 newisec->sclass = isec->sclass;
3892 newisec->sid = isec->sid;
3893 newisec->initialized = 1;
3894
3895 return 0;
3896}
3897
3898static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
Eric Paris828dfe12008-04-17 13:17:49 -04003899 int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003900{
Paul Moore389fb802009-03-27 17:10:34 -04003901 return socket_has_perm(current, sock, SOCKET__WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902}
3903
3904static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
3905 int size, int flags)
3906{
3907 return socket_has_perm(current, sock, SOCKET__READ);
3908}
3909
3910static int selinux_socket_getsockname(struct socket *sock)
3911{
3912 return socket_has_perm(current, sock, SOCKET__GETATTR);
3913}
3914
3915static int selinux_socket_getpeername(struct socket *sock)
3916{
3917 return socket_has_perm(current, sock, SOCKET__GETATTR);
3918}
3919
Eric Paris828dfe12008-04-17 13:17:49 -04003920static int selinux_socket_setsockopt(struct socket *sock, int level, int optname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003921{
Paul Mooref8687af2006-10-30 15:22:15 -08003922 int err;
3923
3924 err = socket_has_perm(current, sock, SOCKET__SETOPT);
3925 if (err)
3926 return err;
3927
3928 return selinux_netlbl_socket_setsockopt(sock, level, optname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003929}
3930
3931static int selinux_socket_getsockopt(struct socket *sock, int level,
3932 int optname)
3933{
3934 return socket_has_perm(current, sock, SOCKET__GETOPT);
3935}
3936
3937static int selinux_socket_shutdown(struct socket *sock, int how)
3938{
3939 return socket_has_perm(current, sock, SOCKET__SHUTDOWN);
3940}
3941
3942static int selinux_socket_unix_stream_connect(struct socket *sock,
3943 struct socket *other,
3944 struct sock *newsk)
3945{
3946 struct sk_security_struct *ssec;
3947 struct inode_security_struct *isec;
3948 struct inode_security_struct *other_isec;
3949 struct avc_audit_data ad;
3950 int err;
3951
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952 isec = SOCK_INODE(sock)->i_security;
3953 other_isec = SOCK_INODE(other)->i_security;
3954
Eric Paris828dfe12008-04-17 13:17:49 -04003955 AVC_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003956 ad.u.net.sk = other->sk;
3957
3958 err = avc_has_perm(isec->sid, other_isec->sid,
3959 isec->sclass,
3960 UNIX_STREAM_SOCKET__CONNECTTO, &ad);
3961 if (err)
3962 return err;
3963
3964 /* connecting socket */
3965 ssec = sock->sk->sk_security;
3966 ssec->peer_sid = other_isec->sid;
Eric Paris828dfe12008-04-17 13:17:49 -04003967
Linus Torvalds1da177e2005-04-16 15:20:36 -07003968 /* server child socket */
3969 ssec = newsk->sk_security;
3970 ssec->peer_sid = isec->sid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07003971 err = security_sid_mls_copy(other_isec->sid, ssec->peer_sid, &ssec->sid);
3972
3973 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003974}
3975
3976static int selinux_socket_unix_may_send(struct socket *sock,
3977 struct socket *other)
3978{
3979 struct inode_security_struct *isec;
3980 struct inode_security_struct *other_isec;
3981 struct avc_audit_data ad;
3982 int err;
3983
3984 isec = SOCK_INODE(sock)->i_security;
3985 other_isec = SOCK_INODE(other)->i_security;
3986
Eric Paris828dfe12008-04-17 13:17:49 -04003987 AVC_AUDIT_DATA_INIT(&ad, NET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003988 ad.u.net.sk = other->sk;
3989
3990 err = avc_has_perm(isec->sid, other_isec->sid,
3991 isec->sclass, SOCKET__SENDTO, &ad);
3992 if (err)
3993 return err;
3994
3995 return 0;
3996}
3997
Paul Mooreeffad8d2008-01-29 08:49:27 -05003998static int selinux_inet_sys_rcv_skb(int ifindex, char *addrp, u16 family,
3999 u32 peer_sid,
4000 struct avc_audit_data *ad)
4001{
4002 int err;
4003 u32 if_sid;
4004 u32 node_sid;
4005
4006 err = sel_netif_sid(ifindex, &if_sid);
4007 if (err)
4008 return err;
4009 err = avc_has_perm(peer_sid, if_sid,
4010 SECCLASS_NETIF, NETIF__INGRESS, ad);
4011 if (err)
4012 return err;
4013
4014 err = sel_netnode_sid(addrp, family, &node_sid);
4015 if (err)
4016 return err;
4017 return avc_has_perm(peer_sid, node_sid,
4018 SECCLASS_NODE, NODE__RECVFROM, ad);
4019}
4020
Paul Moore220deb92008-01-29 08:38:23 -05004021static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
Paul Moored8395c82008-10-10 10:16:30 -04004022 u16 family)
Paul Moore220deb92008-01-29 08:38:23 -05004023{
Paul Moore277d3422008-12-31 12:54:11 -05004024 int err = 0;
Paul Moore220deb92008-01-29 08:38:23 -05004025 struct sk_security_struct *sksec = sk->sk_security;
4026 u32 peer_sid;
4027 u32 sk_sid = sksec->sid;
Paul Moored8395c82008-10-10 10:16:30 -04004028 struct avc_audit_data ad;
4029 char *addrp;
4030
4031 AVC_AUDIT_DATA_INIT(&ad, NET);
4032 ad.u.net.netif = skb->iif;
4033 ad.u.net.family = family;
4034 err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4035 if (err)
4036 return err;
Paul Moore220deb92008-01-29 08:38:23 -05004037
Paul Moore58bfbb52009-03-27 17:10:41 -04004038 if (selinux_secmark_enabled()) {
Paul Moore220deb92008-01-29 08:38:23 -05004039 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
Paul Moored8395c82008-10-10 10:16:30 -04004040 PACKET__RECV, &ad);
Paul Moore58bfbb52009-03-27 17:10:41 -04004041 if (err)
4042 return err;
4043 }
Paul Moore220deb92008-01-29 08:38:23 -05004044
4045 if (selinux_policycap_netpeer) {
4046 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004047 if (err)
Paul Moore220deb92008-01-29 08:38:23 -05004048 return err;
4049 err = avc_has_perm(sk_sid, peer_sid,
Paul Moored8395c82008-10-10 10:16:30 -04004050 SECCLASS_PEER, PEER__RECV, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004051 if (err)
4052 selinux_netlbl_err(skb, err, 0);
Paul Moore220deb92008-01-29 08:38:23 -05004053 } else {
Paul Moored8395c82008-10-10 10:16:30 -04004054 err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad);
Paul Moore220deb92008-01-29 08:38:23 -05004055 if (err)
4056 return err;
Paul Moored8395c82008-10-10 10:16:30 -04004057 err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004058 }
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004059
James Morris4e5ab4c2006-06-09 00:33:33 -07004060 return err;
4061}
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004062
James Morris4e5ab4c2006-06-09 00:33:33 -07004063static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
4064{
Paul Moore220deb92008-01-29 08:38:23 -05004065 int err;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004066 struct sk_security_struct *sksec = sk->sk_security;
Paul Moore220deb92008-01-29 08:38:23 -05004067 u16 family = sk->sk_family;
4068 u32 sk_sid = sksec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05004069 struct avc_audit_data ad;
4070 char *addrp;
Paul Moored8395c82008-10-10 10:16:30 -04004071 u8 secmark_active;
4072 u8 peerlbl_active;
James Morris4e5ab4c2006-06-09 00:33:33 -07004073
James Morris4e5ab4c2006-06-09 00:33:33 -07004074 if (family != PF_INET && family != PF_INET6)
Paul Moore220deb92008-01-29 08:38:23 -05004075 return 0;
James Morris4e5ab4c2006-06-09 00:33:33 -07004076
4077 /* Handle mapped IPv4 packets arriving via IPv6 sockets */
Al Viro87fcd702006-12-04 22:00:55 +00004078 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
James Morris4e5ab4c2006-06-09 00:33:33 -07004079 family = PF_INET;
4080
Paul Moored8395c82008-10-10 10:16:30 -04004081 /* If any sort of compatibility mode is enabled then handoff processing
4082 * to the selinux_sock_rcv_skb_compat() function to deal with the
4083 * special handling. We do this in an attempt to keep this function
4084 * as fast and as clean as possible. */
Paul Moore58bfbb52009-03-27 17:10:41 -04004085 if (!selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004086 return selinux_sock_rcv_skb_compat(sk, skb, family);
4087
4088 secmark_active = selinux_secmark_enabled();
4089 peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4090 if (!secmark_active && !peerlbl_active)
4091 return 0;
4092
James Morris4e5ab4c2006-06-09 00:33:33 -07004093 AVC_AUDIT_DATA_INIT(&ad, NET);
Paul Mooreda5645a2008-01-29 08:38:10 -05004094 ad.u.net.netif = skb->iif;
James Morris4e5ab4c2006-06-09 00:33:33 -07004095 ad.u.net.family = family;
Paul Moore224dfbd2008-01-29 08:38:13 -05004096 err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
James Morris4e5ab4c2006-06-09 00:33:33 -07004097 if (err)
Paul Moore220deb92008-01-29 08:38:23 -05004098 return err;
James Morris4e5ab4c2006-06-09 00:33:33 -07004099
Paul Moored8395c82008-10-10 10:16:30 -04004100 if (peerlbl_active) {
Paul Moored621d352008-01-29 08:43:36 -05004101 u32 peer_sid;
4102
4103 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
4104 if (err)
4105 return err;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004106 err = selinux_inet_sys_rcv_skb(skb->iif, addrp, family,
4107 peer_sid, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004108 if (err) {
4109 selinux_netlbl_err(skb, err, 0);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004110 return err;
Paul Mooredfaebe92008-10-10 10:16:31 -04004111 }
Paul Moored621d352008-01-29 08:43:36 -05004112 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
4113 PEER__RECV, &ad);
Paul Mooredfaebe92008-10-10 10:16:31 -04004114 if (err)
4115 selinux_netlbl_err(skb, err, 0);
Paul Moored621d352008-01-29 08:43:36 -05004116 }
4117
Paul Moored8395c82008-10-10 10:16:30 -04004118 if (secmark_active) {
Paul Mooreeffad8d2008-01-29 08:49:27 -05004119 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4120 PACKET__RECV, &ad);
4121 if (err)
4122 return err;
4123 }
4124
Paul Moored621d352008-01-29 08:43:36 -05004125 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004126}
4127
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004128static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *optval,
4129 int __user *optlen, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004130{
4131 int err = 0;
4132 char *scontext;
4133 u32 scontext_len;
4134 struct sk_security_struct *ssec;
4135 struct inode_security_struct *isec;
Paul Moore3de4bab2006-11-17 17:38:54 -05004136 u32 peer_sid = SECSID_NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004137
4138 isec = SOCK_INODE(sock)->i_security;
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004139
Paul Moore3de4bab2006-11-17 17:38:54 -05004140 if (isec->sclass == SECCLASS_UNIX_STREAM_SOCKET ||
4141 isec->sclass == SECCLASS_TCP_SOCKET) {
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004142 ssec = sock->sk->sk_security;
4143 peer_sid = ssec->peer_sid;
4144 }
Paul Moore3de4bab2006-11-17 17:38:54 -05004145 if (peer_sid == SECSID_NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004146 err = -ENOPROTOOPT;
4147 goto out;
4148 }
4149
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004150 err = security_sid_to_context(peer_sid, &scontext, &scontext_len);
4151
Linus Torvalds1da177e2005-04-16 15:20:36 -07004152 if (err)
4153 goto out;
4154
4155 if (scontext_len > len) {
4156 err = -ERANGE;
4157 goto out_len;
4158 }
4159
4160 if (copy_to_user(optval, scontext, scontext_len))
4161 err = -EFAULT;
4162
4163out_len:
4164 if (put_user(scontext_len, optlen))
4165 err = -EFAULT;
4166
4167 kfree(scontext);
Eric Paris828dfe12008-04-17 13:17:49 -04004168out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004169 return err;
4170}
4171
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004172static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004173{
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004174 u32 peer_secid = SECSID_NULL;
Paul Moore75e22912008-01-29 08:38:04 -05004175 u16 family;
Catherine Zhang877ce7c2006-06-29 12:27:47 -07004176
Paul Mooreaa862902008-10-10 10:16:29 -04004177 if (skb && skb->protocol == htons(ETH_P_IP))
4178 family = PF_INET;
4179 else if (skb && skb->protocol == htons(ETH_P_IPV6))
4180 family = PF_INET6;
4181 else if (sock)
Paul Moore75e22912008-01-29 08:38:04 -05004182 family = sock->sk->sk_family;
Paul Moore75e22912008-01-29 08:38:04 -05004183 else
4184 goto out;
4185
4186 if (sock && family == PF_UNIX)
Ahmed S. Darwish713a04a2008-03-01 21:52:30 +02004187 selinux_inode_getsecid(SOCK_INODE(sock), &peer_secid);
Paul Moore3de4bab2006-11-17 17:38:54 -05004188 else if (skb)
Paul Moore220deb92008-01-29 08:38:23 -05004189 selinux_skb_peerlbl_sid(skb, family, &peer_secid);
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004190
Paul Moore75e22912008-01-29 08:38:04 -05004191out:
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07004192 *secid = peer_secid;
Paul Moore75e22912008-01-29 08:38:04 -05004193 if (peer_secid == SECSID_NULL)
4194 return -EINVAL;
4195 return 0;
Catherine Zhang2c7946a2006-03-20 22:41:23 -08004196}
4197
Al Viro7d877f32005-10-21 03:20:43 -04004198static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004199{
4200 return sk_alloc_security(sk, family, priority);
4201}
4202
4203static void selinux_sk_free_security(struct sock *sk)
4204{
4205 sk_free_security(sk);
4206}
4207
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004208static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
4209{
4210 struct sk_security_struct *ssec = sk->sk_security;
4211 struct sk_security_struct *newssec = newsk->sk_security;
4212
4213 newssec->sid = ssec->sid;
4214 newssec->peer_sid = ssec->peer_sid;
Paul Moore220deb92008-01-29 08:38:23 -05004215 newssec->sclass = ssec->sclass;
Paul Moore99f59ed2006-08-29 17:53:48 -07004216
Paul Moore389fb802009-03-27 17:10:34 -04004217 selinux_netlbl_sk_security_reset(newssec);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004218}
4219
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004220static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004221{
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004222 if (!sk)
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004223 *secid = SECINITSID_ANY_SOCKET;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004224 else {
4225 struct sk_security_struct *sksec = sk->sk_security;
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004226
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07004227 *secid = sksec->sid;
Venkat Yekkirala892c1412006-08-04 23:08:56 -07004228 }
Trent Jaegerd28d1e02005-12-13 23:12:40 -08004229}
4230
Eric Paris828dfe12008-04-17 13:17:49 -04004231static void selinux_sock_graft(struct sock *sk, struct socket *parent)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004232{
4233 struct inode_security_struct *isec = SOCK_INODE(parent)->i_security;
4234 struct sk_security_struct *sksec = sk->sk_security;
4235
David Woodhouse2148ccc2006-09-29 15:50:25 -07004236 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 ||
4237 sk->sk_family == PF_UNIX)
4238 isec->sid = sksec->sid;
Paul Moore220deb92008-01-29 08:38:23 -05004239 sksec->sclass = isec->sclass;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004240}
4241
Adrian Bunk9a673e52006-08-15 00:03:53 -07004242static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4243 struct request_sock *req)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004244{
4245 struct sk_security_struct *sksec = sk->sk_security;
4246 int err;
Paul Mooreaa862902008-10-10 10:16:29 -04004247 u16 family = sk->sk_family;
Venkat Yekkirala7420ed22006-08-04 23:17:57 -07004248 u32 newsid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004249 u32 peersid;
4250
Paul Mooreaa862902008-10-10 10:16:29 -04004251 /* handle mapped IPv4 packets arriving via IPv6 sockets */
4252 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4253 family = PF_INET;
4254
4255 err = selinux_skb_peerlbl_sid(skb, family, &peersid);
Paul Moore220deb92008-01-29 08:38:23 -05004256 if (err)
4257 return err;
Venkat Yekkiralaa51c64f2006-07-27 22:01:34 -07004258 if (peersid == SECSID_NULL) {
4259 req->secid = sksec->sid;
Paul Moore3de4bab2006-11-17 17:38:54 -05004260 req->peer_secid = SECSID_NULL;
Paul Moore389fb802009-03-27 17:10:34 -04004261 } else {
4262 err = security_sid_mls_copy(sksec->sid, peersid, &newsid);
4263 if (err)
4264 return err;
4265 req->secid = newsid;
4266 req->peer_secid = peersid;
Venkat Yekkiralaa51c64f2006-07-27 22:01:34 -07004267 }
4268
Paul Moore389fb802009-03-27 17:10:34 -04004269 return selinux_netlbl_inet_conn_request(req, family);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004270}
4271
Adrian Bunk9a673e52006-08-15 00:03:53 -07004272static void selinux_inet_csk_clone(struct sock *newsk,
4273 const struct request_sock *req)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004274{
4275 struct sk_security_struct *newsksec = newsk->sk_security;
4276
4277 newsksec->sid = req->secid;
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004278 newsksec->peer_sid = req->peer_secid;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004279 /* NOTE: Ideally, we should also get the isec->sid for the
4280 new socket in sync, but we don't have the isec available yet.
4281 So we will wait until sock_graft to do it, by which
4282 time it will have been created and available. */
Paul Moore99f59ed2006-08-29 17:53:48 -07004283
Paul Moore9f2ad662006-11-17 17:38:53 -05004284 /* We don't need to take any sort of lock here as we are the only
4285 * thread with access to newsksec */
Paul Moore389fb802009-03-27 17:10:34 -04004286 selinux_netlbl_inet_csk_clone(newsk, req->rsk_ops->family);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004287}
4288
Paul Moore014ab192008-10-10 10:16:33 -04004289static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004290{
Paul Mooreaa862902008-10-10 10:16:29 -04004291 u16 family = sk->sk_family;
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004292 struct sk_security_struct *sksec = sk->sk_security;
4293
Paul Mooreaa862902008-10-10 10:16:29 -04004294 /* handle mapped IPv4 packets arriving via IPv6 sockets */
4295 if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4296 family = PF_INET;
4297
4298 selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid);
Venkat Yekkirala6b877692006-11-08 17:04:09 -06004299}
4300
Adrian Bunk9a673e52006-08-15 00:03:53 -07004301static void selinux_req_classify_flow(const struct request_sock *req,
4302 struct flowi *fl)
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004303{
4304 fl->secid = req->secid;
4305}
4306
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb)
4308{
4309 int err = 0;
4310 u32 perm;
4311 struct nlmsghdr *nlh;
4312 struct socket *sock = sk->sk_socket;
4313 struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
Eric Paris828dfe12008-04-17 13:17:49 -04004314
Linus Torvalds1da177e2005-04-16 15:20:36 -07004315 if (skb->len < NLMSG_SPACE(0)) {
4316 err = -EINVAL;
4317 goto out;
4318 }
Arnaldo Carvalho de Melob529ccf2007-04-25 19:08:35 -07004319 nlh = nlmsg_hdr(skb);
Eric Paris828dfe12008-04-17 13:17:49 -04004320
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321 err = selinux_nlmsg_lookup(isec->sclass, nlh->nlmsg_type, &perm);
4322 if (err) {
4323 if (err == -EINVAL) {
David Woodhouse9ad9ad32005-06-22 15:04:33 +01004324 audit_log(current->audit_context, GFP_KERNEL, AUDIT_SELINUX_ERR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325 "SELinux: unrecognized netlink message"
4326 " type=%hu for sclass=%hu\n",
4327 nlh->nlmsg_type, isec->sclass);
Eric Paris39c9aed2008-11-05 09:34:42 -05004328 if (!selinux_enforcing || security_get_allow_unknown())
Linus Torvalds1da177e2005-04-16 15:20:36 -07004329 err = 0;
4330 }
4331
4332 /* Ignore */
4333 if (err == -ENOENT)
4334 err = 0;
4335 goto out;
4336 }
4337
4338 err = socket_has_perm(current, sock, perm);
4339out:
4340 return err;
4341}
4342
4343#ifdef CONFIG_NETFILTER
4344
Paul Mooreeffad8d2008-01-29 08:49:27 -05004345static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
4346 u16 family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004347{
Paul Mooredfaebe92008-10-10 10:16:31 -04004348 int err;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004349 char *addrp;
4350 u32 peer_sid;
4351 struct avc_audit_data ad;
4352 u8 secmark_active;
Paul Moore948bf852008-10-10 10:16:32 -04004353 u8 netlbl_active;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004354 u8 peerlbl_active;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004355
Paul Mooreeffad8d2008-01-29 08:49:27 -05004356 if (!selinux_policycap_netpeer)
4357 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004358
Paul Mooreeffad8d2008-01-29 08:49:27 -05004359 secmark_active = selinux_secmark_enabled();
Paul Moore948bf852008-10-10 10:16:32 -04004360 netlbl_active = netlbl_enabled();
4361 peerlbl_active = netlbl_active || selinux_xfrm_enabled();
Paul Mooreeffad8d2008-01-29 08:49:27 -05004362 if (!secmark_active && !peerlbl_active)
4363 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004364
Paul Moored8395c82008-10-10 10:16:30 -04004365 if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
4366 return NF_DROP;
4367
Paul Mooreeffad8d2008-01-29 08:49:27 -05004368 AVC_AUDIT_DATA_INIT(&ad, NET);
4369 ad.u.net.netif = ifindex;
4370 ad.u.net.family = family;
4371 if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0)
4372 return NF_DROP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004373
Paul Mooredfaebe92008-10-10 10:16:31 -04004374 if (peerlbl_active) {
4375 err = selinux_inet_sys_rcv_skb(ifindex, addrp, family,
4376 peer_sid, &ad);
4377 if (err) {
4378 selinux_netlbl_err(skb, err, 1);
Paul Mooreeffad8d2008-01-29 08:49:27 -05004379 return NF_DROP;
Paul Mooredfaebe92008-10-10 10:16:31 -04004380 }
4381 }
Paul Mooreeffad8d2008-01-29 08:49:27 -05004382
4383 if (secmark_active)
4384 if (avc_has_perm(peer_sid, skb->secmark,
4385 SECCLASS_PACKET, PACKET__FORWARD_IN, &ad))
4386 return NF_DROP;
4387
Paul Moore948bf852008-10-10 10:16:32 -04004388 if (netlbl_active)
4389 /* we do this in the FORWARD path and not the POST_ROUTING
4390 * path because we want to make sure we apply the necessary
4391 * labeling before IPsec is applied so we can leverage AH
4392 * protection */
4393 if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0)
4394 return NF_DROP;
4395
Paul Mooreeffad8d2008-01-29 08:49:27 -05004396 return NF_ACCEPT;
4397}
4398
4399static unsigned int selinux_ipv4_forward(unsigned int hooknum,
4400 struct sk_buff *skb,
4401 const struct net_device *in,
4402 const struct net_device *out,
4403 int (*okfn)(struct sk_buff *))
4404{
4405 return selinux_ip_forward(skb, in->ifindex, PF_INET);
4406}
4407
4408#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4409static unsigned int selinux_ipv6_forward(unsigned int hooknum,
4410 struct sk_buff *skb,
4411 const struct net_device *in,
4412 const struct net_device *out,
4413 int (*okfn)(struct sk_buff *))
4414{
4415 return selinux_ip_forward(skb, in->ifindex, PF_INET6);
4416}
4417#endif /* IPV6 */
4418
Paul Moore948bf852008-10-10 10:16:32 -04004419static unsigned int selinux_ip_output(struct sk_buff *skb,
4420 u16 family)
4421{
4422 u32 sid;
4423
4424 if (!netlbl_enabled())
4425 return NF_ACCEPT;
4426
4427 /* we do this in the LOCAL_OUT path and not the POST_ROUTING path
4428 * because we want to make sure we apply the necessary labeling
4429 * before IPsec is applied so we can leverage AH protection */
4430 if (skb->sk) {
4431 struct sk_security_struct *sksec = skb->sk->sk_security;
4432 sid = sksec->sid;
4433 } else
4434 sid = SECINITSID_KERNEL;
4435 if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0)
4436 return NF_DROP;
4437
4438 return NF_ACCEPT;
4439}
4440
4441static unsigned int selinux_ipv4_output(unsigned int hooknum,
4442 struct sk_buff *skb,
4443 const struct net_device *in,
4444 const struct net_device *out,
4445 int (*okfn)(struct sk_buff *))
4446{
4447 return selinux_ip_output(skb, PF_INET);
4448}
4449
Paul Mooreeffad8d2008-01-29 08:49:27 -05004450static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb,
4451 int ifindex,
Paul Moored8395c82008-10-10 10:16:30 -04004452 u16 family)
James Morris4e5ab4c2006-06-09 00:33:33 -07004453{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004454 struct sock *sk = skb->sk;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004455 struct sk_security_struct *sksec;
Paul Moored8395c82008-10-10 10:16:30 -04004456 struct avc_audit_data ad;
4457 char *addrp;
4458 u8 proto;
James Morris4e5ab4c2006-06-09 00:33:33 -07004459
Paul Mooreeffad8d2008-01-29 08:49:27 -05004460 if (sk == NULL)
4461 return NF_ACCEPT;
Venkat Yekkirala4237c752006-07-24 23:32:50 -07004462 sksec = sk->sk_security;
James Morris4e5ab4c2006-06-09 00:33:33 -07004463
Paul Moored8395c82008-10-10 10:16:30 -04004464 AVC_AUDIT_DATA_INIT(&ad, NET);
4465 ad.u.net.netif = ifindex;
4466 ad.u.net.family = family;
4467 if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
4468 return NF_DROP;
4469
Paul Moore58bfbb52009-03-27 17:10:41 -04004470 if (selinux_secmark_enabled())
Paul Mooreeffad8d2008-01-29 08:49:27 -05004471 if (avc_has_perm(sksec->sid, skb->secmark,
Paul Moored8395c82008-10-10 10:16:30 -04004472 SECCLASS_PACKET, PACKET__SEND, &ad))
Paul Mooreeffad8d2008-01-29 08:49:27 -05004473 return NF_DROP;
James Morris4e5ab4c2006-06-09 00:33:33 -07004474
Paul Mooreeffad8d2008-01-29 08:49:27 -05004475 if (selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004476 if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto))
Paul Mooreeffad8d2008-01-29 08:49:27 -05004477 return NF_DROP;
James Morris4e5ab4c2006-06-09 00:33:33 -07004478
Paul Mooreeffad8d2008-01-29 08:49:27 -05004479 return NF_ACCEPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004480}
4481
Paul Mooreeffad8d2008-01-29 08:49:27 -05004482static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
4483 u16 family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004484{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004485 u32 secmark_perm;
4486 u32 peer_sid;
4487 struct sock *sk;
4488 struct avc_audit_data ad;
4489 char *addrp;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004490 u8 secmark_active;
4491 u8 peerlbl_active;
4492
Paul Mooreeffad8d2008-01-29 08:49:27 -05004493 /* If any sort of compatibility mode is enabled then handoff processing
4494 * to the selinux_ip_postroute_compat() function to deal with the
4495 * special handling. We do this in an attempt to keep this function
4496 * as fast and as clean as possible. */
Paul Moore58bfbb52009-03-27 17:10:41 -04004497 if (!selinux_policycap_netpeer)
Paul Moored8395c82008-10-10 10:16:30 -04004498 return selinux_ip_postroute_compat(skb, ifindex, family);
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07004499#ifdef CONFIG_XFRM
Paul Mooreeffad8d2008-01-29 08:49:27 -05004500 /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec
4501 * packet transformation so allow the packet to pass without any checks
4502 * since we'll have another chance to perform access control checks
4503 * when the packet is on it's final way out.
4504 * NOTE: there appear to be some IPv6 multicast cases where skb->dst
4505 * is NULL, in this case go ahead and apply access control. */
4506 if (skb->dst != NULL && skb->dst->xfrm != NULL)
4507 return NF_ACCEPT;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07004508#endif
Paul Mooreeffad8d2008-01-29 08:49:27 -05004509 secmark_active = selinux_secmark_enabled();
4510 peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4511 if (!secmark_active && !peerlbl_active)
4512 return NF_ACCEPT;
4513
Paul Moored8395c82008-10-10 10:16:30 -04004514 /* if the packet is being forwarded then get the peer label from the
4515 * packet itself; otherwise check to see if it is from a local
4516 * application or the kernel, if from an application get the peer label
4517 * from the sending socket, otherwise use the kernel's sid */
Paul Mooreeffad8d2008-01-29 08:49:27 -05004518 sk = skb->sk;
Paul Moored8395c82008-10-10 10:16:30 -04004519 if (sk == NULL) {
4520 switch (family) {
4521 case PF_INET:
4522 if (IPCB(skb)->flags & IPSKB_FORWARDED)
4523 secmark_perm = PACKET__FORWARD_OUT;
4524 else
4525 secmark_perm = PACKET__SEND;
4526 break;
4527 case PF_INET6:
4528 if (IP6CB(skb)->flags & IP6SKB_FORWARDED)
4529 secmark_perm = PACKET__FORWARD_OUT;
4530 else
4531 secmark_perm = PACKET__SEND;
4532 break;
4533 default:
4534 return NF_DROP;
4535 }
4536 if (secmark_perm == PACKET__FORWARD_OUT) {
4537 if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
4538 return NF_DROP;
4539 } else
4540 peer_sid = SECINITSID_KERNEL;
4541 } else {
Paul Mooreeffad8d2008-01-29 08:49:27 -05004542 struct sk_security_struct *sksec = sk->sk_security;
4543 peer_sid = sksec->sid;
4544 secmark_perm = PACKET__SEND;
Paul Mooreeffad8d2008-01-29 08:49:27 -05004545 }
4546
Paul Moored8395c82008-10-10 10:16:30 -04004547 AVC_AUDIT_DATA_INIT(&ad, NET);
4548 ad.u.net.netif = ifindex;
4549 ad.u.net.family = family;
4550 if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL))
4551 return NF_DROP;
4552
Paul Mooreeffad8d2008-01-29 08:49:27 -05004553 if (secmark_active)
4554 if (avc_has_perm(peer_sid, skb->secmark,
4555 SECCLASS_PACKET, secmark_perm, &ad))
4556 return NF_DROP;
4557
4558 if (peerlbl_active) {
4559 u32 if_sid;
4560 u32 node_sid;
4561
4562 if (sel_netif_sid(ifindex, &if_sid))
4563 return NF_DROP;
4564 if (avc_has_perm(peer_sid, if_sid,
4565 SECCLASS_NETIF, NETIF__EGRESS, &ad))
4566 return NF_DROP;
4567
4568 if (sel_netnode_sid(addrp, family, &node_sid))
4569 return NF_DROP;
4570 if (avc_has_perm(peer_sid, node_sid,
4571 SECCLASS_NODE, NODE__SENDTO, &ad))
4572 return NF_DROP;
4573 }
4574
4575 return NF_ACCEPT;
4576}
4577
4578static unsigned int selinux_ipv4_postroute(unsigned int hooknum,
4579 struct sk_buff *skb,
4580 const struct net_device *in,
4581 const struct net_device *out,
4582 int (*okfn)(struct sk_buff *))
4583{
4584 return selinux_ip_postroute(skb, out->ifindex, PF_INET);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004585}
4586
4587#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Paul Mooreeffad8d2008-01-29 08:49:27 -05004588static unsigned int selinux_ipv6_postroute(unsigned int hooknum,
4589 struct sk_buff *skb,
4590 const struct net_device *in,
4591 const struct net_device *out,
4592 int (*okfn)(struct sk_buff *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593{
Paul Mooreeffad8d2008-01-29 08:49:27 -05004594 return selinux_ip_postroute(skb, out->ifindex, PF_INET6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004595}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596#endif /* IPV6 */
4597
4598#endif /* CONFIG_NETFILTER */
4599
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb)
4601{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004602 int err;
4603
Eric Paris200ac532009-02-12 15:01:04 -05004604 err = cap_netlink_send(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004605 if (err)
4606 return err;
4607
Linus Torvalds1da177e2005-04-16 15:20:36 -07004608 if (policydb_loaded_version >= POLICYDB_VERSION_NLCLASS)
4609 err = selinux_nlmsg_perm(sk, skb);
4610
4611 return err;
4612}
4613
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004614static int selinux_netlink_recv(struct sk_buff *skb, int capability)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004615{
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004616 int err;
4617 struct avc_audit_data ad;
4618
Eric Paris200ac532009-02-12 15:01:04 -05004619 err = cap_netlink_recv(skb, capability);
Darrel Goeddelc7bdb542006-06-27 13:26:11 -07004620 if (err)
4621 return err;
4622
4623 AVC_AUDIT_DATA_INIT(&ad, CAP);
4624 ad.u.cap = capability;
4625
4626 return avc_has_perm(NETLINK_CB(skb).sid, NETLINK_CB(skb).sid,
Eric Paris828dfe12008-04-17 13:17:49 -04004627 SECCLASS_CAPABILITY, CAP_TO_MASK(capability), &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004628}
4629
4630static int ipc_alloc_security(struct task_struct *task,
4631 struct kern_ipc_perm *perm,
4632 u16 sclass)
4633{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004634 struct ipc_security_struct *isec;
David Howells275bb412008-11-14 10:39:19 +11004635 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004636
James Morris89d155e2005-10-30 14:59:21 -08004637 isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004638 if (!isec)
4639 return -ENOMEM;
4640
David Howells275bb412008-11-14 10:39:19 +11004641 sid = task_sid(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004642 isec->sclass = sclass;
David Howells275bb412008-11-14 10:39:19 +11004643 isec->sid = sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004644 perm->security = isec;
4645
4646 return 0;
4647}
4648
4649static void ipc_free_security(struct kern_ipc_perm *perm)
4650{
4651 struct ipc_security_struct *isec = perm->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004652 perm->security = NULL;
4653 kfree(isec);
4654}
4655
4656static int msg_msg_alloc_security(struct msg_msg *msg)
4657{
4658 struct msg_security_struct *msec;
4659
James Morris89d155e2005-10-30 14:59:21 -08004660 msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004661 if (!msec)
4662 return -ENOMEM;
4663
Linus Torvalds1da177e2005-04-16 15:20:36 -07004664 msec->sid = SECINITSID_UNLABELED;
4665 msg->security = msec;
4666
4667 return 0;
4668}
4669
4670static void msg_msg_free_security(struct msg_msg *msg)
4671{
4672 struct msg_security_struct *msec = msg->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673
4674 msg->security = NULL;
4675 kfree(msec);
4676}
4677
4678static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
Stephen Smalley6af963f2005-05-01 08:58:39 -07004679 u32 perms)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004680{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004681 struct ipc_security_struct *isec;
4682 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004683 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004684
Linus Torvalds1da177e2005-04-16 15:20:36 -07004685 isec = ipc_perms->security;
4686
4687 AVC_AUDIT_DATA_INIT(&ad, IPC);
4688 ad.u.ipc_id = ipc_perms->key;
4689
David Howells275bb412008-11-14 10:39:19 +11004690 return avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004691}
4692
4693static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
4694{
4695 return msg_msg_alloc_security(msg);
4696}
4697
4698static void selinux_msg_msg_free_security(struct msg_msg *msg)
4699{
4700 msg_msg_free_security(msg);
4701}
4702
4703/* message queue security operations */
4704static int selinux_msg_queue_alloc_security(struct msg_queue *msq)
4705{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004706 struct ipc_security_struct *isec;
4707 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004708 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004709 int rc;
4710
4711 rc = ipc_alloc_security(current, &msq->q_perm, SECCLASS_MSGQ);
4712 if (rc)
4713 return rc;
4714
Linus Torvalds1da177e2005-04-16 15:20:36 -07004715 isec = msq->q_perm.security;
4716
4717 AVC_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004718 ad.u.ipc_id = msq->q_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004719
David Howells275bb412008-11-14 10:39:19 +11004720 rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004721 MSGQ__CREATE, &ad);
4722 if (rc) {
4723 ipc_free_security(&msq->q_perm);
4724 return rc;
4725 }
4726 return 0;
4727}
4728
4729static void selinux_msg_queue_free_security(struct msg_queue *msq)
4730{
4731 ipc_free_security(&msq->q_perm);
4732}
4733
4734static int selinux_msg_queue_associate(struct msg_queue *msq, int msqflg)
4735{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004736 struct ipc_security_struct *isec;
4737 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004738 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004739
Linus Torvalds1da177e2005-04-16 15:20:36 -07004740 isec = msq->q_perm.security;
4741
4742 AVC_AUDIT_DATA_INIT(&ad, IPC);
4743 ad.u.ipc_id = msq->q_perm.key;
4744
David Howells275bb412008-11-14 10:39:19 +11004745 return avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004746 MSGQ__ASSOCIATE, &ad);
4747}
4748
4749static int selinux_msg_queue_msgctl(struct msg_queue *msq, int cmd)
4750{
4751 int err;
4752 int perms;
4753
Eric Paris828dfe12008-04-17 13:17:49 -04004754 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004755 case IPC_INFO:
4756 case MSG_INFO:
4757 /* No specific object, just general system-wide information. */
4758 return task_has_system(current, SYSTEM__IPC_INFO);
4759 case IPC_STAT:
4760 case MSG_STAT:
4761 perms = MSGQ__GETATTR | MSGQ__ASSOCIATE;
4762 break;
4763 case IPC_SET:
4764 perms = MSGQ__SETATTR;
4765 break;
4766 case IPC_RMID:
4767 perms = MSGQ__DESTROY;
4768 break;
4769 default:
4770 return 0;
4771 }
4772
Stephen Smalley6af963f2005-05-01 08:58:39 -07004773 err = ipc_has_perm(&msq->q_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004774 return err;
4775}
4776
4777static int selinux_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, int msqflg)
4778{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004779 struct ipc_security_struct *isec;
4780 struct msg_security_struct *msec;
4781 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004782 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004783 int rc;
4784
Linus Torvalds1da177e2005-04-16 15:20:36 -07004785 isec = msq->q_perm.security;
4786 msec = msg->security;
4787
4788 /*
4789 * First time through, need to assign label to the message
4790 */
4791 if (msec->sid == SECINITSID_UNLABELED) {
4792 /*
4793 * Compute new sid based on current process and
4794 * message queue this message will be stored in
4795 */
David Howells275bb412008-11-14 10:39:19 +11004796 rc = security_transition_sid(sid, isec->sid, SECCLASS_MSG,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797 &msec->sid);
4798 if (rc)
4799 return rc;
4800 }
4801
4802 AVC_AUDIT_DATA_INIT(&ad, IPC);
4803 ad.u.ipc_id = msq->q_perm.key;
4804
4805 /* Can this process write to the queue? */
David Howells275bb412008-11-14 10:39:19 +11004806 rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004807 MSGQ__WRITE, &ad);
4808 if (!rc)
4809 /* Can this process send the message */
David Howells275bb412008-11-14 10:39:19 +11004810 rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG,
4811 MSG__SEND, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004812 if (!rc)
4813 /* Can the message be put in the queue? */
David Howells275bb412008-11-14 10:39:19 +11004814 rc = avc_has_perm(msec->sid, isec->sid, SECCLASS_MSGQ,
4815 MSGQ__ENQUEUE, &ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004816
4817 return rc;
4818}
4819
4820static int selinux_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
4821 struct task_struct *target,
4822 long type, int mode)
4823{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004824 struct ipc_security_struct *isec;
4825 struct msg_security_struct *msec;
4826 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004827 u32 sid = task_sid(target);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004828 int rc;
4829
Linus Torvalds1da177e2005-04-16 15:20:36 -07004830 isec = msq->q_perm.security;
4831 msec = msg->security;
4832
4833 AVC_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004834 ad.u.ipc_id = msq->q_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004835
David Howells275bb412008-11-14 10:39:19 +11004836 rc = avc_has_perm(sid, isec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004837 SECCLASS_MSGQ, MSGQ__READ, &ad);
4838 if (!rc)
David Howells275bb412008-11-14 10:39:19 +11004839 rc = avc_has_perm(sid, msec->sid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004840 SECCLASS_MSG, MSG__RECEIVE, &ad);
4841 return rc;
4842}
4843
4844/* Shared Memory security operations */
4845static int selinux_shm_alloc_security(struct shmid_kernel *shp)
4846{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004847 struct ipc_security_struct *isec;
4848 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004849 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004850 int rc;
4851
4852 rc = ipc_alloc_security(current, &shp->shm_perm, SECCLASS_SHM);
4853 if (rc)
4854 return rc;
4855
Linus Torvalds1da177e2005-04-16 15:20:36 -07004856 isec = shp->shm_perm.security;
4857
4858 AVC_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004859 ad.u.ipc_id = shp->shm_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004860
David Howells275bb412008-11-14 10:39:19 +11004861 rc = avc_has_perm(sid, isec->sid, SECCLASS_SHM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004862 SHM__CREATE, &ad);
4863 if (rc) {
4864 ipc_free_security(&shp->shm_perm);
4865 return rc;
4866 }
4867 return 0;
4868}
4869
4870static void selinux_shm_free_security(struct shmid_kernel *shp)
4871{
4872 ipc_free_security(&shp->shm_perm);
4873}
4874
4875static int selinux_shm_associate(struct shmid_kernel *shp, int shmflg)
4876{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004877 struct ipc_security_struct *isec;
4878 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004879 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004880
Linus Torvalds1da177e2005-04-16 15:20:36 -07004881 isec = shp->shm_perm.security;
4882
4883 AVC_AUDIT_DATA_INIT(&ad, IPC);
4884 ad.u.ipc_id = shp->shm_perm.key;
4885
David Howells275bb412008-11-14 10:39:19 +11004886 return avc_has_perm(sid, isec->sid, SECCLASS_SHM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004887 SHM__ASSOCIATE, &ad);
4888}
4889
4890/* Note, at this point, shp is locked down */
4891static int selinux_shm_shmctl(struct shmid_kernel *shp, int cmd)
4892{
4893 int perms;
4894 int err;
4895
Eric Paris828dfe12008-04-17 13:17:49 -04004896 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004897 case IPC_INFO:
4898 case SHM_INFO:
4899 /* No specific object, just general system-wide information. */
4900 return task_has_system(current, SYSTEM__IPC_INFO);
4901 case IPC_STAT:
4902 case SHM_STAT:
4903 perms = SHM__GETATTR | SHM__ASSOCIATE;
4904 break;
4905 case IPC_SET:
4906 perms = SHM__SETATTR;
4907 break;
4908 case SHM_LOCK:
4909 case SHM_UNLOCK:
4910 perms = SHM__LOCK;
4911 break;
4912 case IPC_RMID:
4913 perms = SHM__DESTROY;
4914 break;
4915 default:
4916 return 0;
4917 }
4918
Stephen Smalley6af963f2005-05-01 08:58:39 -07004919 err = ipc_has_perm(&shp->shm_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004920 return err;
4921}
4922
4923static int selinux_shm_shmat(struct shmid_kernel *shp,
4924 char __user *shmaddr, int shmflg)
4925{
4926 u32 perms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004927
4928 if (shmflg & SHM_RDONLY)
4929 perms = SHM__READ;
4930 else
4931 perms = SHM__READ | SHM__WRITE;
4932
Stephen Smalley6af963f2005-05-01 08:58:39 -07004933 return ipc_has_perm(&shp->shm_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004934}
4935
4936/* Semaphore security operations */
4937static int selinux_sem_alloc_security(struct sem_array *sma)
4938{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004939 struct ipc_security_struct *isec;
4940 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004941 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004942 int rc;
4943
4944 rc = ipc_alloc_security(current, &sma->sem_perm, SECCLASS_SEM);
4945 if (rc)
4946 return rc;
4947
Linus Torvalds1da177e2005-04-16 15:20:36 -07004948 isec = sma->sem_perm.security;
4949
4950 AVC_AUDIT_DATA_INIT(&ad, IPC);
Eric Paris828dfe12008-04-17 13:17:49 -04004951 ad.u.ipc_id = sma->sem_perm.key;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004952
David Howells275bb412008-11-14 10:39:19 +11004953 rc = avc_has_perm(sid, isec->sid, SECCLASS_SEM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004954 SEM__CREATE, &ad);
4955 if (rc) {
4956 ipc_free_security(&sma->sem_perm);
4957 return rc;
4958 }
4959 return 0;
4960}
4961
4962static void selinux_sem_free_security(struct sem_array *sma)
4963{
4964 ipc_free_security(&sma->sem_perm);
4965}
4966
4967static int selinux_sem_associate(struct sem_array *sma, int semflg)
4968{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004969 struct ipc_security_struct *isec;
4970 struct avc_audit_data ad;
David Howells275bb412008-11-14 10:39:19 +11004971 u32 sid = current_sid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004972
Linus Torvalds1da177e2005-04-16 15:20:36 -07004973 isec = sma->sem_perm.security;
4974
4975 AVC_AUDIT_DATA_INIT(&ad, IPC);
4976 ad.u.ipc_id = sma->sem_perm.key;
4977
David Howells275bb412008-11-14 10:39:19 +11004978 return avc_has_perm(sid, isec->sid, SECCLASS_SEM,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004979 SEM__ASSOCIATE, &ad);
4980}
4981
4982/* Note, at this point, sma is locked down */
4983static int selinux_sem_semctl(struct sem_array *sma, int cmd)
4984{
4985 int err;
4986 u32 perms;
4987
Eric Paris828dfe12008-04-17 13:17:49 -04004988 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004989 case IPC_INFO:
4990 case SEM_INFO:
4991 /* No specific object, just general system-wide information. */
4992 return task_has_system(current, SYSTEM__IPC_INFO);
4993 case GETPID:
4994 case GETNCNT:
4995 case GETZCNT:
4996 perms = SEM__GETATTR;
4997 break;
4998 case GETVAL:
4999 case GETALL:
5000 perms = SEM__READ;
5001 break;
5002 case SETVAL:
5003 case SETALL:
5004 perms = SEM__WRITE;
5005 break;
5006 case IPC_RMID:
5007 perms = SEM__DESTROY;
5008 break;
5009 case IPC_SET:
5010 perms = SEM__SETATTR;
5011 break;
5012 case IPC_STAT:
5013 case SEM_STAT:
5014 perms = SEM__GETATTR | SEM__ASSOCIATE;
5015 break;
5016 default:
5017 return 0;
5018 }
5019
Stephen Smalley6af963f2005-05-01 08:58:39 -07005020 err = ipc_has_perm(&sma->sem_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005021 return err;
5022}
5023
5024static int selinux_sem_semop(struct sem_array *sma,
5025 struct sembuf *sops, unsigned nsops, int alter)
5026{
5027 u32 perms;
5028
5029 if (alter)
5030 perms = SEM__READ | SEM__WRITE;
5031 else
5032 perms = SEM__READ;
5033
Stephen Smalley6af963f2005-05-01 08:58:39 -07005034 return ipc_has_perm(&sma->sem_perm, perms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005035}
5036
5037static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
5038{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005039 u32 av = 0;
5040
Linus Torvalds1da177e2005-04-16 15:20:36 -07005041 av = 0;
5042 if (flag & S_IRUGO)
5043 av |= IPC__UNIX_READ;
5044 if (flag & S_IWUGO)
5045 av |= IPC__UNIX_WRITE;
5046
5047 if (av == 0)
5048 return 0;
5049
Stephen Smalley6af963f2005-05-01 08:58:39 -07005050 return ipc_has_perm(ipcp, av);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005051}
5052
Ahmed S. Darwish713a04a2008-03-01 21:52:30 +02005053static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
5054{
5055 struct ipc_security_struct *isec = ipcp->security;
5056 *secid = isec->sid;
5057}
5058
Eric Paris828dfe12008-04-17 13:17:49 -04005059static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005060{
5061 if (inode)
5062 inode_doinit_with_dentry(inode, dentry);
5063}
5064
5065static int selinux_getprocattr(struct task_struct *p,
Al Viro04ff9702007-03-12 16:17:58 +00005066 char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005067{
David Howells275bb412008-11-14 10:39:19 +11005068 const struct task_security_struct *__tsec;
Dustin Kirkland8c8570f2005-11-03 17:15:16 +00005069 u32 sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005070 int error;
Al Viro04ff9702007-03-12 16:17:58 +00005071 unsigned len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005072
5073 if (current != p) {
David Howells3b11a1d2008-11-14 10:39:26 +11005074 error = current_has_perm(p, PROCESS__GETATTR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005075 if (error)
5076 return error;
5077 }
5078
David Howells275bb412008-11-14 10:39:19 +11005079 rcu_read_lock();
5080 __tsec = __task_cred(p)->security;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005081
5082 if (!strcmp(name, "current"))
David Howells275bb412008-11-14 10:39:19 +11005083 sid = __tsec->sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005084 else if (!strcmp(name, "prev"))
David Howells275bb412008-11-14 10:39:19 +11005085 sid = __tsec->osid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005086 else if (!strcmp(name, "exec"))
David Howells275bb412008-11-14 10:39:19 +11005087 sid = __tsec->exec_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005088 else if (!strcmp(name, "fscreate"))
David Howells275bb412008-11-14 10:39:19 +11005089 sid = __tsec->create_sid;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005090 else if (!strcmp(name, "keycreate"))
David Howells275bb412008-11-14 10:39:19 +11005091 sid = __tsec->keycreate_sid;
Eric Paris42c3e032006-06-26 00:26:03 -07005092 else if (!strcmp(name, "sockcreate"))
David Howells275bb412008-11-14 10:39:19 +11005093 sid = __tsec->sockcreate_sid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005094 else
David Howells275bb412008-11-14 10:39:19 +11005095 goto invalid;
5096 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005097
5098 if (!sid)
5099 return 0;
5100
Al Viro04ff9702007-03-12 16:17:58 +00005101 error = security_sid_to_context(sid, value, &len);
5102 if (error)
5103 return error;
5104 return len;
David Howells275bb412008-11-14 10:39:19 +11005105
5106invalid:
5107 rcu_read_unlock();
5108 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005109}
5110
5111static int selinux_setprocattr(struct task_struct *p,
5112 char *name, void *value, size_t size)
5113{
5114 struct task_security_struct *tsec;
Roland McGrath03563572008-03-26 15:46:39 -07005115 struct task_struct *tracer;
David Howellsd84f4f92008-11-14 10:39:23 +11005116 struct cred *new;
5117 u32 sid = 0, ptsid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005118 int error;
5119 char *str = value;
5120
5121 if (current != p) {
5122 /* SELinux only allows a process to change its own
5123 security attributes. */
5124 return -EACCES;
5125 }
5126
5127 /*
5128 * Basic control over ability to set these attributes at all.
5129 * current == p, but we'll pass them separately in case the
5130 * above restriction is ever removed.
5131 */
5132 if (!strcmp(name, "exec"))
David Howells3b11a1d2008-11-14 10:39:26 +11005133 error = current_has_perm(p, PROCESS__SETEXEC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005134 else if (!strcmp(name, "fscreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005135 error = current_has_perm(p, PROCESS__SETFSCREATE);
Michael LeMay4eb582c2006-06-26 00:24:57 -07005136 else if (!strcmp(name, "keycreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005137 error = current_has_perm(p, PROCESS__SETKEYCREATE);
Eric Paris42c3e032006-06-26 00:26:03 -07005138 else if (!strcmp(name, "sockcreate"))
David Howells3b11a1d2008-11-14 10:39:26 +11005139 error = current_has_perm(p, PROCESS__SETSOCKCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005140 else if (!strcmp(name, "current"))
David Howells3b11a1d2008-11-14 10:39:26 +11005141 error = current_has_perm(p, PROCESS__SETCURRENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005142 else
5143 error = -EINVAL;
5144 if (error)
5145 return error;
5146
5147 /* Obtain a SID for the context, if one was specified. */
5148 if (size && str[1] && str[1] != '\n') {
5149 if (str[size-1] == '\n') {
5150 str[size-1] = 0;
5151 size--;
5152 }
5153 error = security_context_to_sid(value, size, &sid);
Stephen Smalley12b29f32008-05-07 13:03:20 -04005154 if (error == -EINVAL && !strcmp(name, "fscreate")) {
5155 if (!capable(CAP_MAC_ADMIN))
5156 return error;
5157 error = security_context_to_sid_force(value, size,
5158 &sid);
5159 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005160 if (error)
5161 return error;
5162 }
5163
David Howellsd84f4f92008-11-14 10:39:23 +11005164 new = prepare_creds();
5165 if (!new)
5166 return -ENOMEM;
5167
Linus Torvalds1da177e2005-04-16 15:20:36 -07005168 /* Permission checking based on the specified context is
5169 performed during the actual operation (execve,
5170 open/mkdir/...), when we know the full context of the
David Howellsd84f4f92008-11-14 10:39:23 +11005171 operation. See selinux_bprm_set_creds for the execve
Linus Torvalds1da177e2005-04-16 15:20:36 -07005172 checks and may_create for the file creation checks. The
5173 operation will then fail if the context is not permitted. */
David Howellsd84f4f92008-11-14 10:39:23 +11005174 tsec = new->security;
5175 if (!strcmp(name, "exec")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005176 tsec->exec_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005177 } else if (!strcmp(name, "fscreate")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005178 tsec->create_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005179 } else if (!strcmp(name, "keycreate")) {
Michael LeMay4eb582c2006-06-26 00:24:57 -07005180 error = may_create_key(sid, p);
5181 if (error)
David Howellsd84f4f92008-11-14 10:39:23 +11005182 goto abort_change;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005183 tsec->keycreate_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005184 } else if (!strcmp(name, "sockcreate")) {
Eric Paris42c3e032006-06-26 00:26:03 -07005185 tsec->sockcreate_sid = sid;
David Howellsd84f4f92008-11-14 10:39:23 +11005186 } else if (!strcmp(name, "current")) {
5187 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005188 if (sid == 0)
David Howellsd84f4f92008-11-14 10:39:23 +11005189 goto abort_change;
KaiGai Koheid9250de2008-08-28 16:35:57 +09005190
David Howellsd84f4f92008-11-14 10:39:23 +11005191 /* Only allow single threaded processes to change context */
5192 error = -EPERM;
5193 if (!is_single_threaded(p)) {
5194 error = security_bounded_transition(tsec->sid, sid);
5195 if (error)
5196 goto abort_change;
Eric Paris828dfe12008-04-17 13:17:49 -04005197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005198
5199 /* Check permissions for the transition. */
5200 error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
Eric Paris828dfe12008-04-17 13:17:49 -04005201 PROCESS__DYNTRANSITION, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005202 if (error)
David Howellsd84f4f92008-11-14 10:39:23 +11005203 goto abort_change;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005204
5205 /* Check for ptracing, and update the task SID if ok.
5206 Otherwise, leave SID unchanged and fail. */
David Howellsd84f4f92008-11-14 10:39:23 +11005207 ptsid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005208 task_lock(p);
Roland McGrath0d094ef2008-07-25 19:45:49 -07005209 tracer = tracehook_tracer_task(p);
David Howellsd84f4f92008-11-14 10:39:23 +11005210 if (tracer)
5211 ptsid = task_sid(tracer);
5212 task_unlock(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005213
David Howellsd84f4f92008-11-14 10:39:23 +11005214 if (tracer) {
5215 error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS,
5216 PROCESS__PTRACE, NULL);
5217 if (error)
5218 goto abort_change;
5219 }
5220
5221 tsec->sid = sid;
5222 } else {
5223 error = -EINVAL;
5224 goto abort_change;
5225 }
5226
5227 commit_creds(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005228 return size;
David Howellsd84f4f92008-11-14 10:39:23 +11005229
5230abort_change:
5231 abort_creds(new);
5232 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005233}
5234
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005235static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
5236{
5237 return security_sid_to_context(secid, secdata, seclen);
5238}
5239
David Howells7bf570d2008-04-29 20:52:51 +01005240static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
David Howells63cb3442008-01-15 23:47:35 +00005241{
5242 return security_context_to_sid(secdata, seclen, secid);
5243}
5244
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005245static void selinux_release_secctx(char *secdata, u32 seclen)
5246{
Paul Moore088999e2007-08-01 11:12:58 -04005247 kfree(secdata);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005248}
5249
Michael LeMayd7200242006-06-22 14:47:17 -07005250#ifdef CONFIG_KEYS
5251
David Howellsd84f4f92008-11-14 10:39:23 +11005252static int selinux_key_alloc(struct key *k, const struct cred *cred,
David Howells7e047ef2006-06-26 00:24:50 -07005253 unsigned long flags)
Michael LeMayd7200242006-06-22 14:47:17 -07005254{
David Howellsd84f4f92008-11-14 10:39:23 +11005255 const struct task_security_struct *tsec;
Michael LeMayd7200242006-06-22 14:47:17 -07005256 struct key_security_struct *ksec;
5257
5258 ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
5259 if (!ksec)
5260 return -ENOMEM;
5261
David Howellsd84f4f92008-11-14 10:39:23 +11005262 tsec = cred->security;
5263 if (tsec->keycreate_sid)
5264 ksec->sid = tsec->keycreate_sid;
Michael LeMay4eb582c2006-06-26 00:24:57 -07005265 else
David Howellsd84f4f92008-11-14 10:39:23 +11005266 ksec->sid = tsec->sid;
Michael LeMayd7200242006-06-22 14:47:17 -07005267
David Howells275bb412008-11-14 10:39:19 +11005268 k->security = ksec;
Michael LeMayd7200242006-06-22 14:47:17 -07005269 return 0;
5270}
5271
5272static void selinux_key_free(struct key *k)
5273{
5274 struct key_security_struct *ksec = k->security;
5275
5276 k->security = NULL;
5277 kfree(ksec);
5278}
5279
5280static int selinux_key_permission(key_ref_t key_ref,
David Howellsd84f4f92008-11-14 10:39:23 +11005281 const struct cred *cred,
5282 key_perm_t perm)
Michael LeMayd7200242006-06-22 14:47:17 -07005283{
5284 struct key *key;
Michael LeMayd7200242006-06-22 14:47:17 -07005285 struct key_security_struct *ksec;
David Howells275bb412008-11-14 10:39:19 +11005286 u32 sid;
Michael LeMayd7200242006-06-22 14:47:17 -07005287
5288 /* if no specific permissions are requested, we skip the
5289 permission check. No serious, additional covert channels
5290 appear to be created. */
5291 if (perm == 0)
5292 return 0;
5293
David Howellsd84f4f92008-11-14 10:39:23 +11005294 sid = cred_sid(cred);
David Howells275bb412008-11-14 10:39:19 +11005295
5296 key = key_ref_to_ptr(key_ref);
5297 ksec = key->security;
5298
5299 return avc_has_perm(sid, ksec->sid, SECCLASS_KEY, perm, NULL);
Michael LeMayd7200242006-06-22 14:47:17 -07005300}
5301
David Howells70a5bb72008-04-29 01:01:26 -07005302static int selinux_key_getsecurity(struct key *key, char **_buffer)
5303{
5304 struct key_security_struct *ksec = key->security;
5305 char *context = NULL;
5306 unsigned len;
5307 int rc;
5308
5309 rc = security_sid_to_context(ksec->sid, &context, &len);
5310 if (!rc)
5311 rc = len;
5312 *_buffer = context;
5313 return rc;
5314}
5315
Michael LeMayd7200242006-06-22 14:47:17 -07005316#endif
5317
Linus Torvalds1da177e2005-04-16 15:20:36 -07005318static struct security_operations selinux_ops = {
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02005319 .name = "selinux",
5320
David Howells5cd9c582008-08-14 11:37:28 +01005321 .ptrace_may_access = selinux_ptrace_may_access,
5322 .ptrace_traceme = selinux_ptrace_traceme,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005323 .capget = selinux_capget,
David Howellsd84f4f92008-11-14 10:39:23 +11005324 .capset = selinux_capset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005325 .sysctl = selinux_sysctl,
5326 .capable = selinux_capable,
5327 .quotactl = selinux_quotactl,
5328 .quota_on = selinux_quota_on,
5329 .syslog = selinux_syslog,
5330 .vm_enough_memory = selinux_vm_enough_memory,
5331
5332 .netlink_send = selinux_netlink_send,
Eric Paris828dfe12008-04-17 13:17:49 -04005333 .netlink_recv = selinux_netlink_recv,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005334
David Howellsa6f76f22008-11-14 10:39:24 +11005335 .bprm_set_creds = selinux_bprm_set_creds,
David Howellsa6f76f22008-11-14 10:39:24 +11005336 .bprm_committing_creds = selinux_bprm_committing_creds,
5337 .bprm_committed_creds = selinux_bprm_committed_creds,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005338 .bprm_secureexec = selinux_bprm_secureexec,
5339
5340 .sb_alloc_security = selinux_sb_alloc_security,
5341 .sb_free_security = selinux_sb_free_security,
5342 .sb_copy_data = selinux_sb_copy_data,
Eric Paris828dfe12008-04-17 13:17:49 -04005343 .sb_kern_mount = selinux_sb_kern_mount,
Eric Paris2069f452008-07-04 09:47:13 +10005344 .sb_show_options = selinux_sb_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005345 .sb_statfs = selinux_sb_statfs,
5346 .sb_mount = selinux_mount,
5347 .sb_umount = selinux_umount,
Eric Parisc9180a52007-11-30 13:00:35 -05005348 .sb_set_mnt_opts = selinux_set_mnt_opts,
Eric Paris828dfe12008-04-17 13:17:49 -04005349 .sb_clone_mnt_opts = selinux_sb_clone_mnt_opts,
Eric Parise0007522008-03-05 10:31:54 -05005350 .sb_parse_opts_str = selinux_parse_opts_str,
5351
Linus Torvalds1da177e2005-04-16 15:20:36 -07005352
5353 .inode_alloc_security = selinux_inode_alloc_security,
5354 .inode_free_security = selinux_inode_free_security,
Stephen Smalley5e41ff92005-09-09 13:01:35 -07005355 .inode_init_security = selinux_inode_init_security,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005356 .inode_create = selinux_inode_create,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005357 .inode_link = selinux_inode_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005358 .inode_unlink = selinux_inode_unlink,
5359 .inode_symlink = selinux_inode_symlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005360 .inode_mkdir = selinux_inode_mkdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005361 .inode_rmdir = selinux_inode_rmdir,
5362 .inode_mknod = selinux_inode_mknod,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005363 .inode_rename = selinux_inode_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005364 .inode_readlink = selinux_inode_readlink,
5365 .inode_follow_link = selinux_inode_follow_link,
5366 .inode_permission = selinux_inode_permission,
5367 .inode_setattr = selinux_inode_setattr,
5368 .inode_getattr = selinux_inode_getattr,
5369 .inode_setxattr = selinux_inode_setxattr,
5370 .inode_post_setxattr = selinux_inode_post_setxattr,
5371 .inode_getxattr = selinux_inode_getxattr,
5372 .inode_listxattr = selinux_inode_listxattr,
5373 .inode_removexattr = selinux_inode_removexattr,
Eric Paris828dfe12008-04-17 13:17:49 -04005374 .inode_getsecurity = selinux_inode_getsecurity,
5375 .inode_setsecurity = selinux_inode_setsecurity,
5376 .inode_listsecurity = selinux_inode_listsecurity,
Eric Parisf5269712008-05-14 11:27:45 -04005377 .inode_getsecid = selinux_inode_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005378
5379 .file_permission = selinux_file_permission,
5380 .file_alloc_security = selinux_file_alloc_security,
5381 .file_free_security = selinux_file_free_security,
5382 .file_ioctl = selinux_file_ioctl,
5383 .file_mmap = selinux_file_mmap,
5384 .file_mprotect = selinux_file_mprotect,
5385 .file_lock = selinux_file_lock,
5386 .file_fcntl = selinux_file_fcntl,
5387 .file_set_fowner = selinux_file_set_fowner,
5388 .file_send_sigiotask = selinux_file_send_sigiotask,
5389 .file_receive = selinux_file_receive,
5390
Eric Paris828dfe12008-04-17 13:17:49 -04005391 .dentry_open = selinux_dentry_open,
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09005392
Linus Torvalds1da177e2005-04-16 15:20:36 -07005393 .task_create = selinux_task_create,
David Howellsf1752ee2008-11-14 10:39:17 +11005394 .cred_free = selinux_cred_free,
David Howellsd84f4f92008-11-14 10:39:23 +11005395 .cred_prepare = selinux_cred_prepare,
David Howells3a3b7ce2008-11-14 10:39:28 +11005396 .kernel_act_as = selinux_kernel_act_as,
5397 .kernel_create_files_as = selinux_kernel_create_files_as,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005398 .task_setpgid = selinux_task_setpgid,
5399 .task_getpgid = selinux_task_getpgid,
Eric Paris828dfe12008-04-17 13:17:49 -04005400 .task_getsid = selinux_task_getsid,
David Quigleyf9008e42006-06-30 01:55:46 -07005401 .task_getsecid = selinux_task_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005402 .task_setnice = selinux_task_setnice,
James Morris03e68062006-06-23 02:03:58 -07005403 .task_setioprio = selinux_task_setioprio,
David Quigleya1836a42006-06-30 01:55:49 -07005404 .task_getioprio = selinux_task_getioprio,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005405 .task_setrlimit = selinux_task_setrlimit,
5406 .task_setscheduler = selinux_task_setscheduler,
5407 .task_getscheduler = selinux_task_getscheduler,
David Quigley35601542006-06-23 02:04:01 -07005408 .task_movememory = selinux_task_movememory,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005409 .task_kill = selinux_task_kill,
5410 .task_wait = selinux_task_wait,
Eric Paris828dfe12008-04-17 13:17:49 -04005411 .task_to_inode = selinux_task_to_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005412
5413 .ipc_permission = selinux_ipc_permission,
Eric Parisf5269712008-05-14 11:27:45 -04005414 .ipc_getsecid = selinux_ipc_getsecid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005415
5416 .msg_msg_alloc_security = selinux_msg_msg_alloc_security,
5417 .msg_msg_free_security = selinux_msg_msg_free_security,
5418
5419 .msg_queue_alloc_security = selinux_msg_queue_alloc_security,
5420 .msg_queue_free_security = selinux_msg_queue_free_security,
5421 .msg_queue_associate = selinux_msg_queue_associate,
5422 .msg_queue_msgctl = selinux_msg_queue_msgctl,
5423 .msg_queue_msgsnd = selinux_msg_queue_msgsnd,
5424 .msg_queue_msgrcv = selinux_msg_queue_msgrcv,
5425
5426 .shm_alloc_security = selinux_shm_alloc_security,
5427 .shm_free_security = selinux_shm_free_security,
5428 .shm_associate = selinux_shm_associate,
5429 .shm_shmctl = selinux_shm_shmctl,
5430 .shm_shmat = selinux_shm_shmat,
5431
Eric Paris828dfe12008-04-17 13:17:49 -04005432 .sem_alloc_security = selinux_sem_alloc_security,
5433 .sem_free_security = selinux_sem_free_security,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005434 .sem_associate = selinux_sem_associate,
5435 .sem_semctl = selinux_sem_semctl,
5436 .sem_semop = selinux_sem_semop,
5437
Eric Paris828dfe12008-04-17 13:17:49 -04005438 .d_instantiate = selinux_d_instantiate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005439
Eric Paris828dfe12008-04-17 13:17:49 -04005440 .getprocattr = selinux_getprocattr,
5441 .setprocattr = selinux_setprocattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005442
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005443 .secid_to_secctx = selinux_secid_to_secctx,
David Howells63cb3442008-01-15 23:47:35 +00005444 .secctx_to_secid = selinux_secctx_to_secid,
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07005445 .release_secctx = selinux_release_secctx,
5446
Eric Paris828dfe12008-04-17 13:17:49 -04005447 .unix_stream_connect = selinux_socket_unix_stream_connect,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005448 .unix_may_send = selinux_socket_unix_may_send,
5449
5450 .socket_create = selinux_socket_create,
5451 .socket_post_create = selinux_socket_post_create,
5452 .socket_bind = selinux_socket_bind,
5453 .socket_connect = selinux_socket_connect,
5454 .socket_listen = selinux_socket_listen,
5455 .socket_accept = selinux_socket_accept,
5456 .socket_sendmsg = selinux_socket_sendmsg,
5457 .socket_recvmsg = selinux_socket_recvmsg,
5458 .socket_getsockname = selinux_socket_getsockname,
5459 .socket_getpeername = selinux_socket_getpeername,
5460 .socket_getsockopt = selinux_socket_getsockopt,
5461 .socket_setsockopt = selinux_socket_setsockopt,
5462 .socket_shutdown = selinux_socket_shutdown,
5463 .socket_sock_rcv_skb = selinux_socket_sock_rcv_skb,
Catherine Zhang2c7946a2006-03-20 22:41:23 -08005464 .socket_getpeersec_stream = selinux_socket_getpeersec_stream,
5465 .socket_getpeersec_dgram = selinux_socket_getpeersec_dgram,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005466 .sk_alloc_security = selinux_sk_alloc_security,
5467 .sk_free_security = selinux_sk_free_security,
Venkat Yekkirala892c1412006-08-04 23:08:56 -07005468 .sk_clone_security = selinux_sk_clone_security,
Eric Paris828dfe12008-04-17 13:17:49 -04005469 .sk_getsecid = selinux_sk_getsecid,
Venkat Yekkirala4237c752006-07-24 23:32:50 -07005470 .sock_graft = selinux_sock_graft,
5471 .inet_conn_request = selinux_inet_conn_request,
5472 .inet_csk_clone = selinux_inet_csk_clone,
Venkat Yekkirala6b877692006-11-08 17:04:09 -06005473 .inet_conn_established = selinux_inet_conn_established,
Venkat Yekkirala4237c752006-07-24 23:32:50 -07005474 .req_classify_flow = selinux_req_classify_flow,
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005475
5476#ifdef CONFIG_SECURITY_NETWORK_XFRM
5477 .xfrm_policy_alloc_security = selinux_xfrm_policy_alloc,
5478 .xfrm_policy_clone_security = selinux_xfrm_policy_clone,
5479 .xfrm_policy_free_security = selinux_xfrm_policy_free,
Catherine Zhangc8c05a82006-06-08 23:39:49 -07005480 .xfrm_policy_delete_security = selinux_xfrm_policy_delete,
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005481 .xfrm_state_alloc_security = selinux_xfrm_state_alloc,
5482 .xfrm_state_free_security = selinux_xfrm_state_free,
Catherine Zhangc8c05a82006-06-08 23:39:49 -07005483 .xfrm_state_delete_security = selinux_xfrm_state_delete,
Eric Paris828dfe12008-04-17 13:17:49 -04005484 .xfrm_policy_lookup = selinux_xfrm_policy_lookup,
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07005485 .xfrm_state_pol_flow_match = selinux_xfrm_state_pol_flow_match,
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07005486 .xfrm_decode_session = selinux_xfrm_decode_session,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005487#endif
Michael LeMayd7200242006-06-22 14:47:17 -07005488
5489#ifdef CONFIG_KEYS
Eric Paris828dfe12008-04-17 13:17:49 -04005490 .key_alloc = selinux_key_alloc,
5491 .key_free = selinux_key_free,
5492 .key_permission = selinux_key_permission,
David Howells70a5bb72008-04-29 01:01:26 -07005493 .key_getsecurity = selinux_key_getsecurity,
Michael LeMayd7200242006-06-22 14:47:17 -07005494#endif
Ahmed S. Darwish9d57a7f2008-03-01 22:03:14 +02005495
5496#ifdef CONFIG_AUDIT
5497 .audit_rule_init = selinux_audit_rule_init,
5498 .audit_rule_known = selinux_audit_rule_known,
5499 .audit_rule_match = selinux_audit_rule_match,
5500 .audit_rule_free = selinux_audit_rule_free,
5501#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07005502};
5503
5504static __init int selinux_init(void)
5505{
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02005506 if (!security_module_enable(&selinux_ops)) {
5507 selinux_enabled = 0;
5508 return 0;
5509 }
5510
Linus Torvalds1da177e2005-04-16 15:20:36 -07005511 if (!selinux_enabled) {
5512 printk(KERN_INFO "SELinux: Disabled at boot.\n");
5513 return 0;
5514 }
5515
5516 printk(KERN_INFO "SELinux: Initializing.\n");
5517
5518 /* Set the security state for the initial task. */
David Howellsd84f4f92008-11-14 10:39:23 +11005519 cred_init_security();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005520
James Morris7cae7e22006-03-22 00:09:22 -08005521 sel_inode_cache = kmem_cache_create("selinux_inode_security",
5522 sizeof(struct inode_security_struct),
Paul Mundt20c2df82007-07-20 10:11:58 +09005523 0, SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005524 avc_init();
5525
James Morris6f0f0fd2008-07-10 17:02:07 +09005526 secondary_ops = security_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005527 if (!secondary_ops)
Eric Paris828dfe12008-04-17 13:17:49 -04005528 panic("SELinux: No initial security operations\n");
5529 if (register_security(&selinux_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005530 panic("SELinux: Unable to register with kernel.\n");
5531
Eric Paris828dfe12008-04-17 13:17:49 -04005532 if (selinux_enforcing)
Eric Parisfadcdb42007-02-22 18:11:31 -05005533 printk(KERN_DEBUG "SELinux: Starting in enforcing mode\n");
Eric Paris828dfe12008-04-17 13:17:49 -04005534 else
Eric Parisfadcdb42007-02-22 18:11:31 -05005535 printk(KERN_DEBUG "SELinux: Starting in permissive mode\n");
Michael LeMayd7200242006-06-22 14:47:17 -07005536
Linus Torvalds1da177e2005-04-16 15:20:36 -07005537 return 0;
5538}
5539
5540void selinux_complete_init(void)
5541{
Eric Parisfadcdb42007-02-22 18:11:31 -05005542 printk(KERN_DEBUG "SELinux: Completing initialization.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005543
5544 /* Set up any superblocks initialized prior to the policy load. */
Eric Parisfadcdb42007-02-22 18:11:31 -05005545 printk(KERN_DEBUG "SELinux: Setting up existing superblocks.\n");
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005546 spin_lock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005547 spin_lock(&sb_security_lock);
5548next_sb:
5549 if (!list_empty(&superblock_security_head)) {
5550 struct superblock_security_struct *sbsec =
5551 list_entry(superblock_security_head.next,
Eric Paris828dfe12008-04-17 13:17:49 -04005552 struct superblock_security_struct,
5553 list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005554 struct super_block *sb = sbsec->sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005555 sb->s_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005556 spin_unlock(&sb_security_lock);
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005557 spin_unlock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005558 down_read(&sb->s_umount);
5559 if (sb->s_root)
5560 superblock_doinit(sb, NULL);
5561 drop_super(sb);
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005562 spin_lock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005563 spin_lock(&sb_security_lock);
5564 list_del_init(&sbsec->list);
5565 goto next_sb;
5566 }
5567 spin_unlock(&sb_security_lock);
Stephen Smalleyba0c19e2006-06-04 02:51:30 -07005568 spin_unlock(&sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005569}
5570
5571/* SELinux requires early initialization in order to label
5572 all processes and objects when they are created. */
5573security_initcall(selinux_init);
5574
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005575#if defined(CONFIG_NETFILTER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005576
Paul Mooreeffad8d2008-01-29 08:49:27 -05005577static struct nf_hook_ops selinux_ipv4_ops[] = {
5578 {
5579 .hook = selinux_ipv4_postroute,
5580 .owner = THIS_MODULE,
5581 .pf = PF_INET,
5582 .hooknum = NF_INET_POST_ROUTING,
5583 .priority = NF_IP_PRI_SELINUX_LAST,
5584 },
5585 {
5586 .hook = selinux_ipv4_forward,
5587 .owner = THIS_MODULE,
5588 .pf = PF_INET,
5589 .hooknum = NF_INET_FORWARD,
5590 .priority = NF_IP_PRI_SELINUX_FIRST,
Paul Moore948bf852008-10-10 10:16:32 -04005591 },
5592 {
5593 .hook = selinux_ipv4_output,
5594 .owner = THIS_MODULE,
5595 .pf = PF_INET,
5596 .hooknum = NF_INET_LOCAL_OUT,
5597 .priority = NF_IP_PRI_SELINUX_FIRST,
Paul Mooreeffad8d2008-01-29 08:49:27 -05005598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005599};
5600
5601#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5602
Paul Mooreeffad8d2008-01-29 08:49:27 -05005603static struct nf_hook_ops selinux_ipv6_ops[] = {
5604 {
5605 .hook = selinux_ipv6_postroute,
5606 .owner = THIS_MODULE,
5607 .pf = PF_INET6,
5608 .hooknum = NF_INET_POST_ROUTING,
5609 .priority = NF_IP6_PRI_SELINUX_LAST,
5610 },
5611 {
5612 .hook = selinux_ipv6_forward,
5613 .owner = THIS_MODULE,
5614 .pf = PF_INET6,
5615 .hooknum = NF_INET_FORWARD,
5616 .priority = NF_IP6_PRI_SELINUX_FIRST,
5617 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005618};
5619
5620#endif /* IPV6 */
5621
5622static int __init selinux_nf_ip_init(void)
5623{
5624 int err = 0;
5625
5626 if (!selinux_enabled)
5627 goto out;
Eric Parisfadcdb42007-02-22 18:11:31 -05005628
5629 printk(KERN_DEBUG "SELinux: Registering netfilter hooks\n");
5630
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005631 err = nf_register_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5632 if (err)
5633 panic("SELinux: nf_register_hooks for IPv4: error %d\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005634
5635#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005636 err = nf_register_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5637 if (err)
5638 panic("SELinux: nf_register_hooks for IPv6: error %d\n", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005639#endif /* IPV6 */
Trent Jaegerd28d1e02005-12-13 23:12:40 -08005640
Linus Torvalds1da177e2005-04-16 15:20:36 -07005641out:
5642 return err;
5643}
5644
5645__initcall(selinux_nf_ip_init);
5646
5647#ifdef CONFIG_SECURITY_SELINUX_DISABLE
5648static void selinux_nf_ip_exit(void)
5649{
Eric Parisfadcdb42007-02-22 18:11:31 -05005650 printk(KERN_DEBUG "SELinux: Unregistering netfilter hooks\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005651
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005652 nf_unregister_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005653#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Alexey Dobriyan6c5a9d22008-07-26 17:48:15 -07005654 nf_unregister_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005655#endif /* IPV6 */
5656}
5657#endif
5658
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005659#else /* CONFIG_NETFILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005660
5661#ifdef CONFIG_SECURITY_SELINUX_DISABLE
5662#define selinux_nf_ip_exit()
5663#endif
5664
Stephen Smalleyc2b507f2006-02-04 23:27:50 -08005665#endif /* CONFIG_NETFILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005666
5667#ifdef CONFIG_SECURITY_SELINUX_DISABLE
Eric Paris828dfe12008-04-17 13:17:49 -04005668static int selinux_disabled;
5669
Linus Torvalds1da177e2005-04-16 15:20:36 -07005670int selinux_disable(void)
5671{
5672 extern void exit_sel_fs(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005673
5674 if (ss_initialized) {
5675 /* Not permitted after initial policy load. */
5676 return -EINVAL;
5677 }
5678
5679 if (selinux_disabled) {
5680 /* Only do this once. */
5681 return -EINVAL;
5682 }
5683
5684 printk(KERN_INFO "SELinux: Disabled at runtime.\n");
5685
5686 selinux_disabled = 1;
Stephen Smalley30d55282006-05-03 10:52:36 -04005687 selinux_enabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005688
5689 /* Reset security_ops to the secondary module, dummy or capability. */
5690 security_ops = secondary_ops;
5691
5692 /* Unregister netfilter hooks. */
5693 selinux_nf_ip_exit();
5694
5695 /* Unregister selinuxfs. */
5696 exit_sel_fs();
5697
5698 return 0;
5699}
5700#endif