~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/security/integrity/ima/ima_fs.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp