1f381c272SMimi Zohar /* 2f381c272SMimi Zohar * Copyright (C) 2008 IBM Corporation 3f381c272SMimi Zohar * 4f381c272SMimi Zohar * Authors: 5f381c272SMimi Zohar * Mimi Zohar <zohar@us.ibm.com> 6f381c272SMimi Zohar * 7f381c272SMimi Zohar * This program is free software; you can redistribute it and/or 8f381c272SMimi Zohar * modify it under the terms of the GNU General Public License as 9f381c272SMimi Zohar * published by the Free Software Foundation, version 2 of the 10f381c272SMimi Zohar * License. 11f381c272SMimi Zohar * 12f381c272SMimi Zohar * File: integrity_iint.c 13f381c272SMimi Zohar * - implements the integrity hooks: integrity_inode_alloc, 14f381c272SMimi Zohar * integrity_inode_free 15f381c272SMimi Zohar * - cache integrity information associated with an inode 16f381c272SMimi Zohar * using a rbtree tree. 17f381c272SMimi Zohar */ 18f381c272SMimi Zohar #include <linux/slab.h> 19f381c272SMimi Zohar #include <linux/module.h> 20f381c272SMimi Zohar #include <linux/spinlock.h> 21f381c272SMimi Zohar #include <linux/rbtree.h> 22e3c4abbfSDmitry Kasatkin #include <linux/file.h> 23e3c4abbfSDmitry Kasatkin #include <linux/uaccess.h> 24f381c272SMimi Zohar #include "integrity.h" 25f381c272SMimi Zohar 26f381c272SMimi Zohar static struct rb_root integrity_iint_tree = RB_ROOT; 27a10bf26bSDmitry Kasatkin static DEFINE_RWLOCK(integrity_iint_lock); 28f381c272SMimi Zohar static struct kmem_cache *iint_cache __read_mostly; 29f381c272SMimi Zohar 30f381c272SMimi Zohar /* 31f381c272SMimi Zohar * __integrity_iint_find - return the iint associated with an inode 32f381c272SMimi Zohar */ 33f381c272SMimi Zohar static struct integrity_iint_cache *__integrity_iint_find(struct inode *inode) 34f381c272SMimi Zohar { 35f381c272SMimi Zohar struct integrity_iint_cache *iint; 36f381c272SMimi Zohar struct rb_node *n = integrity_iint_tree.rb_node; 37f381c272SMimi Zohar 38f381c272SMimi Zohar while (n) { 39f381c272SMimi Zohar iint = rb_entry(n, struct integrity_iint_cache, rb_node); 40f381c272SMimi Zohar 41f381c272SMimi Zohar if (inode < iint->inode) 42f381c272SMimi Zohar n = n->rb_left; 43f381c272SMimi Zohar else if (inode > iint->inode) 44f381c272SMimi Zohar n = n->rb_right; 45f381c272SMimi Zohar else 46f381c272SMimi Zohar break; 47f381c272SMimi Zohar } 48f381c272SMimi Zohar if (!n) 49f381c272SMimi Zohar return NULL; 50f381c272SMimi Zohar 51f381c272SMimi Zohar return iint; 52f381c272SMimi Zohar } 53f381c272SMimi Zohar 54f381c272SMimi Zohar /* 55f381c272SMimi Zohar * integrity_iint_find - return the iint associated with an inode 56f381c272SMimi Zohar */ 57f381c272SMimi Zohar struct integrity_iint_cache *integrity_iint_find(struct inode *inode) 58f381c272SMimi Zohar { 59f381c272SMimi Zohar struct integrity_iint_cache *iint; 60f381c272SMimi Zohar 61f381c272SMimi Zohar if (!IS_IMA(inode)) 62f381c272SMimi Zohar return NULL; 63f381c272SMimi Zohar 64a10bf26bSDmitry Kasatkin read_lock(&integrity_iint_lock); 65f381c272SMimi Zohar iint = __integrity_iint_find(inode); 66a10bf26bSDmitry Kasatkin read_unlock(&integrity_iint_lock); 67f381c272SMimi Zohar 68f381c272SMimi Zohar return iint; 69f381c272SMimi Zohar } 70f381c272SMimi Zohar 71f381c272SMimi Zohar static void iint_free(struct integrity_iint_cache *iint) 72f381c272SMimi Zohar { 73a35c3fb6SDmitry Kasatkin kfree(iint->ima_hash); 74a35c3fb6SDmitry Kasatkin iint->ima_hash = NULL; 75f381c272SMimi Zohar iint->version = 0; 76f381c272SMimi Zohar iint->flags = 0UL; 77d79d72e0SMimi Zohar iint->ima_file_status = INTEGRITY_UNKNOWN; 78d79d72e0SMimi Zohar iint->ima_mmap_status = INTEGRITY_UNKNOWN; 79d79d72e0SMimi Zohar iint->ima_bprm_status = INTEGRITY_UNKNOWN; 80d79d72e0SMimi Zohar iint->ima_module_status = INTEGRITY_UNKNOWN; 81fb788d8bSDmitry Kasatkin iint->evm_status = INTEGRITY_UNKNOWN; 82f381c272SMimi Zohar kmem_cache_free(iint_cache, iint); 83f381c272SMimi Zohar } 84f381c272SMimi Zohar 85f381c272SMimi Zohar /** 86bf2276d1SDmitry Kasatkin * integrity_inode_get - find or allocate an iint associated with an inode 87f381c272SMimi Zohar * @inode: pointer to the inode 88bf2276d1SDmitry Kasatkin * @return: allocated iint 89bf2276d1SDmitry Kasatkin * 90bf2276d1SDmitry Kasatkin * Caller must lock i_mutex 91f381c272SMimi Zohar */ 92bf2276d1SDmitry Kasatkin struct integrity_iint_cache *integrity_inode_get(struct inode *inode) 93f381c272SMimi Zohar { 94f381c272SMimi Zohar struct rb_node **p; 95bf2276d1SDmitry Kasatkin struct rb_node *node, *parent = NULL; 96bf2276d1SDmitry Kasatkin struct integrity_iint_cache *iint, *test_iint; 97f381c272SMimi Zohar 98bf2276d1SDmitry Kasatkin iint = integrity_iint_find(inode); 99bf2276d1SDmitry Kasatkin if (iint) 100bf2276d1SDmitry Kasatkin return iint; 101f381c272SMimi Zohar 102bf2276d1SDmitry Kasatkin iint = kmem_cache_alloc(iint_cache, GFP_NOFS); 103bf2276d1SDmitry Kasatkin if (!iint) 104bf2276d1SDmitry Kasatkin return NULL; 105f381c272SMimi Zohar 106a10bf26bSDmitry Kasatkin write_lock(&integrity_iint_lock); 107f381c272SMimi Zohar 108f381c272SMimi Zohar p = &integrity_iint_tree.rb_node; 109f381c272SMimi Zohar while (*p) { 110f381c272SMimi Zohar parent = *p; 111f381c272SMimi Zohar test_iint = rb_entry(parent, struct integrity_iint_cache, 112f381c272SMimi Zohar rb_node); 113f381c272SMimi Zohar if (inode < test_iint->inode) 114f381c272SMimi Zohar p = &(*p)->rb_left; 115f381c272SMimi Zohar else 116bf2276d1SDmitry Kasatkin p = &(*p)->rb_right; 117f381c272SMimi Zohar } 118f381c272SMimi Zohar 119bf2276d1SDmitry Kasatkin iint->inode = inode; 120bf2276d1SDmitry Kasatkin node = &iint->rb_node; 121f381c272SMimi Zohar inode->i_flags |= S_IMA; 122bf2276d1SDmitry Kasatkin rb_link_node(node, parent, p); 123bf2276d1SDmitry Kasatkin rb_insert_color(node, &integrity_iint_tree); 124f381c272SMimi Zohar 125a10bf26bSDmitry Kasatkin write_unlock(&integrity_iint_lock); 126bf2276d1SDmitry Kasatkin return iint; 127f381c272SMimi Zohar } 128f381c272SMimi Zohar 129f381c272SMimi Zohar /** 130f381c272SMimi Zohar * integrity_inode_free - called on security_inode_free 131f381c272SMimi Zohar * @inode: pointer to the inode 132f381c272SMimi Zohar * 133f381c272SMimi Zohar * Free the integrity information(iint) associated with an inode. 134f381c272SMimi Zohar */ 135f381c272SMimi Zohar void integrity_inode_free(struct inode *inode) 136f381c272SMimi Zohar { 137f381c272SMimi Zohar struct integrity_iint_cache *iint; 138f381c272SMimi Zohar 139f381c272SMimi Zohar if (!IS_IMA(inode)) 140f381c272SMimi Zohar return; 141f381c272SMimi Zohar 142a10bf26bSDmitry Kasatkin write_lock(&integrity_iint_lock); 143f381c272SMimi Zohar iint = __integrity_iint_find(inode); 144f381c272SMimi Zohar rb_erase(&iint->rb_node, &integrity_iint_tree); 145a10bf26bSDmitry Kasatkin write_unlock(&integrity_iint_lock); 146f381c272SMimi Zohar 147f381c272SMimi Zohar iint_free(iint); 148f381c272SMimi Zohar } 149f381c272SMimi Zohar 150f381c272SMimi Zohar static void init_once(void *foo) 151f381c272SMimi Zohar { 152f381c272SMimi Zohar struct integrity_iint_cache *iint = foo; 153f381c272SMimi Zohar 1542bb930abSDmitry Kasatkin memset(iint, 0, sizeof(*iint)); 155f381c272SMimi Zohar iint->version = 0; 156f381c272SMimi Zohar iint->flags = 0UL; 157d79d72e0SMimi Zohar iint->ima_file_status = INTEGRITY_UNKNOWN; 158d79d72e0SMimi Zohar iint->ima_mmap_status = INTEGRITY_UNKNOWN; 159d79d72e0SMimi Zohar iint->ima_bprm_status = INTEGRITY_UNKNOWN; 160d79d72e0SMimi Zohar iint->ima_module_status = INTEGRITY_UNKNOWN; 16124e0198eSDmitry Kasatkin iint->evm_status = INTEGRITY_UNKNOWN; 162f381c272SMimi Zohar } 163f381c272SMimi Zohar 164f381c272SMimi Zohar static int __init integrity_iintcache_init(void) 165f381c272SMimi Zohar { 166f381c272SMimi Zohar iint_cache = 167f381c272SMimi Zohar kmem_cache_create("iint_cache", sizeof(struct integrity_iint_cache), 168f381c272SMimi Zohar 0, SLAB_PANIC, init_once); 169f381c272SMimi Zohar return 0; 170f381c272SMimi Zohar } 171f381c272SMimi Zohar security_initcall(integrity_iintcache_init); 172e3c4abbfSDmitry Kasatkin 173e3c4abbfSDmitry Kasatkin 174e3c4abbfSDmitry Kasatkin /* 175e3c4abbfSDmitry Kasatkin * integrity_kernel_read - read data from the file 176e3c4abbfSDmitry Kasatkin * 177e3c4abbfSDmitry Kasatkin * This is a function for reading file content instead of kernel_read(). 178e3c4abbfSDmitry Kasatkin * It does not perform locking checks to ensure it cannot be blocked. 179e3c4abbfSDmitry Kasatkin * It does not perform security checks because it is irrelevant for IMA. 180e3c4abbfSDmitry Kasatkin * 181e3c4abbfSDmitry Kasatkin */ 182e3c4abbfSDmitry Kasatkin int integrity_kernel_read(struct file *file, loff_t offset, 183e3c4abbfSDmitry Kasatkin char *addr, unsigned long count) 184e3c4abbfSDmitry Kasatkin { 185e3c4abbfSDmitry Kasatkin mm_segment_t old_fs; 186e3c4abbfSDmitry Kasatkin char __user *buf = (char __user *)addr; 187e3c4abbfSDmitry Kasatkin ssize_t ret = -EINVAL; 188e3c4abbfSDmitry Kasatkin 189e3c4abbfSDmitry Kasatkin if (!(file->f_mode & FMODE_READ)) 190e3c4abbfSDmitry Kasatkin return -EBADF; 191e3c4abbfSDmitry Kasatkin 192e3c4abbfSDmitry Kasatkin old_fs = get_fs(); 193e3c4abbfSDmitry Kasatkin set_fs(get_ds()); 194e3c4abbfSDmitry Kasatkin if (file->f_op->read) 195e3c4abbfSDmitry Kasatkin ret = file->f_op->read(file, buf, count, &offset); 196e3c4abbfSDmitry Kasatkin else if (file->f_op->aio_read) 197e3c4abbfSDmitry Kasatkin ret = do_sync_read(file, buf, count, &offset); 198e3c4abbfSDmitry Kasatkin else if (file->f_op->read_iter) 199e3c4abbfSDmitry Kasatkin ret = new_sync_read(file, buf, count, &offset); 200e3c4abbfSDmitry Kasatkin set_fs(old_fs); 201e3c4abbfSDmitry Kasatkin return ret; 202e3c4abbfSDmitry Kasatkin } 203e3c4abbfSDmitry Kasatkin 204e3c4abbfSDmitry Kasatkin /* 205e3c4abbfSDmitry Kasatkin * integrity_read_file - read entire file content into the buffer 206e3c4abbfSDmitry Kasatkin * 207e3c4abbfSDmitry Kasatkin * This is function opens a file, allocates the buffer of required 208e3c4abbfSDmitry Kasatkin * size, read entire file content to the buffer and closes the file 209e3c4abbfSDmitry Kasatkin * 210e3c4abbfSDmitry Kasatkin * It is used only by init code. 211e3c4abbfSDmitry Kasatkin * 212e3c4abbfSDmitry Kasatkin */ 213e3c4abbfSDmitry Kasatkin int __init integrity_read_file(const char *path, char **data) 214e3c4abbfSDmitry Kasatkin { 215e3c4abbfSDmitry Kasatkin struct file *file; 216e3c4abbfSDmitry Kasatkin loff_t size; 217e3c4abbfSDmitry Kasatkin char *buf; 218e3c4abbfSDmitry Kasatkin int rc = -EINVAL; 219e3c4abbfSDmitry Kasatkin 220e3c4abbfSDmitry Kasatkin file = filp_open(path, O_RDONLY, 0); 221e3c4abbfSDmitry Kasatkin if (IS_ERR(file)) { 222e3c4abbfSDmitry Kasatkin rc = PTR_ERR(file); 223e3c4abbfSDmitry Kasatkin pr_err("Unable to open file: %s (%d)", path, rc); 224e3c4abbfSDmitry Kasatkin return rc; 225e3c4abbfSDmitry Kasatkin } 226e3c4abbfSDmitry Kasatkin 227e3c4abbfSDmitry Kasatkin size = i_size_read(file_inode(file)); 228e3c4abbfSDmitry Kasatkin if (size <= 0) 229e3c4abbfSDmitry Kasatkin goto out; 230e3c4abbfSDmitry Kasatkin 231e3c4abbfSDmitry Kasatkin buf = kmalloc(size, GFP_KERNEL); 232e3c4abbfSDmitry Kasatkin if (!buf) { 233e3c4abbfSDmitry Kasatkin rc = -ENOMEM; 234e3c4abbfSDmitry Kasatkin goto out; 235e3c4abbfSDmitry Kasatkin } 236e3c4abbfSDmitry Kasatkin 237e3c4abbfSDmitry Kasatkin rc = integrity_kernel_read(file, 0, buf, size); 238e3c4abbfSDmitry Kasatkin if (rc < 0) 239e3c4abbfSDmitry Kasatkin kfree(buf); 240e3c4abbfSDmitry Kasatkin else if (rc != size) 241e3c4abbfSDmitry Kasatkin rc = -EIO; 242e3c4abbfSDmitry Kasatkin else 243e3c4abbfSDmitry Kasatkin *data = buf; 244e3c4abbfSDmitry Kasatkin out: 245e3c4abbfSDmitry Kasatkin fput(file); 246e3c4abbfSDmitry Kasatkin return rc; 247e3c4abbfSDmitry Kasatkin } 248