Merge branch 'akpm-incoming-1'
[sfrench/cifs-2.6.git] / security / integrity / ima / ima_api.c
1 /*
2  * Copyright (C) 2008 IBM Corporation
3  *
4  * Author: Mimi Zohar <zohar@us.ibm.com>
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation, version 2 of the
9  * License.
10  *
11  * File: ima_api.c
12  *      Implements must_measure, collect_measurement, store_measurement,
13  *      and store_template.
14  */
15 #include <linux/module.h>
16 #include <linux/slab.h>
17
18 #include "ima.h"
19 static const char *IMA_TEMPLATE_NAME = "ima";
20
21 /*
22  * ima_store_template - store ima template measurements
23  *
24  * Calculate the hash of a template entry, add the template entry
25  * to an ordered list of measurement entries maintained inside the kernel,
26  * and also update the aggregate integrity value (maintained inside the
27  * configured TPM PCR) over the hashes of the current list of measurement
28  * entries.
29  *
30  * Applications retrieve the current kernel-held measurement list through
31  * the securityfs entries in /sys/kernel/security/ima. The signed aggregate
32  * TPM PCR (called quote) can be retrieved using a TPM user space library
33  * and is used to validate the measurement list.
34  *
35  * Returns 0 on success, error code otherwise
36  */
37 int ima_store_template(struct ima_template_entry *entry,
38                        int violation, struct inode *inode)
39 {
40         const char *op = "add_template_measure";
41         const char *audit_cause = "hashing_error";
42         int result;
43
44         memset(entry->digest, 0, sizeof(entry->digest));
45         entry->template_name = IMA_TEMPLATE_NAME;
46         entry->template_len = sizeof(entry->template);
47
48         if (!violation) {
49                 result = ima_calc_template_hash(entry->template_len,
50                                                 &entry->template,
51                                                 entry->digest);
52                 if (result < 0) {
53                         integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
54                                             entry->template_name, op,
55                                             audit_cause, result, 0);
56                         return result;
57                 }
58         }
59         result = ima_add_template_entry(entry, violation, op, inode);
60         return result;
61 }
62
63 /*
64  * ima_add_violation - add violation to measurement list.
65  *
66  * Violations are flagged in the measurement list with zero hash values.
67  * By extending the PCR with 0xFF's instead of with zeroes, the PCR
68  * value is invalidated.
69  */
70 void ima_add_violation(struct inode *inode, const unsigned char *filename,
71                        const char *op, const char *cause)
72 {
73         struct ima_template_entry *entry;
74         int violation = 1;
75         int result;
76
77         /* can overflow, only indicator */
78         atomic_long_inc(&ima_htable.violations);
79
80         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
81         if (!entry) {
82                 result = -ENOMEM;
83                 goto err_out;
84         }
85         memset(&entry->template, 0, sizeof(entry->template));
86         strncpy(entry->template.file_name, filename, IMA_EVENT_NAME_LEN_MAX);
87         result = ima_store_template(entry, violation, inode);
88         if (result < 0)
89                 kfree(entry);
90 err_out:
91         integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
92                             op, cause, result, 0);
93 }
94
95 /**
96  * ima_must_measure - measure decision based on policy.
97  * @inode: pointer to inode to measure
98  * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXECUTE)
99  * @function: calling function (FILE_CHECK, BPRM_CHECK, FILE_MMAP)
100  *
101  * The policy is defined in terms of keypairs:
102  *              subj=, obj=, type=, func=, mask=, fsmagic=
103  *      subj,obj, and type: are LSM specific.
104  *      func: FILE_CHECK | BPRM_CHECK | FILE_MMAP
105  *      mask: contains the permission mask
106  *      fsmagic: hex value
107  *
108  * Must be called with iint->mutex held.
109  *
110  * Return 0 to measure. Return 1 if already measured.
111  * For matching a DONT_MEASURE policy, no policy, or other
112  * error, return an error code.
113 */
114 int ima_must_measure(struct ima_iint_cache *iint, struct inode *inode,
115                      int mask, int function)
116 {
117         int must_measure;
118
119         if (iint && iint->flags & IMA_MEASURED)
120                 return 1;
121
122         must_measure = ima_match_policy(inode, function, mask);
123         return must_measure ? 0 : -EACCES;
124 }
125
126 /*
127  * ima_collect_measurement - collect file measurement
128  *
129  * Calculate the file hash, if it doesn't already exist,
130  * storing the measurement and i_version in the iint.
131  *
132  * Must be called with iint->mutex held.
133  *
134  * Return 0 on success, error code otherwise
135  */
136 int ima_collect_measurement(struct ima_iint_cache *iint, struct file *file)
137 {
138         int result = -EEXIST;
139
140         if (!(iint->flags & IMA_MEASURED)) {
141                 u64 i_version = file->f_dentry->d_inode->i_version;
142
143                 memset(iint->digest, 0, IMA_DIGEST_SIZE);
144                 result = ima_calc_hash(file, iint->digest);
145                 if (!result)
146                         iint->version = i_version;
147         }
148         return result;
149 }
150
151 /*
152  * ima_store_measurement - store file measurement
153  *
154  * Create an "ima" template and then store the template by calling
155  * ima_store_template.
156  *
157  * We only get here if the inode has not already been measured,
158  * but the measurement could already exist:
159  *      - multiple copies of the same file on either the same or
160  *        different filesystems.
161  *      - the inode was previously flushed as well as the iint info,
162  *        containing the hashing info.
163  *
164  * Must be called with iint->mutex held.
165  */
166 void ima_store_measurement(struct ima_iint_cache *iint, struct file *file,
167                            const unsigned char *filename)
168 {
169         const char *op = "add_template_measure";
170         const char *audit_cause = "ENOMEM";
171         int result = -ENOMEM;
172         struct inode *inode = file->f_dentry->d_inode;
173         struct ima_template_entry *entry;
174         int violation = 0;
175
176         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
177         if (!entry) {
178                 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
179                                     op, audit_cause, result, 0);
180                 return;
181         }
182         memset(&entry->template, 0, sizeof(entry->template));
183         memcpy(entry->template.digest, iint->digest, IMA_DIGEST_SIZE);
184         strncpy(entry->template.file_name, filename, IMA_EVENT_NAME_LEN_MAX);
185
186         result = ima_store_template(entry, violation, inode);
187         if (!result)
188                 iint->flags |= IMA_MEASURED;
189         else
190                 kfree(entry);
191 }