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

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

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

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