1 /* 2 * Copyright (C) 2005,2006,2007,2008 IBM Corporation 3 * 4 * Authors: 5 * Kylene Hall <kjhall@us.ibm.com> 6 * Reiner Sailer <sailer@us.ibm.com> 7 * Mimi Zohar <zohar@us.ibm.com> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation, version 2 of the 12 * License. 13 * 14 * File: ima_fs.c 15 * implemenents security file system for reporting 16 * current measurement list and IMA statistics 17 */ 18 #include <linux/fcntl.h> 19 #include <linux/slab.h> 20 #include <linux/module.h> 21 #include <linux/seq_file.h> 22 #include <linux/rculist.h> 23 #include <linux/rcupdate.h> 24 #include <linux/parser.h> 25 26 #include "ima.h" 27 28 static int valid_policy = 1; 29 #define TMPBUFLEN 12 30 static ssize_t ima_show_htable_value(char __user *buf, size_t count, 31 loff_t *ppos, atomic_long_t *val) 32 { 33 char tmpbuf[TMPBUFLEN]; 34 ssize_t len; 35 36 len = scnprintf(tmpbuf, TMPBUFLEN, "%li\n", atomic_long_read(val)); 37 return simple_read_from_buffer(buf, count, ppos, tmpbuf, len); 38 } 39 40 static ssize_t ima_show_htable_violations(struct file *filp, 41 char __user *buf, 42 size_t count, loff_t *ppos) 43 { 44 return ima_show_htable_value(buf, count, ppos, &ima_htable.violations); 45 } 46 47 static const struct file_operations ima_htable_violations_ops = { 48 .read = ima_show_htable_violations, 49 .llseek = generic_file_llseek, 50 }; 51 52 static ssize_t ima_show_measurements_count(struct file *filp, 53 char __user *buf, 54 size_t count, loff_t *ppos) 55 { 56 return ima_show_htable_value(buf, count, ppos, &ima_htable.len); 57 58 } 59 60 static const struct file_operations ima_measurements_count_ops = { 61 .read = ima_show_measurements_count, 62 .llseek = generic_file_llseek, 63 }; 64 65 /* returns pointer to hlist_node */ 66 static void *ima_measurements_start(struct seq_file *m, loff_t *pos) 67 { 68 loff_t l = *pos; 69 struct ima_queue_entry *qe; 70 71 /* we need a lock since pos could point beyond last element */ 72 rcu_read_lock(); 73 list_for_each_entry_rcu(qe, &ima_measurements, later) { 74 if (!l--) { 75 rcu_read_unlock(); 76 return qe; 77 } 78 } 79 rcu_read_unlock(); 80 return NULL; 81 } 82 83 static void *ima_measurements_next(struct seq_file *m, void *v, loff_t *pos) 84 { 85 struct ima_queue_entry *qe = v; 86 87 /* lock protects when reading beyond last element 88 * against concurrent list-extension 89 */ 90 rcu_read_lock(); 91 qe = list_entry_rcu(qe->later.next, struct ima_queue_entry, later); 92 rcu_read_unlock(); 93 (*pos)++; 94 95 return (&qe->later == &ima_measurements) ? NULL : qe; 96 } 97 98 static void ima_measurements_stop(struct seq_file *m, void *v) 99 { 100 } 101 102 void ima_putc(struct seq_file *m, void *data, int datalen) 103 { 104 while (datalen--) 105 seq_putc(m, *(char *)data++); 106 } 107 108 /* print format: 109 * 32bit-le=pcr# 110 * char[20]=template digest 111 * 32bit-le=template name size 112 * char[n]=template name 113 * [eventdata length] 114 * eventdata[n]=template specific data 115 */ 116 static int ima_measurements_show(struct seq_file *m, void *v) 117 { 118 /* the list never shrinks, so we don't need a lock here */ 119 struct ima_queue_entry *qe = v; 120 struct ima_template_entry *e; 121 int namelen; 122 u32 pcr = CONFIG_IMA_MEASURE_PCR_IDX; 123 int i; 124 125 /* get entry */ 126 e = qe->entry; 127 if (e == NULL) 128 return -1; 129 130 /* 131 * 1st: PCRIndex 132 * PCR used is always the same (config option) in 133 * little-endian format 134 */ 135 ima_putc(m, &pcr, sizeof pcr); 136 137 /* 2nd: template digest */ 138 ima_putc(m, e->digest, TPM_DIGEST_SIZE); 139 140 /* 3rd: template name size */ 141 namelen = strlen(e->template_desc->name); 142 ima_putc(m, &namelen, sizeof namelen); 143 144 /* 4th: template name */ 145 ima_putc(m, e->template_desc->name, namelen); 146 147 /* 5th: template length (except for 'ima' template) */ 148 if (strcmp(e->template_desc->name, IMA_TEMPLATE_IMA_NAME) != 0) 149 ima_putc(m, &e->template_data_len, 150 sizeof(e->template_data_len)); 151 152 /* 6th: template specific data */ 153 for (i = 0; i < e->template_desc->num_fields; i++) { 154 e->template_desc->fields[i]->field_show(m, IMA_SHOW_BINARY, 155 &e->template_data[i]); 156 } 157 return 0; 158 } 159 160 static const struct seq_operations ima_measurments_seqops = { 161 .start = ima_measurements_start, 162 .next = ima_measurements_next, 163 .stop = ima_measurements_stop, 164 .show = ima_measurements_show 165 }; 166 167 static int ima_measurements_open(struct inode *inode, struct file *file) 168 { 169 return seq_open(file, &ima_measurments_seqops); 170 } 171 172 static const struct file_operations ima_measurements_ops = { 173 .open = ima_measurements_open, 174 .read = seq_read, 175 .llseek = seq_lseek, 176 .release = seq_release, 177 }; 178 179 void ima_print_digest(struct seq_file *m, u8 *digest, int size) 180 { 181 int i; 182 183 for (i = 0; i < size; i++) 184 seq_printf(m, "%02x", *(digest + i)); 185 } 186 187 /* print in ascii */ 188 static int ima_ascii_measurements_show(struct seq_file *m, void *v) 189 { 190 /* the list never shrinks, so we don't need a lock here */ 191 struct ima_queue_entry *qe = v; 192 struct ima_template_entry *e; 193 int i; 194 195 /* get entry */ 196 e = qe->entry; 197 if (e == NULL) 198 return -1; 199 200 /* 1st: PCR used (config option) */ 201 seq_printf(m, "%2d ", CONFIG_IMA_MEASURE_PCR_IDX); 202 203 /* 2nd: SHA1 template hash */ 204 ima_print_digest(m, e->digest, TPM_DIGEST_SIZE); 205 206 /* 3th: template name */ 207 seq_printf(m, " %s", e->template_desc->name); 208 209 /* 4th: template specific data */ 210 for (i = 0; i < e->template_desc->num_fields; i++) { 211 seq_puts(m, " "); 212 if (e->template_data[i].len == 0) 213 continue; 214 215 e->template_desc->fields[i]->field_show(m, IMA_SHOW_ASCII, 216 &e->template_data[i]); 217 } 218 seq_puts(m, "\n"); 219 return 0; 220 } 221 222 static const struct seq_operations ima_ascii_measurements_seqops = { 223 .start = ima_measurements_start, 224 .next = ima_measurements_next, 225 .stop = ima_measurements_stop, 226 .show = ima_ascii_measurements_show 227 }; 228 229 static int ima_ascii_measurements_open(struct inode *inode, struct file *file) 230 { 231 return seq_open(file, &ima_ascii_measurements_seqops); 232 } 233 234 static const struct file_operations ima_ascii_measurements_ops = { 235 .open = ima_ascii_measurements_open, 236 .read = seq_read, 237 .llseek = seq_lseek, 238 .release = seq_release, 239 }; 240 241 static ssize_t ima_write_policy(struct file *file, const char __user *buf, 242 size_t datalen, loff_t *ppos) 243 { 244 char *data = NULL; 245 ssize_t result; 246 247 if (datalen >= PAGE_SIZE) 248 datalen = PAGE_SIZE - 1; 249 250 /* No partial writes. */ 251 result = -EINVAL; 252 if (*ppos != 0) 253 goto out; 254 255 result = -ENOMEM; 256 data = kmalloc(datalen + 1, GFP_KERNEL); 257 if (!data) 258 goto out; 259 260 *(data + datalen) = '\0'; 261 262 result = -EFAULT; 263 if (copy_from_user(data, buf, datalen)) 264 goto out; 265 266 result = ima_parse_add_rule(data); 267 out: 268 if (result < 0) 269 valid_policy = 0; 270 kfree(data); 271 return result; 272 } 273 274 static struct dentry *ima_dir; 275 static struct dentry *binary_runtime_measurements; 276 static struct dentry *ascii_runtime_measurements; 277 static struct dentry *runtime_measurements_count; 278 static struct dentry *violations; 279 static struct dentry *ima_policy; 280 281 static atomic_t policy_opencount = ATOMIC_INIT(1); 282 /* 283 * ima_open_policy: sequentialize access to the policy file 284 */ 285 static int ima_open_policy(struct inode * inode, struct file * filp) 286 { 287 /* No point in being allowed to open it if you aren't going to write */ 288 if (!(filp->f_flags & O_WRONLY)) 289 return -EACCES; 290 if (atomic_dec_and_test(&policy_opencount)) 291 return 0; 292 return -EBUSY; 293 } 294 295 /* 296 * ima_release_policy - start using the new measure policy rules. 297 * 298 * Initially, ima_measure points to the default policy rules, now 299 * point to the new policy rules, and remove the securityfs policy file, 300 * assuming a valid policy. 301 */ 302 static int ima_release_policy(struct inode *inode, struct file *file) 303 { 304 if (!valid_policy) { 305 ima_delete_rules(); 306 valid_policy = 1; 307 atomic_set(&policy_opencount, 1); 308 return 0; 309 } 310 ima_update_policy(); 311 securityfs_remove(ima_policy); 312 ima_policy = NULL; 313 return 0; 314 } 315 316 static const struct file_operations ima_measure_policy_ops = { 317 .open = ima_open_policy, 318 .write = ima_write_policy, 319 .release = ima_release_policy, 320 .llseek = generic_file_llseek, 321 }; 322 323 int __init ima_fs_init(void) 324 { 325 ima_dir = securityfs_create_dir("ima", NULL); 326 if (IS_ERR(ima_dir)) 327 return -1; 328 329 binary_runtime_measurements = 330 securityfs_create_file("binary_runtime_measurements", 331 S_IRUSR | S_IRGRP, ima_dir, NULL, 332 &ima_measurements_ops); 333 if (IS_ERR(binary_runtime_measurements)) 334 goto out; 335 336 ascii_runtime_measurements = 337 securityfs_create_file("ascii_runtime_measurements", 338 S_IRUSR | S_IRGRP, ima_dir, NULL, 339 &ima_ascii_measurements_ops); 340 if (IS_ERR(ascii_runtime_measurements)) 341 goto out; 342 343 runtime_measurements_count = 344 securityfs_create_file("runtime_measurements_count", 345 S_IRUSR | S_IRGRP, ima_dir, NULL, 346 &ima_measurements_count_ops); 347 if (IS_ERR(runtime_measurements_count)) 348 goto out; 349 350 violations = 351 securityfs_create_file("violations", S_IRUSR | S_IRGRP, 352 ima_dir, NULL, &ima_htable_violations_ops); 353 if (IS_ERR(violations)) 354 goto out; 355 356 ima_policy = securityfs_create_file("policy", 357 S_IWUSR, 358 ima_dir, NULL, 359 &ima_measure_policy_ops); 360 if (IS_ERR(ima_policy)) 361 goto out; 362 363 return 0; 364 out: 365 securityfs_remove(violations); 366 securityfs_remove(runtime_measurements_count); 367 securityfs_remove(ascii_runtime_measurements); 368 securityfs_remove(binary_runtime_measurements); 369 securityfs_remove(ima_dir); 370 securityfs_remove(ima_policy); 371 return -1; 372 } 373