security/seclvl.c

   1 /**
   2  * BSD Secure Levels LSM
   3  *
   4  * Maintainers:
   5  *      Michael A. Halcrow <mike@halcrow.us>
   6  *      Serge Hallyn <hallyn@cs.wm.edu>
   7  *
   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>
  11  *
  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.
  16  */
  17
  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>
  25 #include <linux/fs.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>
  36
  37 #define SHA1_DIGEST_SIZE 20
  38
  39 /**
  40  * Module parameter that defines the initial secure level.
  41  *
  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.
  46  */
  47 #ifdef CONFIG_SECURITY_SECLVL_MODULE
  48 static int initlvl = 1;
  49 #else
  50 static int initlvl;
  51 #endif
  52 module_param(initlvl, int, 0);
  53 MODULE_PARM_DESC(initlvl, "Initial secure level (defaults to 1)");
  54
  55 /* Module parameter that defines the verbosity level */
  56 static int verbosity;
  57 module_param(verbosity, int, 0);
  58 MODULE_PARM_DESC(verbosity, "Initial verbosity level (0 or 1; defaults to "
  59                  "0, which is Quiet)");
  60
  61 /**
  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).
  65  *
  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.
  69  */
  70
  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");
  77
  78 /**
  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).
  83  *
  84  * Use the sha1sum utility to generate the SHA1 hash of a password:
  85  *
  86  * echo -n "secret" | sha1sum
  87  */
  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");
  95
  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");
 101
 102 #define MY_NAME "seclvl"
 103
 104 /**
 105  * This time-limits log writes to one per second.
 106  */
 107 #define seclvl_printk(verb, type, fmt, arg...)                  \
 108         do {                                                    \
 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__ , \
 115                                         ## arg);                \
 116                                 _prior = _now;                  \
 117                         }                                       \
 118                 }                                               \
 119         } while (0)
 120
 121 /**
 122  * kobject stuff
 123  */
 124
 125 struct subsystem seclvl_subsys;
 126
 127 struct seclvl_obj {
 128         char *name;
 129         struct list_head slot_list;
 130         struct kobject kobj;
 131 };
 132
 133 /**
 134  * There is a seclvl_attribute struct for each file in sysfs.
 135  *
 136  * In our case, we have one of these structs for "passwd" and another
 137  * for "seclvl".
 138  */
 139 struct seclvl_attribute {
 140         struct attribute attr;
 141         ssize_t(*show) (struct seclvl_obj *, char *);
 142         ssize_t(*store) (struct seclvl_obj *, const char *, size_t);
 143 };
 144
 145 /**
 146  * When this function is called, one of the files in sysfs is being
 147  * written to.  attribute->store is a function pointer to whatever the
 148  * struct seclvl_attribute store function pointer points to.  It is
 149  * unique for "passwd" and "seclvl".
 150  */
 151 static ssize_t
 152 seclvl_attr_store(struct kobject *kobj,
 153                   struct attribute *attr, const char *buf, size_t len)
 154 {
 155         struct seclvl_obj *obj = container_of(kobj, struct seclvl_obj, kobj);
 156         struct seclvl_attribute *attribute =
 157             container_of(attr, struct seclvl_attribute, attr);
 158         return attribute->store ? attribute->store(obj, buf, len) : -EIO;
 159 }
 160
 161 static ssize_t
 162 seclvl_attr_show(struct kobject *kobj, struct attribute *attr, char *buf)
 163 {
 164         struct seclvl_obj *obj = container_of(kobj, struct seclvl_obj, kobj);
 165         struct seclvl_attribute *attribute =
 166             container_of(attr, struct seclvl_attribute, attr);
 167         return attribute->show ? attribute->show(obj, buf) : -EIO;
 168 }
 169
 170 /**
 171  * Callback function pointers for show and store
 172  */
 173 static struct sysfs_ops seclvlfs_sysfs_ops = {
 174         .show = seclvl_attr_show,
 175         .store = seclvl_attr_store,
 176 };
 177
 178 static struct kobj_type seclvl_ktype = {
 179         .sysfs_ops = &seclvlfs_sysfs_ops
 180 };
 181
 182 decl_subsys(seclvl, &seclvl_ktype, NULL);
 183
 184 /**
 185  * The actual security level.  Ranges between -1 and 2 inclusive.
 186  */
 187 static int seclvl;
 188
 189 /**
 190  * flag to keep track of how we were registered
 191  */
 192 static int secondary;
 193
 194 /**
 195  * Verifies that the requested secure level is valid, given the current
 196  * secure level.
 197  */
 198 static int seclvl_sanity(int reqlvl)
 199 {
 200         if ((reqlvl < -1) || (reqlvl > 2)) {
 201                 seclvl_printk(1, KERN_WARNING, "Attempt to set seclvl out of "
 202                               "range: [%d]\n", reqlvl);
 203                 return -EINVAL;
 204         }
 205         if ((seclvl == 0) && (reqlvl == -1))
 206                 return 0;
 207         if (reqlvl < seclvl) {
 208                 seclvl_printk(1, KERN_WARNING, "Attempt to lower seclvl to "
 209                               "[%d]\n", reqlvl);
 210                 return -EPERM;
 211         }
 212         return 0;
 213 }
 214
 215 /**
 216  * Called whenever the user reads the sysfs handle to this kernel
 217  * object
 218  */
 219 static ssize_t seclvl_read_file(struct seclvl_obj *obj, char *buff)
 220 {
 221         return snprintf(buff, PAGE_SIZE, "%d\n", seclvl);
 222 }
 223
 224 /**
 225  * security level advancement rules:
 226  *   Valid levels are -1 through 2, inclusive.
 227  *   From -1, stuck.  [ in case compiled into kernel ]
 228  *   From 0 or above, can only increment.
 229  */
 230 static int do_seclvl_advance(int newlvl)
 231 {
 232         if (newlvl <= seclvl) {
 233                 seclvl_printk(1, KERN_WARNING, "Cannot advance to seclvl "
 234                               "[%d]\n", newlvl);
 235                 return -EINVAL;
 236         }
 237         if (newlvl > 2) {
 238                 seclvl_printk(1, KERN_WARNING, "Cannot advance to seclvl "
 239                               "[%d]\n", newlvl);
 240                 return -EINVAL;
 241         }
 242         if (seclvl == -1) {
 243                 seclvl_printk(1, KERN_WARNING, "Not allowed to advance to "
 244                               "seclvl [%d]\n", seclvl);
 245                 return -EPERM;
 246         }
 247         seclvl = newlvl;
 248         return 0;
 249 }
 250
 251 /**
 252  * Called whenever the user writes to the sysfs handle to this kernel
 253  * object (seclvl/seclvl).  It expects a single-digit number.
 254  */
 255 static ssize_t
 256 seclvl_write_file(struct seclvl_obj *obj, const char *buff, size_t count)
 257 {
 258         unsigned long val;
 259         if (count > 2 || (count == 2 && buff[1] != '\n')) {
 260                 seclvl_printk(1, KERN_WARNING, "Invalid value passed to "
 261                               "seclvl: [%s]\n", buff);
 262                 return -EINVAL;
 263         }
 264         val = buff[0] - 48;
 265         if (seclvl_sanity(val)) {
 266                 seclvl_printk(1, KERN_WARNING, "Illegal secure level "
 267                               "requested: [%d]\n", (int)val);
 268                 return -EPERM;
 269         }
 270         if (do_seclvl_advance(val)) {
 271                 seclvl_printk(0, KERN_ERR, "Failure advancing security level "
 272                               "to %lu\n", val);
 273         }
 274         return count;
 275 }
 276
 277 /* Generate sysfs_attr_seclvl */
 278 static struct seclvl_attribute sysfs_attr_seclvl =
 279 __ATTR(seclvl, (S_IFREG | S_IRUGO | S_IWUSR), seclvl_read_file,
 280        seclvl_write_file);
 281
 282 static unsigned char hashedPassword[SHA1_DIGEST_SIZE];
 283
 284 /**
 285  * Called whenever the user reads the sysfs passwd handle.
 286  */
 287 static ssize_t seclvl_read_passwd(struct seclvl_obj *obj, char *buff)
 288 {
 289         /* So just how good *is* your password? :-) */
 290         char tmp[3];
 291         int i = 0;
 292         buff[0] = '\0';
 293         if (hideHash) {
 294                 /* Security through obscurity */
 295                 return 0;
 296         }
 297         while (i < SHA1_DIGEST_SIZE) {
 298                 snprintf(tmp, 3, "%02x", hashedPassword[i]);
 299                 strncat(buff, tmp, 2);
 300                 i++;
 301         }
 302         strcat(buff, "\n");
 303         return ((SHA1_DIGEST_SIZE * 2) + 1);
 304 }
 305
 306 /**
 307  * Converts a block of plaintext of into its SHA1 hashed value.
 308  *
 309  * It would be nice if crypto had a wrapper to do this for us linear
 310  * people...
 311  */
 312 static int
 313 plaintext_to_sha1(unsigned char *hash, const char *plaintext, int len)
 314 {
 315         char *pgVirtAddr;
 316         struct crypto_tfm *tfm;
 317         struct scatterlist sg[1];
 318         if (len > PAGE_SIZE) {
 319                 seclvl_printk(0, KERN_ERR, "Plaintext password too large (%d "
 320                               "characters).  Largest possible is %lu "
 321                               "bytes.\n", len, PAGE_SIZE);
 322                 return -ENOMEM;
 323         }
 324         tfm = crypto_alloc_tfm("sha1", 0);
 325         if (tfm == NULL) {
 326                 seclvl_printk(0, KERN_ERR,
 327                               "Failed to load transform for SHA1\n");
 328                 return -ENOSYS;
 329         }
 330         // Just get a new page; don't play around with page boundaries
 331         // and scatterlists.
 332         pgVirtAddr = (char *)__get_free_page(GFP_KERNEL);
 333         sg[0].page = virt_to_page(pgVirtAddr);
 334         sg[0].offset = 0;
 335         sg[0].length = len;
 336         strncpy(pgVirtAddr, plaintext, len);
 337         crypto_digest_init(tfm);
 338         crypto_digest_update(tfm, sg, 1);
 339         crypto_digest_final(tfm, hash);
 340         crypto_free_tfm(tfm);
 341         free_page((unsigned long)pgVirtAddr);
 342         return 0;
 343 }
 344
 345 /**
 346  * Called whenever the user writes to the sysfs passwd handle to this kernel
 347  * object.  It hashes the password and compares the hashed results.
 348  */
 349 static ssize_t
 350 seclvl_write_passwd(struct seclvl_obj *obj, const char *buff, size_t count)
 351 {
 352         int i;
 353         unsigned char tmp[SHA1_DIGEST_SIZE];
 354         int rc;
 355         int len;
 356         if (!*passwd && !*sha1_passwd) {
 357                 seclvl_printk(0, KERN_ERR, "Attempt to password-unlock the "
 358                               "seclvl module, but neither a plain text "
 359                               "password nor a SHA1 hashed password was "
 360                               "passed in as a module parameter!  This is a "
 361                               "bug, since it should not be possible to be in "
 362                               "this part of the module; please tell a "
 363                               "maintainer about this event.\n");
 364                 return -EINVAL;
 365         }
 366         len = strlen(buff);
 367         /* ``echo "secret" > seclvl/passwd'' includes a newline */
 368         if (buff[len - 1] == '\n') {
 369                 len--;
 370         }
 371         /* Hash the password, then compare the hashed values */
 372         if ((rc = plaintext_to_sha1(tmp, buff, len))) {
 373                 seclvl_printk(0, KERN_ERR, "Error hashing password: rc = "
 374                               "[%d]\n", rc);
 375                 return rc;
 376         }
 377         for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
 378                 if (hashedPassword[i] != tmp[i]) {
 379                         return -EPERM;
 380                 }
 381         }
 382         seclvl_printk(0, KERN_INFO,
 383                       "Password accepted; seclvl reduced to 0.\n");
 384         seclvl = 0;
 385         return count;
 386 }
 387
 388 /* Generate sysfs_attr_passwd */
 389 static struct seclvl_attribute sysfs_attr_passwd =
 390 __ATTR(passwd, (S_IFREG | S_IRUGO | S_IWUSR), seclvl_read_passwd,
 391        seclvl_write_passwd);
 392
 393 /**
 394  * Explicitely disallow ptrace'ing the init process.
 395  */
 396 static int seclvl_ptrace(struct task_struct *parent, struct task_struct *child)
 397 {
 398         if (seclvl >= 0) {
 399                 if (child->pid == 1) {
 400                         seclvl_printk(1, KERN_WARNING, "Attempt to ptrace "
 401                                       "the init process dissallowed in "
 402                                       "secure level %d\n", seclvl);
 403                         return -EPERM;
 404                 }
 405         }
 406         return 0;
 407 }
 408
 409 /**
 410  * Capability checks for seclvl.  The majority of the policy
 411  * enforcement for seclvl takes place here.
 412  */
 413 static int seclvl_capable(struct task_struct *tsk, int cap)
 414 {
 415         /* init can do anything it wants */
 416         if (tsk->pid == 1)
 417                 return 0;
 418
 419         switch (seclvl) {
 420         case 2:
 421                 /* fall through */
 422         case 1:
 423                 if (cap == CAP_LINUX_IMMUTABLE) {
 424                         seclvl_printk(1, KERN_WARNING, "Attempt to modify "
 425                                       "the IMMUTABLE and/or APPEND extended "
 426                                       "attribute on a file with the IMMUTABLE "
 427                                       "and/or APPEND extended attribute set "
 428                                       "denied in seclvl [%d]\n", seclvl);
 429                         return -EPERM;
 430                 } else if (cap == CAP_SYS_RAWIO) {      // Somewhat broad...
 431                         seclvl_printk(1, KERN_WARNING, "Attempt to perform "
 432                                       "raw I/O while in secure level [%d] "
 433                                       "denied\n", seclvl);
 434                         return -EPERM;
 435                 } else if (cap == CAP_NET_ADMIN) {
 436                         seclvl_printk(1, KERN_WARNING, "Attempt to perform "
 437                                       "network administrative task while "
 438                                       "in secure level [%d] denied\n", seclvl);
 439                         return -EPERM;
 440                 } else if (cap == CAP_SETUID) {
 441                         seclvl_printk(1, KERN_WARNING, "Attempt to setuid "
 442                                       "while in secure level [%d] denied\n",
 443                                       seclvl);
 444                         return -EPERM;
 445                 } else if (cap == CAP_SETGID) {
 446                         seclvl_printk(1, KERN_WARNING, "Attempt to setgid "
 447                                       "while in secure level [%d] denied\n",
 448                                       seclvl);
 449                 } else if (cap == CAP_SYS_MODULE) {
 450                         seclvl_printk(1, KERN_WARNING, "Attempt to perform "
 451                                       "a module operation while in secure "
 452                                       "level [%d] denied\n", seclvl);
 453                         return -EPERM;
 454                 }
 455                 break;
 456         default:
 457                 break;
 458         }
 459         /* from dummy.c */
 460         if (cap_is_fs_cap(cap) ? tsk->fsuid == 0 : tsk->euid == 0)
 461                 return 0;       /* capability granted */
 462         seclvl_printk(1, KERN_WARNING, "Capability denied\n");
 463         return -EPERM;          /* capability denied */
 464 }
 465
 466 /**
 467  * Disallow reversing the clock in seclvl > 1
 468  */
 469 static int seclvl_settime(struct timespec *tv, struct timezone *tz)
 470 {
 471         struct timespec now;
 472         if (seclvl > 1) {
 473                 now = current_kernel_time();
 474                 if (tv->tv_sec < now.tv_sec ||
 475                     (tv->tv_sec == now.tv_sec && tv->tv_nsec < now.tv_nsec)) {
 476                         seclvl_printk(1, KERN_WARNING, "Attempt to decrement "
 477                                       "time in secure level %d denied: "
 478                                       "current->pid = [%d], "
 479                                       "current->group_leader->pid = [%d]\n",
 480                                       seclvl, current->pid,
 481                                       current->group_leader->pid);
 482                         return -EPERM;
 483                 }               /* if attempt to decrement time */
 484         }                       /* if seclvl > 1 */
 485         return 0;
 486 }
 487
 488 /* claim the blockdev to exclude mounters, release on file close */
 489 static int seclvl_bd_claim(struct inode *inode)
 490 {
 491         int holder;
 492         struct block_device *bdev = NULL;
 493         dev_t dev = inode->i_rdev;
 494         bdev = open_by_devnum(dev, FMODE_WRITE);
 495         if (bdev) {
 496                 if (bd_claim(bdev, &holder)) {
 497                         blkdev_put(bdev);
 498                         return -EPERM;
 499                 }
 500                 /* claimed, mark it to release on close */
 501                 inode->i_security = current;
 502         }
 503         return 0;
 504 }
 505
 506 /* release the blockdev if you claimed it */
 507 static void seclvl_bd_release(struct inode *inode)
 508 {
 509         if (inode && S_ISBLK(inode->i_mode) && inode->i_security == current) {
 510                 struct block_device *bdev = inode->i_bdev;
 511                 if (bdev) {
 512                         bd_release(bdev);
 513                         blkdev_put(bdev);
 514                         inode->i_security = NULL;
 515                 }
 516         }
 517 }
 518
 519 /**
 520  * Security for writes to block devices is regulated by this seclvl
 521  * function.  Deny all writes to block devices in seclvl 2.  In
 522  * seclvl 1, we only deny writes to *mounted* block devices.
 523  */
 524 static int
 525 seclvl_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
 526 {
 527         if (current->pid != 1 && S_ISBLK(inode->i_mode) && (mask & MAY_WRITE)) {
 528                 switch (seclvl) {
 529                 case 2:
 530                         seclvl_printk(1, KERN_WARNING, "Write to block device "
 531                                       "denied in secure level [%d]\n", seclvl);
 532                         return -EPERM;
 533                 case 1:
 534                         if (seclvl_bd_claim(inode)) {
 535                                 seclvl_printk(1, KERN_WARNING,
 536                                               "Write to mounted block device "
 537                                               "denied in secure level [%d]\n",
 538                                               seclvl);
 539                                 return -EPERM;
 540                         }
 541                 }
 542         }
 543         return 0;
 544 }
 545
 546 /**
 547  * The SUID and SGID bits cannot be set in seclvl >= 1
 548  */
 549 static int seclvl_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 550 {
 551         if (seclvl > 0) {
 552                 if (iattr->ia_valid & ATTR_MODE)
 553                         if (iattr->ia_mode & S_ISUID ||
 554                             iattr->ia_mode & S_ISGID) {
 555                                 seclvl_printk(1, KERN_WARNING, "Attempt to "
 556                                               "modify SUID or SGID bit "
 557                                               "denied in seclvl [%d]\n",
 558                                               seclvl);
 559                                 return -EPERM;
 560                         }
 561         }
 562         return 0;
 563 }
 564
 565 /* release busied block devices */
 566 static void seclvl_file_free_security(struct file *filp)
 567 {
 568         struct dentry *dentry = filp->f_dentry;
 569         struct inode *inode = NULL;
 570
 571         if (dentry) {
 572                 inode = dentry->d_inode;
 573                 seclvl_bd_release(inode);
 574         }
 575 }
 576
 577 /**
 578  * Cannot unmount in secure level 2
 579  */
 580 static int seclvl_umount(struct vfsmount *mnt, int flags)
 581 {
 582         if (current->pid == 1) {
 583                 return 0;
 584         }
 585         if (seclvl == 2) {
 586                 seclvl_printk(1, KERN_WARNING, "Attempt to unmount in secure "
 587                               "level %d\n", seclvl);
 588                 return -EPERM;
 589         }
 590         return 0;
 591 }
 592
 593 static struct security_operations seclvl_ops = {
 594         .ptrace = seclvl_ptrace,
 595         .capable = seclvl_capable,
 596         .inode_permission = seclvl_inode_permission,
 597         .inode_setattr = seclvl_inode_setattr,
 598         .file_free_security = seclvl_file_free_security,
 599         .settime = seclvl_settime,
 600         .sb_umount = seclvl_umount,
 601 };
 602
 603 /**
 604  * Process the password-related module parameters
 605  */
 606 static int processPassword(void)
 607 {
 608         int rc = 0;
 609         hashedPassword[0] = '\0';
 610         if (*passwd) {
 611                 if (*sha1_passwd) {
 612                         seclvl_printk(0, KERN_ERR, "Error: Both "
 613                                       "passwd and sha1_passwd "
 614                                       "were set, but they are mutually "
 615                                       "exclusive.\n");
 616                         return -EINVAL;
 617                 }
 618                 if ((rc = plaintext_to_sha1(hashedPassword, passwd,
 619                                             strlen(passwd)))) {
 620                         seclvl_printk(0, KERN_ERR, "Error: SHA1 support not "
 621                                       "in kernel\n");
 622                         return rc;
 623                 }
 624                 /* All static data goes to the BSS, which zero's the
 625                  * plaintext password out for us. */
 626         } else if (*sha1_passwd) {      // Base 16
 627                 int i;
 628                 i = strlen(sha1_passwd);
 629                 if (i != (SHA1_DIGEST_SIZE * 2)) {
 630                         seclvl_printk(0, KERN_ERR, "Received [%d] bytes; "
 631                                       "expected [%d] for the hexadecimal "
 632                                       "representation of the SHA1 hash of "
 633                                       "the password.\n",
 634                                       i, (SHA1_DIGEST_SIZE * 2));
 635                         return -EINVAL;
 636                 }
 637                 while ((i -= 2) + 2) {
 638                         unsigned char tmp;
 639                         tmp = sha1_passwd[i + 2];
 640                         sha1_passwd[i + 2] = '\0';
 641                         hashedPassword[i / 2] = (unsigned char)
 642                             simple_strtol(&sha1_passwd[i], NULL, 16);
 643                         sha1_passwd[i + 2] = tmp;
 644                 }
 645         }
 646         return 0;
 647 }
 648
 649 /**
 650  * Sysfs registrations
 651  */
 652 static int doSysfsRegistrations(void)
 653 {
 654         int rc = 0;
 655         if ((rc = subsystem_register(&seclvl_subsys))) {
 656                 seclvl_printk(0, KERN_WARNING,
 657                               "Error [%d] registering seclvl subsystem\n", rc);
 658                 return rc;
 659         }
 660         sysfs_create_file(&seclvl_subsys.kset.kobj, &sysfs_attr_seclvl.attr);
 661         if (*passwd || *sha1_passwd) {
 662                 sysfs_create_file(&seclvl_subsys.kset.kobj,
 663                                   &sysfs_attr_passwd.attr);
 664         }
 665         return 0;
 666 }
 667
 668 /**
 669  * Initialize the seclvl module.
 670  */
 671 static int __init seclvl_init(void)
 672 {
 673         int rc = 0;
 674         if (verbosity < 0 || verbosity > 1) {
 675                 printk(KERN_ERR "Error: bad verbosity [%d]; only 0 or 1 "
 676                        "are valid values\n", verbosity);
 677                 rc = -EINVAL;
 678                 goto exit;
 679         }
 680         sysfs_attr_seclvl.attr.owner = THIS_MODULE;
 681         sysfs_attr_passwd.attr.owner = THIS_MODULE;
 682         if (initlvl < -1 || initlvl > 2) {
 683                 seclvl_printk(0, KERN_ERR, "Error: bad initial securelevel "
 684                               "[%d].\n", initlvl);
 685                 rc = -EINVAL;
 686                 goto exit;
 687         }
 688         seclvl = initlvl;
 689         if ((rc = processPassword())) {
 690                 seclvl_printk(0, KERN_ERR, "Error processing the password "
 691                               "module parameter(s): rc = [%d]\n", rc);
 692                 goto exit;
 693         }
 694         /* register ourselves with the security framework */
 695         if (register_security(&seclvl_ops)) {
 696                 seclvl_printk(0, KERN_ERR,
 697                               "seclvl: Failure registering with the "
 698                               "kernel.\n");
 699                 /* try registering with primary module */
 700                 rc = mod_reg_security(MY_NAME, &seclvl_ops);
 701                 if (rc) {
 702                         seclvl_printk(0, KERN_ERR, "seclvl: Failure "
 703                                       "registering with primary security "
 704                                       "module.\n");
 705                         goto exit;
 706                 }               /* if primary module registered */
 707                 secondary = 1;
 708         }                       /* if we registered ourselves with the security framework */
 709         if ((rc = doSysfsRegistrations())) {
 710                 seclvl_printk(0, KERN_ERR, "Error registering with sysfs\n");
 711                 goto exit;
 712         }
 713         seclvl_printk(0, KERN_INFO, "seclvl: Successfully initialized.\n");
 714  exit:
 715         if (rc) {
 716                 printk(KERN_ERR "seclvl: Error during initialization: rc = "
 717                        "[%d]\n", rc);
 718         }
 719         return rc;
 720 }
 721
 722 /**
 723  * Remove the seclvl module.
 724  */
 725 static void __exit seclvl_exit(void)
 726 {
 727         sysfs_remove_file(&seclvl_subsys.kset.kobj, &sysfs_attr_seclvl.attr);
 728         if (*passwd || *sha1_passwd) {
 729                 sysfs_remove_file(&seclvl_subsys.kset.kobj,
 730                                   &sysfs_attr_passwd.attr);
 731         }
 732         subsystem_unregister(&seclvl_subsys);
 733         if (secondary == 1) {
 734                 mod_unreg_security(MY_NAME, &seclvl_ops);
 735         } else if (unregister_security(&seclvl_ops)) {
 736                 seclvl_printk(0, KERN_INFO,
 737                               "seclvl: Failure unregistering with the "
 738                               "kernel\n");
 739         }
 740 }
 741
 742 module_init(seclvl_init);
 743 module_exit(seclvl_exit);
 744
 745 MODULE_AUTHOR("Michael A. Halcrow <mike@halcrow.us>");
 746 MODULE_DESCRIPTION("LSM implementation of the BSD Secure Levels");
 747 MODULE_LICENSE("GPL");