2 * BSD Secure Levels LSM
5 * Michael A. Halcrow <mike@halcrow.us>
6 * Serge Hallyn <hallyn@cs.wm.edu>
8 * Copyright (c) 2001 WireX Communications, Inc <chris@wirex.com>
9 * Copyright (c) 2001 Greg Kroah-Hartman <greg@kroah.com>
10 * Copyright (c) 2002 International Business Machines <robb@austin.ibm.com>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
18 #include <linux/config.h>
19 #include <linux/module.h>
20 #include <linux/moduleparam.h>
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/security.h>
24 #include <linux/netlink.h>
26 #include <linux/namei.h>
27 #include <linux/mount.h>
28 #include <linux/capability.h>
29 #include <linux/time.h>
30 #include <linux/proc_fs.h>
31 #include <linux/kobject.h>
32 #include <linux/crypto.h>
33 #include <asm/scatterlist.h>
34 #include <linux/gfp.h>
35 #include <linux/sysfs.h>
37 #define SHA1_DIGEST_SIZE 20
40 * Module parameter that defines the initial secure level.
42 * When built as a module, it defaults to seclvl 1, which is the
43 * behavior of BSD secure levels. Note that this default behavior
44 * wrecks havoc on a machine when the seclvl module is compiled into
45 * the kernel. In that case, we default to seclvl 0.
47 #ifdef CONFIG_SECURITY_SECLVL_MODULE
48 static int initlvl
= 1;
52 module_param(initlvl
, int, 0);
53 MODULE_PARM_DESC(initlvl
, "Initial secure level (defaults to 1)");
55 /* Module parameter that defines the verbosity level */
57 module_param(verbosity
, int, 0);
58 MODULE_PARM_DESC(verbosity
, "Initial verbosity level (0 or 1; defaults to "
59 "0, which is Quiet)");
62 * Optional password which can be passed in to bring seclvl to 0
63 * (i.e., for halt/reboot). Defaults to NULL (the passwd attribute
64 * file will not be registered in sysfs).
66 * This gets converted to its SHA1 hash when stored. It's probably
67 * not a good idea to use this parameter when loading seclvl from a
68 * script; use sha1_passwd instead.
71 #define MAX_PASSWD_SIZE 32
72 static char passwd
[MAX_PASSWD_SIZE
];
73 module_param_string(passwd
, passwd
, sizeof(passwd
), 0);
74 MODULE_PARM_DESC(passwd
,
75 "Plaintext of password that sets seclvl=0 when written to "
76 "(sysfs mount point)/seclvl/passwd\n");
79 * SHA1 hashed version of the optional password which can be passed in
80 * to bring seclvl to 0 (i.e., for halt/reboot). Must be in
81 * hexadecimal format (40 characters). Defaults to NULL (the passwd
82 * attribute file will not be registered in sysfs).
84 * Use the sha1sum utility to generate the SHA1 hash of a password:
86 * echo -n "secret" | sha1sum
88 #define MAX_SHA1_PASSWD 41
89 static char sha1_passwd
[MAX_SHA1_PASSWD
];
90 module_param_string(sha1_passwd
, sha1_passwd
, sizeof(sha1_passwd
), 0);
91 MODULE_PARM_DESC(sha1_passwd
,
92 "SHA1 hash (40 hexadecimal characters) of password that "
93 "sets seclvl=0 when plaintext password is written to "
94 "(sysfs mount point)/seclvl/passwd\n");
96 static int hideHash
= 1;
97 module_param(hideHash
, int, 0);
98 MODULE_PARM_DESC(hideHash
, "When set to 0, reading seclvl/passwd from sysfs "
99 "will return the SHA1-hashed value of the password that "
100 "lowers the secure level to 0.\n");
102 #define MY_NAME "seclvl"
105 * This time-limits log writes to one per second.
107 #define seclvl_printk(verb, type, fmt, arg...) \
109 if (verbosity >= verb) { \
110 static unsigned long _prior; \
111 unsigned long _now = jiffies; \
112 if ((_now - _prior) > HZ) { \
113 printk(type "%s: %s: " fmt, \
114 MY_NAME, __FUNCTION__ , \
122 * The actual security level. Ranges between -1 and 2 inclusive.
127 * flag to keep track of how we were registered
129 static int secondary
;
132 * Verifies that the requested secure level is valid, given the current
135 static int seclvl_sanity(int reqlvl
)
137 if ((reqlvl
< -1) || (reqlvl
> 2)) {
138 seclvl_printk(1, KERN_WARNING
, "Attempt to set seclvl out of "
139 "range: [%d]\n", reqlvl
);
142 if ((seclvl
== 0) && (reqlvl
== -1))
144 if (reqlvl
< seclvl
) {
145 seclvl_printk(1, KERN_WARNING
, "Attempt to lower seclvl to "
153 * security level advancement rules:
154 * Valid levels are -1 through 2, inclusive.
155 * From -1, stuck. [ in case compiled into kernel ]
156 * From 0 or above, can only increment.
158 static void do_seclvl_advance(void *data
, u64 val
)
161 int newlvl
= (int)val
;
163 ret
= seclvl_sanity(newlvl
);
168 seclvl_printk(1, KERN_WARNING
, "Cannot advance to seclvl "
173 seclvl_printk(1, KERN_WARNING
, "Not allowed to advance to "
174 "seclvl [%d]\n", seclvl
);
177 seclvl
= newlvl
; /* would it be more "correct" to set *data? */
181 static u64
seclvl_int_get(void *data
)
186 DEFINE_SIMPLE_ATTRIBUTE(seclvl_file_ops
, seclvl_int_get
, do_seclvl_advance
, "%lld\n");
188 static unsigned char hashedPassword
[SHA1_DIGEST_SIZE
];
191 * Converts a block of plaintext of into its SHA1 hashed value.
193 * It would be nice if crypto had a wrapper to do this for us linear
197 plaintext_to_sha1(unsigned char *hash
, const char *plaintext
, int len
)
200 struct crypto_tfm
*tfm
;
201 struct scatterlist sg
[1];
202 if (len
> PAGE_SIZE
) {
203 seclvl_printk(0, KERN_ERR
, "Plaintext password too large (%d "
204 "characters). Largest possible is %lu "
205 "bytes.\n", len
, PAGE_SIZE
);
208 tfm
= crypto_alloc_tfm("sha1", CRYPTO_TFM_REQ_MAY_SLEEP
);
210 seclvl_printk(0, KERN_ERR
,
211 "Failed to load transform for SHA1\n");
214 // Just get a new page; don't play around with page boundaries
216 pgVirtAddr
= (char *)__get_free_page(GFP_KERNEL
);
217 sg
[0].page
= virt_to_page(pgVirtAddr
);
220 strncpy(pgVirtAddr
, plaintext
, len
);
221 crypto_digest_init(tfm
);
222 crypto_digest_update(tfm
, sg
, 1);
223 crypto_digest_final(tfm
, hash
);
224 crypto_free_tfm(tfm
);
225 free_page((unsigned long)pgVirtAddr
);
230 * Called whenever the user writes to the sysfs passwd handle to this kernel
231 * object. It hashes the password and compares the hashed results.
234 passwd_write_file(struct file
* file
, const char __user
* buf
,
235 size_t count
, loff_t
*ppos
)
238 unsigned char tmp
[SHA1_DIGEST_SIZE
];
243 if (!*passwd
&& !*sha1_passwd
) {
244 seclvl_printk(0, KERN_ERR
, "Attempt to password-unlock the "
245 "seclvl module, but neither a plain text "
246 "password nor a SHA1 hashed password was "
247 "passed in as a module parameter! This is a "
248 "bug, since it should not be possible to be in "
249 "this part of the module; please tell a "
250 "maintainer about this event.\n");
254 if (count
< 0 || count
>= PAGE_SIZE
)
259 page
= (char *)get_zeroed_page(GFP_KERNEL
);
263 if (copy_from_user(page
, buf
, count
))
267 /* ``echo "secret" > seclvl/passwd'' includes a newline */
268 if (page
[len
- 1] == '\n') {
271 /* Hash the password, then compare the hashed values */
272 if ((rc
= plaintext_to_sha1(tmp
, page
, len
))) {
273 seclvl_printk(0, KERN_ERR
, "Error hashing password: rc = "
277 for (i
= 0; i
< SHA1_DIGEST_SIZE
; i
++) {
278 if (hashedPassword
[i
] != tmp
[i
]) {
282 seclvl_printk(0, KERN_INFO
,
283 "Password accepted; seclvl reduced to 0.\n");
288 free_page((unsigned long)page
);
292 static struct file_operations passwd_file_ops
= {
293 .write
= passwd_write_file
,
297 * Explicitely disallow ptrace'ing the init process.
299 static int seclvl_ptrace(struct task_struct
*parent
, struct task_struct
*child
)
302 if (child
->pid
== 1) {
303 seclvl_printk(1, KERN_WARNING
, "Attempt to ptrace "
304 "the init process dissallowed in "
305 "secure level %d\n", seclvl
);
313 * Capability checks for seclvl. The majority of the policy
314 * enforcement for seclvl takes place here.
316 static int seclvl_capable(struct task_struct
*tsk
, int cap
)
318 /* init can do anything it wants */
326 if (cap
== CAP_LINUX_IMMUTABLE
) {
327 seclvl_printk(1, KERN_WARNING
, "Attempt to modify "
328 "the IMMUTABLE and/or APPEND extended "
329 "attribute on a file with the IMMUTABLE "
330 "and/or APPEND extended attribute set "
331 "denied in seclvl [%d]\n", seclvl
);
333 } else if (cap
== CAP_SYS_RAWIO
) { // Somewhat broad...
334 seclvl_printk(1, KERN_WARNING
, "Attempt to perform "
335 "raw I/O while in secure level [%d] "
338 } else if (cap
== CAP_NET_ADMIN
) {
339 seclvl_printk(1, KERN_WARNING
, "Attempt to perform "
340 "network administrative task while "
341 "in secure level [%d] denied\n", seclvl
);
343 } else if (cap
== CAP_SETUID
) {
344 seclvl_printk(1, KERN_WARNING
, "Attempt to setuid "
345 "while in secure level [%d] denied\n",
348 } else if (cap
== CAP_SETGID
) {
349 seclvl_printk(1, KERN_WARNING
, "Attempt to setgid "
350 "while in secure level [%d] denied\n",
352 } else if (cap
== CAP_SYS_MODULE
) {
353 seclvl_printk(1, KERN_WARNING
, "Attempt to perform "
354 "a module operation while in secure "
355 "level [%d] denied\n", seclvl
);
363 if (cap_is_fs_cap(cap
) ? tsk
->fsuid
== 0 : tsk
->euid
== 0)
364 return 0; /* capability granted */
365 seclvl_printk(1, KERN_WARNING
, "Capability denied\n");
366 return -EPERM
; /* capability denied */
370 * Disallow reversing the clock in seclvl > 1
372 static int seclvl_settime(struct timespec
*tv
, struct timezone
*tz
)
376 now
= current_kernel_time();
377 if (tv
->tv_sec
< now
.tv_sec
||
378 (tv
->tv_sec
== now
.tv_sec
&& tv
->tv_nsec
< now
.tv_nsec
)) {
379 seclvl_printk(1, KERN_WARNING
, "Attempt to decrement "
380 "time in secure level %d denied: "
381 "current->pid = [%d], "
382 "current->group_leader->pid = [%d]\n",
383 seclvl
, current
->pid
,
384 current
->group_leader
->pid
);
386 } /* if attempt to decrement time */
387 } /* if seclvl > 1 */
391 /* claim the blockdev to exclude mounters, release on file close */
392 static int seclvl_bd_claim(struct inode
*inode
)
395 struct block_device
*bdev
= NULL
;
396 dev_t dev
= inode
->i_rdev
;
397 bdev
= open_by_devnum(dev
, FMODE_WRITE
);
399 if (bd_claim(bdev
, &holder
)) {
403 /* claimed, mark it to release on close */
404 inode
->i_security
= current
;
409 /* release the blockdev if you claimed it */
410 static void seclvl_bd_release(struct inode
*inode
)
412 if (inode
&& S_ISBLK(inode
->i_mode
) && inode
->i_security
== current
) {
413 struct block_device
*bdev
= inode
->i_bdev
;
417 inode
->i_security
= NULL
;
423 * Security for writes to block devices is regulated by this seclvl
424 * function. Deny all writes to block devices in seclvl 2. In
425 * seclvl 1, we only deny writes to *mounted* block devices.
428 seclvl_inode_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
430 if (current
->pid
!= 1 && S_ISBLK(inode
->i_mode
) && (mask
& MAY_WRITE
)) {
433 seclvl_printk(1, KERN_WARNING
, "Write to block device "
434 "denied in secure level [%d]\n", seclvl
);
437 if (seclvl_bd_claim(inode
)) {
438 seclvl_printk(1, KERN_WARNING
,
439 "Write to mounted block device "
440 "denied in secure level [%d]\n",
450 * The SUID and SGID bits cannot be set in seclvl >= 1
452 static int seclvl_inode_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
455 if (iattr
->ia_valid
& ATTR_MODE
)
456 if (iattr
->ia_mode
& S_ISUID
||
457 iattr
->ia_mode
& S_ISGID
) {
458 seclvl_printk(1, KERN_WARNING
, "Attempt to "
459 "modify SUID or SGID bit "
460 "denied in seclvl [%d]\n",
468 /* release busied block devices */
469 static void seclvl_file_free_security(struct file
*filp
)
471 struct dentry
*dentry
= filp
->f_dentry
;
472 struct inode
*inode
= NULL
;
475 inode
= dentry
->d_inode
;
476 seclvl_bd_release(inode
);
481 * Cannot unmount in secure level 2
483 static int seclvl_umount(struct vfsmount
*mnt
, int flags
)
485 if (current
->pid
== 1) {
489 seclvl_printk(1, KERN_WARNING
, "Attempt to unmount in secure "
490 "level %d\n", seclvl
);
496 static struct security_operations seclvl_ops
= {
497 .ptrace
= seclvl_ptrace
,
498 .capable
= seclvl_capable
,
499 .inode_permission
= seclvl_inode_permission
,
500 .inode_setattr
= seclvl_inode_setattr
,
501 .file_free_security
= seclvl_file_free_security
,
502 .settime
= seclvl_settime
,
503 .sb_umount
= seclvl_umount
,
507 * Process the password-related module parameters
509 static int processPassword(void)
512 hashedPassword
[0] = '\0';
515 seclvl_printk(0, KERN_ERR
, "Error: Both "
516 "passwd and sha1_passwd "
517 "were set, but they are mutually "
521 if ((rc
= plaintext_to_sha1(hashedPassword
, passwd
,
523 seclvl_printk(0, KERN_ERR
, "Error: SHA1 support not "
527 /* All static data goes to the BSS, which zero's the
528 * plaintext password out for us. */
529 } else if (*sha1_passwd
) { // Base 16
531 i
= strlen(sha1_passwd
);
532 if (i
!= (SHA1_DIGEST_SIZE
* 2)) {
533 seclvl_printk(0, KERN_ERR
, "Received [%d] bytes; "
534 "expected [%d] for the hexadecimal "
535 "representation of the SHA1 hash of "
537 i
, (SHA1_DIGEST_SIZE
* 2));
540 while ((i
-= 2) + 2) {
542 tmp
= sha1_passwd
[i
+ 2];
543 sha1_passwd
[i
+ 2] = '\0';
544 hashedPassword
[i
/ 2] = (unsigned char)
545 simple_strtol(&sha1_passwd
[i
], NULL
, 16);
546 sha1_passwd
[i
+ 2] = tmp
;
553 * securityfs registrations
555 struct dentry
*dir_ino
, *seclvl_ino
, *passwd_ino
;
557 static int seclvlfs_register(void)
559 dir_ino
= securityfs_create_dir("seclvl", NULL
);
563 seclvl_ino
= securityfs_create_file("seclvl", S_IRUGO
| S_IWUSR
,
564 dir_ino
, &seclvl
, &seclvl_file_ops
);
567 if (*passwd
|| *sha1_passwd
) {
568 passwd_ino
= securityfs_create_file("passwd", S_IRUGO
| S_IWUSR
,
569 dir_ino
, NULL
, &passwd_file_ops
);
576 securityfs_remove(dir_ino
);
578 securityfs_remove(seclvl_ino
);
584 * Initialize the seclvl module.
586 static int __init
seclvl_init(void)
589 if (verbosity
< 0 || verbosity
> 1) {
590 printk(KERN_ERR
"Error: bad verbosity [%d]; only 0 or 1 "
591 "are valid values\n", verbosity
);
595 if (initlvl
< -1 || initlvl
> 2) {
596 seclvl_printk(0, KERN_ERR
, "Error: bad initial securelevel "
602 if ((rc
= processPassword())) {
603 seclvl_printk(0, KERN_ERR
, "Error processing the password "
604 "module parameter(s): rc = [%d]\n", rc
);
607 /* register ourselves with the security framework */
608 if (register_security(&seclvl_ops
)) {
609 seclvl_printk(0, KERN_ERR
,
610 "seclvl: Failure registering with the "
612 /* try registering with primary module */
613 rc
= mod_reg_security(MY_NAME
, &seclvl_ops
);
615 seclvl_printk(0, KERN_ERR
, "seclvl: Failure "
616 "registering with primary security "
619 } /* if primary module registered */
621 } /* if we registered ourselves with the security framework */
622 if ((rc
= seclvlfs_register())) {
623 seclvl_printk(0, KERN_ERR
, "Error registering with sysfs\n");
626 seclvl_printk(0, KERN_INFO
, "seclvl: Successfully initialized.\n");
629 printk(KERN_ERR
"seclvl: Error during initialization: rc = "
636 * Remove the seclvl module.
638 static void __exit
seclvl_exit(void)
640 securityfs_remove(seclvl_ino
);
641 if (*passwd
|| *sha1_passwd
) {
642 securityfs_remove(passwd_ino
);
644 securityfs_remove(dir_ino
);
645 if (secondary
== 1) {
646 mod_unreg_security(MY_NAME
, &seclvl_ops
);
647 } else if (unregister_security(&seclvl_ops
)) {
648 seclvl_printk(0, KERN_INFO
,
649 "seclvl: Failure unregistering with the "
654 module_init(seclvl_init
);
655 module_exit(seclvl_exit
);
657 MODULE_AUTHOR("Michael A. Halcrow <mike@halcrow.us>");
658 MODULE_DESCRIPTION("LSM implementation of the BSD Secure Levels");
659 MODULE_LICENSE("GPL");