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