leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ima: use ima_parse_buf() to parse measurements headers

Browse Source 
The binary_hdr_v1 and binary_data_v1 structures defined in
ima_restore_measurement_list() have been replaced with an array of four
ima_field_data structures where pcr, digest, template name and
template data lengths and pointers are stored.

The length of pcr and digest in the ima_field_data array and the bits
in the bitmap are set before ima_parse_buf() is called. The ENFORCE_FIELDS
bit is set for all entries except the last one (there is still data to
parse), and ENFORCE_BUFEND is set only for the last entry.

Signed-off-by: Roberto Sassu <roberto.sassu@huawei.com>
Signed-off-by: Mimi Zohar <zohar@linux.vnet.ibm.com>
This commit is contained in:
Roberto Sassu 2017-05-16 14:53:42 +02:00 committed by Mimi Zohar
parent b17fd9ecf8
commit 47fdee60b4
1 changed files with 28 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
security/integrity/ima/ima_template.c
View File

@ -19,6 +19,9 @@
#include "ima.h" #include "ima.h"
#include "ima_template_lib.h" #include "ima_template_lib.h"
enum header_fields { HDR_PCR, HDR_DIGEST, HDR_TEMPLATE_NAME,
HDR_TEMPLATE_DATA, HDR__LAST };
static struct ima_template_desc builtin_templates[] = { static struct ima_template_desc builtin_templates[] = {
{.name = IMA_TEMPLATE_IMA_NAME, .fmt = IMA_TEMPLATE_IMA_FMT}, {.name = IMA_TEMPLATE_IMA_NAME, .fmt = IMA_TEMPLATE_IMA_FMT},
{.name = "ima-ng", .fmt = "d-ng|n-ng"}, {.name = "ima-ng", .fmt = "d-ng|n-ng"},
@ -337,27 +340,19 @@ static int ima_restore_template_data(struct ima_template_desc *template_desc,
/* Restore the serialized binary measurement list without extending PCRs. */ /* Restore the serialized binary measurement list without extending PCRs. */
int ima_restore_measurement_list(loff_t size, void *buf) int ima_restore_measurement_list(loff_t size, void *buf)
{ {
struct binary_hdr_v1 {
u32 pcr;
u8 digest[TPM_DIGEST_SIZE];
u32 template_name_len;
char template_name[0];
} __packed;
char template_name[MAX_TEMPLATE_NAME_LEN]; char template_name[MAX_TEMPLATE_NAME_LEN];
struct binary_data_v1 {
u32 template_data_size;
char template_data[0];
} __packed;
struct ima_kexec_hdr *khdr = buf; struct ima_kexec_hdr *khdr = buf;
struct binary_hdr_v1 *hdr_v1; struct ima_field_data hdr[HDR__LAST] = {
struct binary_data_v1 *data_v1; [HDR_PCR] = {.len = sizeof(u32)},
[HDR_DIGEST] = {.len = TPM_DIGEST_SIZE},
};
void *bufp = buf + sizeof(*khdr); void *bufp = buf + sizeof(*khdr);
void *bufendp; void *bufendp;
struct ima_template_entry *entry; struct ima_template_entry *entry;
struct ima_template_desc *template_desc; struct ima_template_desc *template_desc;
DECLARE_BITMAP(hdr_mask, HDR__LAST);
unsigned long count = 0; unsigned long count = 0;
int ret = 0; int ret = 0;
@ -380,6 +375,10 @@ int ima_restore_measurement_list(loff_t size, void *buf)
return -EINVAL; return -EINVAL;
} }
bitmap_zero(hdr_mask, HDR__LAST);
bitmap_set(hdr_mask, HDR_PCR, 1);
bitmap_set(hdr_mask, HDR_DIGEST, 1);
/* /*
* ima kexec buffer prefix: version, buffer size, count * ima kexec buffer prefix: version, buffer size, count
* v1 format: pcr, digest, template-name-len, template-name, * v1 format: pcr, digest, template-name-len, template-name,
@ -387,31 +386,25 @@ int ima_restore_measurement_list(loff_t size, void *buf)
*/ */
bufendp = buf + khdr->buffer_size; bufendp = buf + khdr->buffer_size;
while ((bufp < bufendp) && (count++ < khdr->count)) { while ((bufp < bufendp) && (count++ < khdr->count)) {
hdr_v1 = bufp; int enforce_mask = ENFORCE_FIELDS;
if (bufp > (bufendp - sizeof(*hdr_v1))) {
pr_err("attempting to restore partial measurement\n"); enforce_mask |= (count == khdr->count) ? ENFORCE_BUFEND : 0;
ret = -EINVAL; ret = ima_parse_buf(bufp, bufendp, &bufp, HDR__LAST, hdr, NULL,
hdr_mask, enforce_mask, "entry header");
if (ret < 0)
break; break;
}
bufp += sizeof(*hdr_v1);
if (ima_canonical_fmt) if (hdr[HDR_TEMPLATE_NAME].len >= MAX_TEMPLATE_NAME_LEN) {
hdr_v1->template_name_len =
le32_to_cpu(hdr_v1->template_name_len);
if ((hdr_v1->template_name_len >= MAX_TEMPLATE_NAME_LEN) ||
(bufp > (bufendp - hdr_v1->template_name_len))) {
pr_err("attempting to restore a template name \ pr_err("attempting to restore a template name \
that is too long\n"); that is too long\n");
ret = -EINVAL; ret = -EINVAL;
break; break;
} }
data_v1 = bufp += (u_int8_t)hdr_v1->template_name_len;
/* template name is not null terminated */ /* template name is not null terminated */
memcpy(template_name, hdr_v1->template_name, memcpy(template_name, hdr[HDR_TEMPLATE_NAME].data,
hdr_v1->template_name_len); hdr[HDR_TEMPLATE_NAME].len);
template_name[hdr_v1->template_name_len] = 0; template_name[hdr[HDR_TEMPLATE_NAME].len] = 0;
if (strcmp(template_name, "ima") == 0) { if (strcmp(template_name, "ima") == 0) {
pr_err("attempting to restore an unsupported \ pr_err("attempting to restore an unsupported \
@ -441,34 +434,17 @@ int ima_restore_measurement_list(loff_t size, void *buf)
break; break;
} }
if (bufp > (bufendp - sizeof(data_v1->template_data_size))) {
pr_err("restoring the template data size failed\n");
ret = -EINVAL;
break;
}
bufp += (u_int8_t) sizeof(data_v1->template_data_size);
if (ima_canonical_fmt)
data_v1->template_data_size =
le32_to_cpu(data_v1->template_data_size);
if (bufp > (bufendp - data_v1->template_data_size)) {
pr_err("restoring the template data failed\n");
ret = -EINVAL;
break;
}
bufp += data_v1->template_data_size;
ret = ima_restore_template_data(template_desc, ret = ima_restore_template_data(template_desc,
data_v1->template_data, hdr[HDR_TEMPLATE_DATA].data,
data_v1->template_data_size, hdr[HDR_TEMPLATE_DATA].len,
&entry); &entry);
if (ret < 0) if (ret < 0)
break; break;
memcpy(entry->digest, hdr_v1->digest, TPM_DIGEST_SIZE); memcpy(entry->digest, hdr[HDR_DIGEST].data,
entry->pcr = hdr[HDR_DIGEST].len);
!ima_canonical_fmt ? hdr_v1->pcr : le32_to_cpu(hdr_v1->pcr); entry->pcr = !ima_canonical_fmt ? *(hdr[HDR_PCR].data) :
le32_to_cpu(*(hdr[HDR_PCR].data));
ret = ima_restore_measurement_entry(entry); ret = ima_restore_measurement_entry(entry);
if (ret < 0) if (ret < 0)
break; break;