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

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

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ 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) 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_appraise_or_measure, collect_measurement,
 13  *      appraise_measurement, store_measurement and store_template.
 14  */
 15 #include <linux/module.h>
 16 #include <linux/slab.h>
 17 #include <linux/file.h>
 18 #include <linux/fs.h>
 19 #include <linux/xattr.h>
 20 #include <linux/evm.h>
 21 #include <crypto/hash_info.h>
 22 #include "ima.h"
 23 
 24 /*
 25  * ima_free_template_entry - free an existing template entry
 26  */
 27 void ima_free_template_entry(struct ima_template_entry *entry)
 28 {
 29         int i;
 30 
 31         for (i = 0; i < entry->template_desc->num_fields; i++)
 32                 kfree(entry->template_data[i].data);
 33 
 34         kfree(entry);
 35 }
 36 
 37 /*
 38  * ima_alloc_init_template - create and initialize a new template entry
 39  */
 40 int ima_alloc_init_template(struct integrity_iint_cache *iint,
 41                             struct file *file, const unsigned char *filename,
 42                             struct evm_ima_xattr_data *xattr_value,
 43                             int xattr_len, struct ima_template_entry **entry)
 44 {
 45         struct ima_template_desc *template_desc = ima_template_desc_current();
 46         int i, result = 0;
 47 
 48         *entry = kzalloc(sizeof(**entry) + template_desc->num_fields *
 49                          sizeof(struct ima_field_data), GFP_NOFS);
 50         if (!*entry)
 51                 return -ENOMEM;
 52 
 53         (*entry)->template_desc = template_desc;
 54         for (i = 0; i < template_desc->num_fields; i++) {
 55                 struct ima_template_field *field = template_desc->fields[i];
 56                 u32 len;
 57 
 58                 result = field->field_init(iint, file, filename,
 59                                            xattr_value, xattr_len,
 60                                            &((*entry)->template_data[i]));
 61                 if (result != 0)
 62                         goto out;
 63 
 64                 len = (*entry)->template_data[i].len;
 65                 (*entry)->template_data_len += sizeof(len);
 66                 (*entry)->template_data_len += len;
 67         }
 68         return 0;
 69 out:
 70         ima_free_template_entry(*entry);
 71         *entry = NULL;
 72         return result;
 73 }
 74 
 75 /*
 76  * ima_store_template - store ima template measurements
 77  *
 78  * Calculate the hash of a template entry, add the template entry
 79  * to an ordered list of measurement entries maintained inside the kernel,
 80  * and also update the aggregate integrity value (maintained inside the
 81  * configured TPM PCR) over the hashes of the current list of measurement
 82  * entries.
 83  *
 84  * Applications retrieve the current kernel-held measurement list through
 85  * the securityfs entries in /sys/kernel/security/ima. The signed aggregate
 86  * TPM PCR (called quote) can be retrieved using a TPM user space library
 87  * and is used to validate the measurement list.
 88  *
 89  * Returns 0 on success, error code otherwise
 90  */
 91 int ima_store_template(struct ima_template_entry *entry,
 92                        int violation, struct inode *inode,
 93                        const unsigned char *filename)
 94 {
 95         const char *op = "add_template_measure";
 96         const char *audit_cause = "hashing_error";
 97         char *template_name = entry->template_desc->name;
 98         int result;
 99         struct {
100                 struct ima_digest_data hdr;
101                 char digest[TPM_DIGEST_SIZE];
102         } hash;
103 
104         if (!violation) {
105                 int num_fields = entry->template_desc->num_fields;
106 
107                 /* this function uses default algo */
108                 hash.hdr.algo = HASH_ALGO_SHA1;
109                 result = ima_calc_field_array_hash(&entry->template_data[0],
110                                                    entry->template_desc,
111                                                    num_fields, &hash.hdr);
112                 if (result < 0) {
113                         integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
114                                             template_name, op,
115                                             audit_cause, result, 0);
116                         return result;
117                 }
118                 memcpy(entry->digest, hash.hdr.digest, hash.hdr.length);
119         }
120         result = ima_add_template_entry(entry, violation, op, inode, filename);
121         return result;
122 }
123 
124 /*
125  * ima_add_violation - add violation to measurement list.
126  *
127  * Violations are flagged in the measurement list with zero hash values.
128  * By extending the PCR with 0xFF's instead of with zeroes, the PCR
129  * value is invalidated.
130  */
131 void ima_add_violation(struct file *file, const unsigned char *filename,
132                        const char *op, const char *cause)
133 {
134         struct ima_template_entry *entry;
135         struct inode *inode = file->f_dentry->d_inode;
136         int violation = 1;
137         int result;
138 
139         /* can overflow, only indicator */
140         atomic_long_inc(&ima_htable.violations);
141 
142         result = ima_alloc_init_template(NULL, file, filename,
143                                          NULL, 0, &entry);
144         if (result < 0) {
145                 result = -ENOMEM;
146                 goto err_out;
147         }
148         result = ima_store_template(entry, violation, inode, filename);
149         if (result < 0)
150                 ima_free_template_entry(entry);
151 err_out:
152         integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
153                             op, cause, result, 0);
154 }
155 
156 /**
157  * ima_get_action - appraise & measure decision based on policy.
158  * @inode: pointer to inode to measure
159  * @mask: contains the permission mask (MAY_READ, MAY_WRITE, MAY_EXECUTE)
160  * @function: calling function (FILE_CHECK, BPRM_CHECK, MMAP_CHECK, MODULE_CHECK)
161  *
162  * The policy is defined in terms of keypairs:
163  *              subj=, obj=, type=, func=, mask=, fsmagic=
164  *      subj,obj, and type: are LSM specific.
165  *      func: FILE_CHECK | BPRM_CHECK | MMAP_CHECK | MODULE_CHECK
166  *      mask: contains the permission mask
167  *      fsmagic: hex value
168  *
169  * Returns IMA_MEASURE, IMA_APPRAISE mask.
170  *
171  */
172 int ima_get_action(struct inode *inode, int mask, int function)
173 {
174         int flags = IMA_MEASURE | IMA_AUDIT | IMA_APPRAISE;
175 
176         if (!ima_appraise)
177                 flags &= ~IMA_APPRAISE;
178 
179         return ima_match_policy(inode, function, mask, flags);
180 }
181 
182 int ima_must_measure(struct inode *inode, int mask, int function)
183 {
184         return ima_match_policy(inode, function, mask, IMA_MEASURE);
185 }
186 
187 /*
188  * ima_collect_measurement - collect file measurement
189  *
190  * Calculate the file hash, if it doesn't already exist,
191  * storing the measurement and i_version in the iint.
192  *
193  * Must be called with iint->mutex held.
194  *
195  * Return 0 on success, error code otherwise
196  */
197 int ima_collect_measurement(struct integrity_iint_cache *iint,
198                             struct file *file,
199                             struct evm_ima_xattr_data **xattr_value,
200                             int *xattr_len)
201 {
202         const char *audit_cause = "failed";
203         struct inode *inode = file_inode(file);
204         const char *filename = file->f_dentry->d_name.name;
205         int result = 0;
206         struct {
207                 struct ima_digest_data hdr;
208                 char digest[IMA_MAX_DIGEST_SIZE];
209         } hash;
210 
211         if (xattr_value)
212                 *xattr_len = ima_read_xattr(file->f_dentry, xattr_value);
213 
214         if (!(iint->flags & IMA_COLLECTED)) {
215                 u64 i_version = file_inode(file)->i_version;
216 
217                 if (file->f_flags & O_DIRECT) {
218                         audit_cause = "failed(directio)";
219                         result = -EACCES;
220                         goto out;
221                 }
222 
223                 /* use default hash algorithm */
224                 hash.hdr.algo = ima_hash_algo;
225 
226                 if (xattr_value)
227                         ima_get_hash_algo(*xattr_value, *xattr_len, &hash.hdr);
228 
229                 result = ima_calc_file_hash(file, &hash.hdr);
230                 if (!result) {
231                         int length = sizeof(hash.hdr) + hash.hdr.length;
232                         void *tmpbuf = krealloc(iint->ima_hash, length,
233                                                 GFP_NOFS);
234                         if (tmpbuf) {
235                                 iint->ima_hash = tmpbuf;
236                                 memcpy(iint->ima_hash, &hash, length);
237                                 iint->version = i_version;
238                                 iint->flags |= IMA_COLLECTED;
239                         } else
240                                 result = -ENOMEM;
241                 }
242         }
243 out:
244         if (result)
245                 integrity_audit_msg(AUDIT_INTEGRITY_DATA, inode,
246                                     filename, "collect_data", audit_cause,
247                                     result, 0);
248         return result;
249 }
250 
251 /*
252  * ima_store_measurement - store file measurement
253  *
254  * Create an "ima" template and then store the template by calling
255  * ima_store_template.
256  *
257  * We only get here if the inode has not already been measured,
258  * but the measurement could already exist:
259  *      - multiple copies of the same file on either the same or
260  *        different filesystems.
261  *      - the inode was previously flushed as well as the iint info,
262  *        containing the hashing info.
263  *
264  * Must be called with iint->mutex held.
265  */
266 void ima_store_measurement(struct integrity_iint_cache *iint,
267                            struct file *file, const unsigned char *filename,
268                            struct evm_ima_xattr_data *xattr_value,
269                            int xattr_len)
270 {
271         const char *op = "add_template_measure";
272         const char *audit_cause = "ENOMEM";
273         int result = -ENOMEM;
274         struct inode *inode = file_inode(file);
275         struct ima_template_entry *entry;
276         int violation = 0;
277 
278         if (iint->flags & IMA_MEASURED)
279                 return;
280 
281         result = ima_alloc_init_template(iint, file, filename,
282                                          xattr_value, xattr_len, &entry);
283         if (result < 0) {
284                 integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode, filename,
285                                     op, audit_cause, result, 0);
286                 return;
287         }
288 
289         result = ima_store_template(entry, violation, inode, filename);
290         if (!result || result == -EEXIST)
291                 iint->flags |= IMA_MEASURED;
292         if (result < 0)
293                 ima_free_template_entry(entry);
294 }
295 
296 void ima_audit_measurement(struct integrity_iint_cache *iint,
297                            const unsigned char *filename)
298 {
299         struct audit_buffer *ab;
300         char hash[(iint->ima_hash->length * 2) + 1];
301         const char *algo_name = hash_algo_name[iint->ima_hash->algo];
302         char algo_hash[sizeof(hash) + strlen(algo_name) + 2];
303         int i;
304 
305         if (iint->flags & IMA_AUDITED)
306                 return;
307 
308         for (i = 0; i < iint->ima_hash->length; i++)
309                 hex_byte_pack(hash + (i * 2), iint->ima_hash->digest[i]);
310         hash[i * 2] = '\0';
311 
312         ab = audit_log_start(current->audit_context, GFP_KERNEL,
313                              AUDIT_INTEGRITY_RULE);
314         if (!ab)
315                 return;
316 
317         audit_log_format(ab, "file=");
318         audit_log_untrustedstring(ab, filename);
319         audit_log_format(ab, " hash=");
320         snprintf(algo_hash, sizeof(algo_hash), "%s:%s", algo_name, hash);
321         audit_log_untrustedstring(ab, algo_hash);
322 
323         audit_log_task_info(ab, current);
324         audit_log_end(ab);
325 
326         iint->flags |= IMA_AUDITED;
327 }
328 
329 const char *ima_d_path(struct path *path, char **pathbuf)
330 {
331         char *pathname = NULL;
332 
333         /* We will allow 11 spaces for ' (deleted)' to be appended */
334         *pathbuf = kmalloc(PATH_MAX + 11, GFP_KERNEL);
335         if (*pathbuf) {
336                 pathname = d_path(path, *pathbuf, PATH_MAX + 11);
337                 if (IS_ERR(pathname)) {
338                         kfree(*pathbuf);
339                         *pathbuf = NULL;
340                         pathname = NULL;
341                 }
342         }
343         return pathname;
344 }
345 

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