OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
linux/security/seclvl.c

671 lines
17 KiB
C
Raw Blame History

/**
* BSD Secure Levels LSM
*
* Maintainers:
* Michael A. Halcrow <mike@halcrow.us>
* Serge Hallyn <hallyn@cs.wm.edu>
*
* Copyright (c) 2001 WireX Communications, Inc <chris@wirex.com>
* Copyright (c) 2001 Greg Kroah-Hartman <greg@kroah.com>
* Copyright (c) 2002 International Business Machines <robb@austin.ibm.com>
* Copyright (c) 2006 Davi E. M. Arnaut <davi.arnaut@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/config.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/security.h>
#include <linux/netlink.h>
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/capability.h>
#include <linux/time.h>
#include <linux/proc_fs.h>
#include <linux/kobject.h>
#include <linux/crypto.h>
#include <asm/scatterlist.h>
#include <linux/scatterlist.h>
#include <linux/gfp.h>
#include <linux/sysfs.h>
#define SHA1_DIGEST_SIZE 20
/**
* Module parameter that defines the initial secure level.
*
* When built as a module, it defaults to seclvl 1, which is the
* behavior of BSD secure levels. Note that this default behavior
* wrecks havoc on a machine when the seclvl module is compiled into
* the kernel. In that case, we default to seclvl 0.
*/
#ifdef CONFIG_SECURITY_SECLVL_MODULE
static int initlvl = 1;
#else
static int initlvl;
#endif
module_param(initlvl, int, 0);
MODULE_PARM_DESC(initlvl, "Initial secure level (defaults to 1)");
/* Module parameter that defines the verbosity level */
static int verbosity;
module_param(verbosity, int, 0);
MODULE_PARM_DESC(verbosity, "Initial verbosity level (0 or 1; defaults to "
"0, which is Quiet)");
/**
* Optional password which can be passed in to bring seclvl to 0
* (i.e., for halt/reboot). Defaults to NULL (the passwd attribute
* file will not be registered in sysfs).
*
* This gets converted to its SHA1 hash when stored. It's probably
* not a good idea to use this parameter when loading seclvl from a
* script; use sha1_passwd instead.
*/
#define MAX_PASSWD_SIZE 32
static char passwd[MAX_PASSWD_SIZE];
module_param_string(passwd, passwd, sizeof(passwd), 0);
MODULE_PARM_DESC(passwd,
"Plaintext of password that sets seclvl=0 when written to "
"(sysfs mount point)/seclvl/passwd\n");
/**
* SHA1 hashed version of the optional password which can be passed in
* to bring seclvl to 0 (i.e., for halt/reboot). Must be in
* hexadecimal format (40 characters). Defaults to NULL (the passwd
* attribute file will not be registered in sysfs).
*
* Use the sha1sum utility to generate the SHA1 hash of a password:
*
* echo -n "secret" | sha1sum
*/
#define MAX_SHA1_PASSWD 41
static char sha1_passwd[MAX_SHA1_PASSWD];
module_param_string(sha1_passwd, sha1_passwd, sizeof(sha1_passwd), 0);
MODULE_PARM_DESC(sha1_passwd,
"SHA1 hash (40 hexadecimal characters) of password that "
"sets seclvl=0 when plaintext password is written to "
"(sysfs mount point)/seclvl/passwd\n");
static int hideHash = 1;
module_param(hideHash, int, 0);
MODULE_PARM_DESC(hideHash, "When set to 0, reading seclvl/passwd from sysfs "
"will return the SHA1-hashed value of the password that "
"lowers the secure level to 0.\n");
#define MY_NAME "seclvl"
/**
* This time-limits log writes to one per second.
*/
#define seclvl_printk(verb, type, fmt, arg...) \
do { \
if (verbosity >= verb) { \
static unsigned long _prior; \
unsigned long _now = jiffies; \
if ((_now - _prior) > HZ) { \
printk(type "%s: %s: " fmt, \
MY_NAME, __FUNCTION__ , \
## arg); \
_prior = _now; \
} \
} \
} while (0)
/**
* The actual security level. Ranges between -1 and 2 inclusive.
*/
static int seclvl;
/**
* flag to keep track of how we were registered
*/
static int secondary;
/**
* Verifies that the requested secure level is valid, given the current
* secure level.
*/
static int seclvl_sanity(int reqlvl)
{
if ((reqlvl < -1) || (reqlvl > 2)) {
seclvl_printk(1, KERN_WARNING, "Attempt to set seclvl out of "
"range: [%d]\n", reqlvl);
return -EINVAL;
}
if ((seclvl == 0) && (reqlvl == -1))
return 0;
if (reqlvl < seclvl) {
seclvl_printk(1, KERN_WARNING, "Attempt to lower seclvl to "
"[%d]\n", reqlvl);
return -EPERM;
}
return 0;
}
/**
* security level advancement rules:
* Valid levels are -1 through 2, inclusive.
* From -1, stuck. [ in case compiled into kernel ]
* From 0 or above, can only increment.
*/
static void do_seclvl_advance(void *data, u64 val)
{
int ret;
int newlvl = (int)val;
ret = seclvl_sanity(newlvl);
if (ret)
return;
if (newlvl > 2) {
seclvl_printk(1, KERN_WARNING, "Cannot advance to seclvl "
"[%d]\n", newlvl);
return;
}
if (seclvl == -1) {
seclvl_printk(1, KERN_WARNING, "Not allowed to advance to "
"seclvl [%d]\n", seclvl);
return;
}
seclvl = newlvl; /* would it be more "correct" to set *data? */
return;
}
static u64 seclvl_int_get(void *data)
{
return *(int *)data;
}
DEFINE_SIMPLE_ATTRIBUTE(seclvl_file_ops, seclvl_int_get, do_seclvl_advance, "%lld\n");
static unsigned char hashedPassword[SHA1_DIGEST_SIZE];
/**
* Converts a block of plaintext of into its SHA1 hashed value.
*
* It would be nice if crypto had a wrapper to do this for us linear
* people...
*/
static int
plaintext_to_sha1(unsigned char *hash, const char *plaintext, unsigned int len)
{
struct crypto_tfm *tfm;
struct scatterlist sg;
if (len > PAGE_SIZE) {
seclvl_printk(0, KERN_ERR, "Plaintext password too large (%d "
"characters). Largest possible is %lu "
"bytes.\n", len, PAGE_SIZE);
return -EINVAL;
}
tfm = crypto_alloc_tfm("sha1", CRYPTO_TFM_REQ_MAY_SLEEP);
if (tfm == NULL) {
seclvl_printk(0, KERN_ERR,
"Failed to load transform for SHA1\n");
return -EINVAL;
}
sg_init_one(&sg, (u8 *)plaintext, len);
crypto_digest_init(tfm);
crypto_digest_update(tfm, &sg, 1);
crypto_digest_final(tfm, hash);
crypto_free_tfm(tfm);
return 0;
}
/**
* Called whenever the user writes to the sysfs passwd handle to this kernel
* object. It hashes the password and compares the hashed results.
*/
static ssize_t
passwd_write_file(struct file * file, const char __user * buf,
size_t count, loff_t *ppos)
{
char *p;
int len;
unsigned char tmp[SHA1_DIGEST_SIZE];
if (!*passwd && !*sha1_passwd) {
seclvl_printk(0, KERN_ERR, "Attempt to password-unlock the "
"seclvl module, but neither a plain text "
"password nor a SHA1 hashed password was "
"passed in as a module parameter! This is a "
"bug, since it should not be possible to be in "
"this part of the module; please tell a "
"maintainer about this event.\n");
return -EINVAL;
}
if (count >= PAGE_SIZE)
return -EINVAL;
if (*ppos != 0)
return -EINVAL;
p = kmalloc(count, GFP_KERNEL);
if (!p)
return -ENOMEM;
len = -EFAULT;
if (copy_from_user(p, buf, count))
goto out;
len = count;
/* ``echo "secret" > seclvl/passwd'' includes a newline */
if (p[len - 1] == '\n')
len--;
/* Hash the password, then compare the hashed values */
if ((len = plaintext_to_sha1(tmp, p, len))) {
seclvl_printk(0, KERN_ERR, "Error hashing password: rc = "
"[%d]\n", len);
goto out;
}
len = -EPERM;
if (memcmp(hashedPassword, tmp, SHA1_DIGEST_SIZE))
goto out;
seclvl_printk(0, KERN_INFO,
"Password accepted; seclvl reduced to 0.\n");
seclvl = 0;
len = count;
out:
kfree (p);
return len;
}
static struct file_operations passwd_file_ops = {
.write = passwd_write_file,
};
/**
* Explicitely disallow ptrace'ing the init process.
*/
static int seclvl_ptrace(struct task_struct *parent, struct task_struct *child)
{
if (seclvl >= 0 && child->pid == 1) {
seclvl_printk(1, KERN_WARNING, "Attempt to ptrace "
"the init process dissallowed in "
"secure level %d\n", seclvl);
return -EPERM;
}
return 0;
}
/**
* Capability checks for seclvl. The majority of the policy
* enforcement for seclvl takes place here.
*/
static int seclvl_capable(struct task_struct *tsk, int cap)
{
int rc = 0;
/* init can do anything it wants */
if (tsk->pid == 1)
return 0;
if (seclvl > 0) {
rc = -EPERM;
if (cap == CAP_LINUX_IMMUTABLE)
seclvl_printk(1, KERN_WARNING, "Attempt to modify "
"the IMMUTABLE and/or APPEND extended "
"attribute on a file with the IMMUTABLE "
"and/or APPEND extended attribute set "
"denied in seclvl [%d]\n", seclvl);
else if (cap == CAP_SYS_RAWIO)
seclvl_printk(1, KERN_WARNING, "Attempt to perform "
"raw I/O while in secure level [%d] "
"denied\n", seclvl);
else if (cap == CAP_NET_ADMIN)
seclvl_printk(1, KERN_WARNING, "Attempt to perform "
"network administrative task while "
"in secure level [%d] denied\n", seclvl);
else if (cap == CAP_SETUID)
seclvl_printk(1, KERN_WARNING, "Attempt to setuid "
"while in secure level [%d] denied\n",
seclvl);
else if (cap == CAP_SETGID)
seclvl_printk(1, KERN_WARNING, "Attempt to setgid "
"while in secure level [%d] denied\n",
seclvl);
else if (cap == CAP_SYS_MODULE)
seclvl_printk(1, KERN_WARNING, "Attempt to perform "
"a module operation while in secure "
"level [%d] denied\n", seclvl);
else
rc = 0;
}
if (!rc) {
if (!(cap_is_fs_cap(cap) ? tsk->fsuid == 0 : tsk->euid == 0))
rc = -EPERM;
}
if (rc)
seclvl_printk(1, KERN_WARNING, "Capability denied\n");
return rc;
}
/**
* Disallow reversing the clock in seclvl > 1
*/
static int seclvl_settime(struct timespec *tv, struct timezone *tz)
{
if (tv && seclvl > 1) {
struct timespec now;
now = current_kernel_time();
if (tv->tv_sec < now.tv_sec ||
(tv->tv_sec == now.tv_sec && tv->tv_nsec < now.tv_nsec)) {
seclvl_printk(1, KERN_WARNING, "Attempt to decrement "
"time in secure level %d denied: "
"current->pid = [%d], "
"current->group_leader->pid = [%d]\n",
seclvl, current->pid,
current->group_leader->pid);
return -EPERM;
} /* if attempt to decrement time */
} /* if seclvl > 1 */
return 0;
}
/* claim the blockdev to exclude mounters, release on file close */
static int seclvl_bd_claim(struct inode *inode)
{
int holder;
struct block_device *bdev = NULL;
dev_t dev = inode->i_rdev;
bdev = open_by_devnum(dev, FMODE_WRITE);
if (bdev) {
if (bd_claim(bdev, &holder)) {
blkdev_put(bdev);
return -EPERM;
}
/* claimed, mark it to release on close */
inode->i_security = current;
}
return 0;
}
/* release the blockdev if you claimed it */
static void seclvl_bd_release(struct inode *inode)
{
if (inode && S_ISBLK(inode->i_mode) && inode->i_security == current) {
struct block_device *bdev = inode->i_bdev;
if (bdev) {
bd_release(bdev);
blkdev_put(bdev);
inode->i_security = NULL;
}
}
}
/**
* Security for writes to block devices is regulated by this seclvl
* function. Deny all writes to block devices in seclvl 2. In
* seclvl 1, we only deny writes to *mounted* block devices.
*/
static int
seclvl_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
{
if (current->pid != 1 && S_ISBLK(inode->i_mode) && (mask & MAY_WRITE)) {
switch (seclvl) {
case 2:
seclvl_printk(1, KERN_WARNING, "Write to block device "
"denied in secure level [%d]\n", seclvl);
return -EPERM;
case 1:
if (seclvl_bd_claim(inode)) {
seclvl_printk(1, KERN_WARNING,
"Write to mounted block device "
"denied in secure level [%d]\n",
seclvl);
return -EPERM;
}
}
}
return 0;
}
/**
* The SUID and SGID bits cannot be set in seclvl >= 1
*/
static int seclvl_inode_setattr(struct dentry *dentry, struct iattr *iattr)
{
if (seclvl > 0) {
if (iattr->ia_valid & ATTR_MODE)
if (iattr->ia_mode & S_ISUID ||
iattr->ia_mode & S_ISGID) {
seclvl_printk(1, KERN_WARNING, "Attempt to "
"modify SUID or SGID bit "
"denied in seclvl [%d]\n",
seclvl);
return -EPERM;
}
}
return 0;
}
/* release busied block devices */
static void seclvl_file_free_security(struct file *filp)
{
struct dentry *dentry = filp->f_dentry;
if (dentry)
seclvl_bd_release(dentry->d_inode);
}
/**
* Cannot unmount in secure level 2
*/
static int seclvl_umount(struct vfsmount *mnt, int flags)
{
if (current->pid != 1 && seclvl == 2) {
seclvl_printk(1, KERN_WARNING, "Attempt to unmount in secure "
"level %d\n", seclvl);
return -EPERM;
}
return 0;
}
static struct security_operations seclvl_ops = {
.ptrace = seclvl_ptrace,
.capable = seclvl_capable,
.inode_permission = seclvl_inode_permission,
.inode_setattr = seclvl_inode_setattr,
.file_free_security = seclvl_file_free_security,
.settime = seclvl_settime,
.sb_umount = seclvl_umount,
};
/**
* Process the password-related module parameters
*/
static int processPassword(void)
{
int rc = 0;
if (*passwd) {
char *p;
if (*sha1_passwd) {
seclvl_printk(0, KERN_ERR, "Error: Both "
"passwd and sha1_passwd "
"were set, but they are mutually "
"exclusive.\n");
return -EINVAL;
}
p = kstrdup(passwd, GFP_KERNEL);
if (p == NULL)
return -ENOMEM;
if ((rc = plaintext_to_sha1(hashedPassword, p, strlen(p))))
seclvl_printk(0, KERN_ERR, "Error: SHA1 support not "
"in kernel\n");
kfree (p);
/* All static data goes to the BSS, which zero's the
* plaintext password out for us. */
} else if (*sha1_passwd) { // Base 16
int i;
i = strlen(sha1_passwd);
if (i != (SHA1_DIGEST_SIZE * 2)) {
seclvl_printk(0, KERN_ERR, "Received [%d] bytes; "
"expected [%d] for the hexadecimal "
"representation of the SHA1 hash of "
"the password.\n",
i, (SHA1_DIGEST_SIZE * 2));
return -EINVAL;
}
while ((i -= 2) + 2) {
unsigned char tmp;
tmp = sha1_passwd[i + 2];
sha1_passwd[i + 2] = '\0';
hashedPassword[i / 2] = (unsigned char)
simple_strtol(&sha1_passwd[i], NULL, 16);
sha1_passwd[i + 2] = tmp;
}
}
return rc;
}
/**
* securityfs registrations
*/
struct dentry *dir_ino, *seclvl_ino, *passwd_ino;
static int seclvlfs_register(void)
{
int rc = 0;
dir_ino = securityfs_create_dir("seclvl", NULL);
if (IS_ERR(dir_ino))
return PTR_ERR(dir_ino);
seclvl_ino = securityfs_create_file("seclvl", S_IRUGO | S_IWUSR,
dir_ino, &seclvl, &seclvl_file_ops);
if (IS_ERR(seclvl_ino)) {
rc = PTR_ERR(seclvl_ino);
goto out_deldir;
}
if (*passwd || *sha1_passwd) {
passwd_ino = securityfs_create_file("passwd", S_IRUGO | S_IWUSR,
dir_ino, NULL, &passwd_file_ops);
if (IS_ERR(passwd_ino)) {
rc = PTR_ERR(passwd_ino);
goto out_delf;
}
}
return rc;
out_delf:
securityfs_remove(seclvl_ino);
out_deldir:
securityfs_remove(dir_ino);
return rc;
}
static void seclvlfs_unregister(void)
{
securityfs_remove(seclvl_ino);
if (*passwd || *sha1_passwd)
securityfs_remove(passwd_ino);
securityfs_remove(dir_ino);
}
/**
* Initialize the seclvl module.
*/
static int __init seclvl_init(void)
{
int rc = 0;
static char once;
if (verbosity < 0 || verbosity > 1) {
printk(KERN_ERR "Error: bad verbosity [%d]; only 0 or 1 "
"are valid values\n", verbosity);
rc = -EINVAL;
goto exit;
}
if (initlvl < -1 || initlvl > 2) {
seclvl_printk(0, KERN_ERR, "Error: bad initial securelevel "
"[%d].\n", initlvl);
rc = -EINVAL;
goto exit;
}
seclvl = initlvl;
if ((rc = processPassword())) {
seclvl_printk(0, KERN_ERR, "Error processing the password "
"module parameter(s): rc = [%d]\n", rc);
goto exit;
}
if ((rc = seclvlfs_register())) {
seclvl_printk(0, KERN_ERR, "Error registering with sysfs\n");
goto exit;
}
/* register ourselves with the security framework */
if (register_security(&seclvl_ops)) {
seclvl_printk(0, KERN_ERR,
"seclvl: Failure registering with the "
"kernel.\n");
/* try registering with primary module */
rc = mod_reg_security(MY_NAME, &seclvl_ops);
if (rc) {
seclvl_printk(0, KERN_ERR, "seclvl: Failure "
"registering with primary security "
"module.\n");
seclvlfs_unregister();
goto exit;
} /* if primary module registered */
secondary = 1;
} /* if we registered ourselves with the security framework */
seclvl_printk(0, KERN_INFO, "seclvl: Successfully initialized.\n");
if (once) {
once = 1;
seclvl_printk(0, KERN_INFO, "seclvl is going away. It has been "
"buggy for ages. Also, be warned that "
"Securelevels are useless.");
}
exit:
if (rc)
printk(KERN_ERR "seclvl: Error during initialization: rc = "
"[%d]\n", rc);
return rc;
}
/**
* Remove the seclvl module.
*/
static void __exit seclvl_exit(void)
{
seclvlfs_unregister();
if (secondary)
mod_unreg_security(MY_NAME, &seclvl_ops);
else if (unregister_security(&seclvl_ops))
seclvl_printk(0, KERN_INFO,
"seclvl: Failure unregistering with the "
"kernel\n");
}
module_init(seclvl_init);
module_exit(seclvl_exit);
MODULE_AUTHOR("Michael A. Halcrow <mike@halcrow.us>");
MODULE_DESCRIPTION("LSM implementation of the BSD Secure Levels");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink