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 static 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[n]=template specific data 114 */ 115 static int ima_measurements_show(struct seq_file *m, void *v) 116 { 117 /* the list never shrinks, so we don't need a lock here */ 118 struct ima_queue_entry *qe = v; 119 struct ima_template_entry *e; 120 int namelen; 121 u32 pcr = CONFIG_IMA_MEASURE_PCR_IDX; 122 123 /* get entry */ 124 e = qe->entry; 125 if (e == NULL) 126 return -1; 127 128 /* 129 * 1st: PCRIndex 130 * PCR used is always the same (config option) in 131 * little-endian format 132 */ 133 ima_putc(m, &pcr, sizeof pcr); 134 135 /* 2nd: template digest */ 136 ima_putc(m, e->digest, TPM_DIGEST_SIZE); 137 138 /* 3rd: template name size */ 139 namelen = strlen(e->template_name); 140 ima_putc(m, &namelen, sizeof namelen); 141 142 /* 4th: template name */ 143 ima_putc(m, (void *)e->template_name, namelen); 144 145 /* 5th: template specific data */ 146 ima_template_show(m, (struct ima_template_data *)&e->template, 147 IMA_SHOW_BINARY); 148 return 0; 149 } 150 151 static const struct seq_operations ima_measurments_seqops = { 152 .start = ima_measurements_start, 153 .next = ima_measurements_next, 154 .stop = ima_measurements_stop, 155 .show = ima_measurements_show 156 }; 157 158 static int ima_measurements_open(struct inode *inode, struct file *file) 159 { 160 return seq_open(file, &ima_measurments_seqops); 161 } 162 163 static const struct file_operations ima_measurements_ops = { 164 .open = ima_measurements_open, 165 .read = seq_read, 166 .llseek = seq_lseek, 167 .release = seq_release, 168 }; 169 170 static void ima_print_digest(struct seq_file *m, u8 *digest, int size) 171 { 172 int i; 173 174 for (i = 0; i < size; i++) 175 seq_printf(m, "%02x", *(digest + i)); 176 } 177 178 void ima_template_show(struct seq_file *m, void *e, enum ima_show_type show) 179 { 180 struct ima_template_data *entry = e; 181 int namelen; 182 183 switch (show) { 184 case IMA_SHOW_ASCII: 185 ima_print_digest(m, entry->digest, IMA_DIGEST_SIZE); 186 seq_printf(m, " %s\n", entry->file_name); 187 break; 188 case IMA_SHOW_BINARY: 189 ima_putc(m, entry->digest, IMA_DIGEST_SIZE); 190 191 namelen = strlen(entry->file_name); 192 ima_putc(m, &namelen, sizeof namelen); 193 ima_putc(m, entry->file_name, namelen); 194 default: 195 break; 196 } 197 } 198 199 /* print in ascii */ 200 static int ima_ascii_measurements_show(struct seq_file *m, void *v) 201 { 202 /* the list never shrinks, so we don't need a lock here */ 203 struct ima_queue_entry *qe = v; 204 struct ima_template_entry *e; 205 206 /* get entry */ 207 e = qe->entry; 208 if (e == NULL) 209 return -1; 210 211 /* 1st: PCR used (config option) */ 212 seq_printf(m, "%2d ", CONFIG_IMA_MEASURE_PCR_IDX); 213 214 /* 2nd: SHA1 template hash */ 215 ima_print_digest(m, e->digest, TPM_DIGEST_SIZE); 216 217 /* 3th: template name */ 218 seq_printf(m, " %s ", e->template_name); 219 220 /* 4th: template specific data */ 221 ima_template_show(m, (struct ima_template_data *)&e->template, 222 IMA_SHOW_ASCII); 223 return 0; 224 } 225 226 static const struct seq_operations ima_ascii_measurements_seqops = { 227 .start = ima_measurements_start, 228 .next = ima_measurements_next, 229 .stop = ima_measurements_stop, 230 .show = ima_ascii_measurements_show 231 }; 232 233 static int ima_ascii_measurements_open(struct inode *inode, struct file *file) 234 { 235 return seq_open(file, &ima_ascii_measurements_seqops); 236 } 237 238 static const struct file_operations ima_ascii_measurements_ops = { 239 .open = ima_ascii_measurements_open, 240 .read = seq_read, 241 .llseek = seq_lseek, 242 .release = seq_release, 243 }; 244 245 static ssize_t ima_write_policy(struct file *file, const char __user *buf, 246 size_t datalen, loff_t *ppos) 247 { 248 char *data = NULL; 249 ssize_t result; 250 251 if (datalen >= PAGE_SIZE) 252 datalen = PAGE_SIZE - 1; 253 254 /* No partial writes. */ 255 result = -EINVAL; 256 if (*ppos != 0) 257 goto out; 258 259 result = -ENOMEM; 260 data = kmalloc(datalen + 1, GFP_KERNEL); 261 if (!data) 262 goto out; 263 264 *(data + datalen) = '\0'; 265 266 result = -EFAULT; 267 if (copy_from_user(data, buf, datalen)) 268 goto out; 269 270 result = ima_parse_add_rule(data); 271 out: 272 if (result < 0) 273 valid_policy = 0; 274 kfree(data); 275 return result; 276 } 277 278 static struct dentry *ima_dir; 279 static struct dentry *binary_runtime_measurements; 280 static struct dentry *ascii_runtime_measurements; 281 static struct dentry *runtime_measurements_count; 282 static struct dentry *violations; 283 static struct dentry *ima_policy; 284 285 static atomic_t policy_opencount = ATOMIC_INIT(1); 286 /* 287 * ima_open_policy: sequentialize access to the policy file 288 */ 289 static int ima_open_policy(struct inode * inode, struct file * filp) 290 { 291 /* No point in being allowed to open it if you aren't going to write */ 292 if (!(filp->f_flags & O_WRONLY)) 293 return -EACCES; 294 if (atomic_dec_and_test(&policy_opencount)) 295 return 0; 296 return -EBUSY; 297 } 298 299 /* 300 * ima_release_policy - start using the new measure policy rules. 301 * 302 * Initially, ima_measure points to the default policy rules, now 303 * point to the new policy rules, and remove the securityfs policy file, 304 * assuming a valid policy. 305 */ 306 static int ima_release_policy(struct inode *inode, struct file *file) 307 { 308 if (!valid_policy) { 309 ima_delete_rules(); 310 valid_policy = 1; 311 atomic_set(&policy_opencount, 1); 312 return 0; 313 } 314 ima_update_policy(); 315 securityfs_remove(ima_policy); 316 ima_policy = NULL; 317 return 0; 318 } 319 320 static const struct file_operations ima_measure_policy_ops = { 321 .open = ima_open_policy, 322 .write = ima_write_policy, 323 .release = ima_release_policy, 324 .llseek = generic_file_llseek, 325 }; 326 327 int __init ima_fs_init(void) 328 { 329 ima_dir = securityfs_create_dir("ima", NULL); 330 if (IS_ERR(ima_dir)) 331 return -1; 332 333 binary_runtime_measurements = 334 securityfs_create_file("binary_runtime_measurements", 335 S_IRUSR | S_IRGRP, ima_dir, NULL, 336 &ima_measurements_ops); 337 if (IS_ERR(binary_runtime_measurements)) 338 goto out; 339 340 ascii_runtime_measurements = 341 securityfs_create_file("ascii_runtime_measurements", 342 S_IRUSR | S_IRGRP, ima_dir, NULL, 343 &ima_ascii_measurements_ops); 344 if (IS_ERR(ascii_runtime_measurements)) 345 goto out; 346 347 runtime_measurements_count = 348 securityfs_create_file("runtime_measurements_count", 349 S_IRUSR | S_IRGRP, ima_dir, NULL, 350 &ima_measurements_count_ops); 351 if (IS_ERR(runtime_measurements_count)) 352 goto out; 353 354 violations = 355 securityfs_create_file("violations", S_IRUSR | S_IRGRP, 356 ima_dir, NULL, &ima_htable_violations_ops); 357 if (IS_ERR(violations)) 358 goto out; 359 360 ima_policy = securityfs_create_file("policy", 361 S_IWUSR, 362 ima_dir, NULL, 363 &ima_measure_policy_ops); 364 if (IS_ERR(ima_policy)) 365 goto out; 366 367 return 0; 368 out: 369 securityfs_remove(violations); 370 securityfs_remove(runtime_measurements_count); 371 securityfs_remove(ascii_runtime_measurements); 372 securityfs_remove(binary_runtime_measurements); 373 securityfs_remove(ima_dir); 374 securityfs_remove(ima_policy); 375 return -1; 376 } 377