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

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

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

~ [ 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