1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
/* Copyright 2013-2017 IBM Corp.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef pr_fmt
#define pr_fmt(fmt) "STB: " fmt
#endif
#include <skiboot.h>
#include <device.h>
#include <nvram.h>
#include <opal-api.h>
#include "secureboot.h"
#include "trustedboot.h"
#include "tpm_chip.h"
/* For debugging only */
//#define STB_DEBUG
static bool trusted_mode = false;
/*
* This maps a PCR for each resource we can measure. The PCR number is
* mapped according to the TCG PC Client Platform Firmware Profile
* specification, Revision 00.21
* Only resources included in this whitelist can be measured.
*/
static struct {
enum resource_id id;
TPM_Pcr pcr;
} resources[] = {
{ RESOURCE_ID_IMA_CATALOG, PCR_2 },
{ RESOURCE_ID_KERNEL, PCR_4 },
{ RESOURCE_ID_CAPP, PCR_2 },
};
static TPM_Pcr map_pcr(enum resource_id id)
{
int i;
for (i = 0; i < ARRAY_SIZE(resources); i++) {
if (resources[i].id == id)
return resources[i].pcr;
}
return -1;
}
void trustedboot_init(void)
{
struct dt_node *node;
node = dt_find_by_path(dt_root, "/ibm,secureboot");
if (!node) {
prlog(PR_NOTICE, "trusted boot not supported\n");
return;
}
if (!secureboot_is_compatible(node, NULL, NULL)) {
/**
* @fwts-label TrustedBootNotCompatible
* @fwts-advice Compatible trustedboot driver not found. Probably,
* hostboot/mambo/skiboot has updated the
* /ibm,secureboot/compatible without adding a driver that
* supports it.
*/
prlog(PR_ERR, "trustedboot init FAILED, '%s' node not "
"compatible.\n", node->name);
return;
}
if (nvram_query_eq("force-trusted-mode", "true")) {
trusted_mode = true;
prlog(PR_NOTICE, "trusted mode on (FORCED by nvram)\n");
} else {
trusted_mode = dt_has_node_property(node, "trusted-enabled", NULL);
prlog(PR_NOTICE, "trusted mode %s\n",
trusted_mode ? "on" : "off");
}
if (!trusted_mode)
return;
cvc_init();
tpm_init();
}
int trustedboot_measure(enum resource_id id, void *buf, size_t len)
{
uint8_t digest[SHA512_DIGEST_LENGTH];
void *buf_aux;
size_t len_aux;
const char *name;
TPM_Pcr pcr;
int rc = -1;
if (!trusted_mode)
return 1;
name = flash_map_resource_name(id);
if (!name) {
/**
* @fwts-label ResourceNotMeasuredUnknown
* @fwts-advice This is a bug in the trustedboot_measure()
* caller, which is passing an unknown resource_id.
*/
prlog(PR_ERR, "resource NOT MEASURED, resource_id=%d unknown\n", id);
return -1;
}
pcr = map_pcr(id);
if (pcr == -1) {
/**
* @fwts-label ResourceNotMappedToPCR
* @fwts-advice This is a bug. The resource cannot be measured
* because it is not mapped to a PCR in the resources[] array.
*/
prlog(PR_ERR, "%s NOT MEASURED, it's not mapped to a PCR\n", name);
return -1;
}
if (!buf) {
/**
* @fwts-label ResourceNotMeasuredNull
* @fwts-advice This is a bug. The trustedboot_measure() caller
* provided a NULL container.
*/
prlog(PR_ERR, "%s NOT MEASURED, it's null\n", name);
return -1;
}
if (stb_is_container(buf, len)) {
buf_aux = buf + SECURE_BOOT_HEADERS_SIZE;
len_aux = len - SECURE_BOOT_HEADERS_SIZE;
} else {
buf_aux = buf;
len_aux = len;
}
rc = call_cvc_sha512(buf_aux, len_aux, digest, SHA512_DIGEST_LENGTH);
if (rc == OPAL_SUCCESS) {
prlog(PR_INFO, "%s hash calculated\n", name);
} else if (rc == OPAL_PARAMETER) {
prlog(PR_ERR, "%s NOT MEASURED, invalid param. buf=%p, "
"len=%zd, digest=%p\n", name, buf_aux,
len_aux, digest);
return -1;
} else if (rc == OPAL_UNSUPPORTED) {
prlog(PR_ERR, "%s NOT MEASURED, CVC-sha512 service not "
"supported\n", name);
return -1;
} else {
prlog(PR_ERR, "%s NOT MEASURED, unknown CVC-sha512 error. "
"rc=%d\n", name, rc);
return -1;
}
#ifdef STB_DEBUG
stb_print_data(digest, TPM_ALG_SHA256_SIZE);
#endif
/*
* Extend the given PCR number in both sha256 and sha1 banks with the
* sha512 hash calculated. The hash is truncated accordingly to fit the
* PCR.
*/
return tpm_extendl(pcr,
TPM_ALG_SHA256, digest, TPM_ALG_SHA256_SIZE,
TPM_ALG_SHA1, digest, TPM_ALG_SHA1_SIZE,
EV_ACTION, name);
}
|
