1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2013
4 * Reinhard Pfau, Guntermann & Drunck GmbH, reinhard.pfau@gdsys.cc
5 */
6
7 #include <common.h>
8 #include <malloc.h>
9 #include <fs.h>
10 #include <i2c.h>
11 #include <mmc.h>
12 #include <tpm-v1.h>
13 #include <u-boot/sha1.h>
14 #include <asm/byteorder.h>
15 #include <asm/unaligned.h>
16 #include <pca9698.h>
17
18 #include "hre.h"
19
20 /* other constants */
21 enum {
22 ESDHC_BOOT_IMAGE_SIG_OFS = 0x40,
23 ESDHC_BOOT_IMAGE_SIZE_OFS = 0x48,
24 ESDHC_BOOT_IMAGE_ADDR_OFS = 0x50,
25 ESDHC_BOOT_IMAGE_TARGET_OFS = 0x58,
26 ESDHC_BOOT_IMAGE_ENTRY_OFS = 0x60,
27 };
28
29 enum {
30 I2C_SOC_0 = 0,
31 I2C_SOC_1 = 1,
32 };
33
34 enum access_mode {
35 HREG_NONE = 0,
36 HREG_RD = 1,
37 HREG_WR = 2,
38 HREG_RDWR = 3,
39 };
40
41 /* register constants */
42 enum {
43 FIX_HREG_DEVICE_ID_HASH = 0,
44 FIX_HREG_UNUSED1 = 1,
45 FIX_HREG_UNUSED2 = 2,
46 FIX_HREG_VENDOR = 3,
47 COUNT_FIX_HREGS
48 };
49
50 static struct h_reg pcr_hregs[24];
51 static struct h_reg fix_hregs[COUNT_FIX_HREGS];
52 static struct h_reg var_hregs[8];
53
54 /* hre opcodes */
55 enum {
56 /* opcodes w/o data */
57 HRE_NOP = 0x00,
58 HRE_SYNC = HRE_NOP,
59 HRE_CHECK0 = 0x01,
60 /* opcodes w/o data, w/ sync dst */
61 /* opcodes w/ data */
62 HRE_LOAD = 0x81,
63 /* opcodes w/data, w/sync dst */
64 HRE_XOR = 0xC1,
65 HRE_AND = 0xC2,
66 HRE_OR = 0xC3,
67 HRE_EXTEND = 0xC4,
68 HRE_LOADKEY = 0xC5,
69 };
70
71 /* hre errors */
72 enum {
73 HRE_E_OK = 0,
74 HRE_E_TPM_FAILURE,
75 HRE_E_INVALID_HREG,
76 };
77
78 static uint64_t device_id;
79 static uint64_t device_cl;
80 static uint64_t device_type;
81
82 static uint32_t platform_key_handle;
83
84 static uint32_t hre_tpm_err;
85 static int hre_err = HRE_E_OK;
86
87 #define IS_PCR_HREG(spec) ((spec) & 0x20)
88 #define IS_FIX_HREG(spec) (((spec) & 0x38) == 0x08)
89 #define IS_VAR_HREG(spec) (((spec) & 0x38) == 0x10)
90 #define HREG_IDX(spec) ((spec) & (IS_PCR_HREG(spec) ? 0x1f : 0x7))
91
92 static const uint8_t vendor[] = "Guntermann & Drunck";
93
94 /**
95 * @brief get the size of a given (TPM) NV area
96 * @param index NV index of the area to get size for
97 * @param size pointer to the size
98 * @return 0 on success, != 0 on error
99 */
get_tpm_nv_size(uint32_t index,uint32_t * size)100 static int get_tpm_nv_size(uint32_t index, uint32_t *size)
101 {
102 uint32_t err;
103 uint8_t info[72];
104 uint8_t *ptr;
105 uint16_t v16;
106
107 err = tpm_get_capability(TPM_CAP_NV_INDEX, index,
108 info, sizeof(info));
109 if (err) {
110 printf("tpm_get_capability(CAP_NV_INDEX, %08x) failed: %u\n",
111 index, err);
112 return 1;
113 }
114
115 /* skip tag and nvIndex */
116 ptr = info + 6;
117 /* skip 2 pcr info fields */
118 v16 = get_unaligned_be16(ptr);
119 ptr += 2 + v16 + 1 + 20;
120 v16 = get_unaligned_be16(ptr);
121 ptr += 2 + v16 + 1 + 20;
122 /* skip permission and flags */
123 ptr += 6 + 3;
124
125 *size = get_unaligned_be32(ptr);
126 return 0;
127 }
128
129 /**
130 * @brief search for a key by usage auth and pub key hash.
131 * @param auth usage auth of the key to search for
132 * @param pubkey_digest (SHA1) hash of the pub key structure of the key
133 * @param[out] handle the handle of the key iff found
134 * @return 0 if key was found in TPM; != 0 if not.
135 */
find_key(const uint8_t auth[20],const uint8_t pubkey_digest[20],uint32_t * handle)136 static int find_key(const uint8_t auth[20], const uint8_t pubkey_digest[20],
137 uint32_t *handle)
138 {
139 uint16_t key_count;
140 uint32_t key_handles[10];
141 uint8_t buf[288];
142 uint8_t *ptr;
143 uint32_t err;
144 uint8_t digest[20];
145 size_t buf_len;
146 unsigned int i;
147
148 /* fetch list of already loaded keys in the TPM */
149 err = tpm_get_capability(TPM_CAP_HANDLE, TPM_RT_KEY, buf, sizeof(buf));
150 if (err)
151 return -1;
152 key_count = get_unaligned_be16(buf);
153 ptr = buf + 2;
154 for (i = 0; i < key_count; ++i, ptr += 4)
155 key_handles[i] = get_unaligned_be32(ptr);
156
157 /* now search a(/ the) key which we can access with the given auth */
158 for (i = 0; i < key_count; ++i) {
159 buf_len = sizeof(buf);
160 err = tpm_get_pub_key_oiap(key_handles[i], auth, buf, &buf_len);
161 if (err && err != TPM_AUTHFAIL)
162 return -1;
163 if (err)
164 continue;
165 sha1_csum(buf, buf_len, digest);
166 if (!memcmp(digest, pubkey_digest, 20)) {
167 *handle = key_handles[i];
168 return 0;
169 }
170 }
171 return 1;
172 }
173
174 /**
175 * @brief read CCDM common data from TPM NV
176 * @return 0 if CCDM common data was found and read, !=0 if something failed.
177 */
read_common_data(void)178 static int read_common_data(void)
179 {
180 uint32_t size = 0;
181 uint32_t err;
182 uint8_t buf[256];
183 sha1_context ctx;
184
185 if (get_tpm_nv_size(NV_COMMON_DATA_INDEX, &size) ||
186 size < NV_COMMON_DATA_MIN_SIZE)
187 return 1;
188 err = tpm_nv_read_value(NV_COMMON_DATA_INDEX,
189 buf, min(sizeof(buf), size));
190 if (err) {
191 printf("tpm_nv_read_value() failed: %u\n", err);
192 return 1;
193 }
194
195 device_id = get_unaligned_be64(buf);
196 device_cl = get_unaligned_be64(buf + 8);
197 device_type = get_unaligned_be64(buf + 16);
198
199 sha1_starts(&ctx);
200 sha1_update(&ctx, buf, 24);
201 sha1_finish(&ctx, fix_hregs[FIX_HREG_DEVICE_ID_HASH].digest);
202 fix_hregs[FIX_HREG_DEVICE_ID_HASH].valid = true;
203
204 platform_key_handle = get_unaligned_be32(buf + 24);
205
206 return 0;
207 }
208
209 /**
210 * @brief get pointer to hash register by specification
211 * @param spec specification of a hash register
212 * @return pointer to hash register or NULL if @a spec does not qualify a
213 * valid hash register; NULL else.
214 */
get_hreg(uint8_t spec)215 static struct h_reg *get_hreg(uint8_t spec)
216 {
217 uint8_t idx;
218
219 idx = HREG_IDX(spec);
220 if (IS_FIX_HREG(spec)) {
221 if (idx < ARRAY_SIZE(fix_hregs))
222 return fix_hregs + idx;
223 hre_err = HRE_E_INVALID_HREG;
224 } else if (IS_PCR_HREG(spec)) {
225 if (idx < ARRAY_SIZE(pcr_hregs))
226 return pcr_hregs + idx;
227 hre_err = HRE_E_INVALID_HREG;
228 } else if (IS_VAR_HREG(spec)) {
229 if (idx < ARRAY_SIZE(var_hregs))
230 return var_hregs + idx;
231 hre_err = HRE_E_INVALID_HREG;
232 }
233 return NULL;
234 }
235
236 /**
237 * @brief get pointer of a hash register by specification and usage.
238 * @param spec specification of a hash register
239 * @param mode access mode (read or write or read/write)
240 * @return pointer to hash register if found and valid; NULL else.
241 *
242 * This func uses @a get_reg() to determine the hash register for a given spec.
243 * If a register is found it is validated according to the desired access mode.
244 * The value of automatic registers (PCR register and fixed registers) is
245 * loaded or computed on read access.
246 */
access_hreg(uint8_t spec,enum access_mode mode)247 static struct h_reg *access_hreg(uint8_t spec, enum access_mode mode)
248 {
249 struct h_reg *result;
250
251 result = get_hreg(spec);
252 if (!result)
253 return NULL;
254
255 if (mode & HREG_WR) {
256 if (IS_FIX_HREG(spec)) {
257 hre_err = HRE_E_INVALID_HREG;
258 return NULL;
259 }
260 }
261 if (mode & HREG_RD) {
262 if (!result->valid) {
263 if (IS_PCR_HREG(spec)) {
264 hre_tpm_err = tpm_pcr_read(HREG_IDX(spec),
265 result->digest, 20);
266 result->valid = (hre_tpm_err == TPM_SUCCESS);
267 } else if (IS_FIX_HREG(spec)) {
268 switch (HREG_IDX(spec)) {
269 case FIX_HREG_DEVICE_ID_HASH:
270 read_common_data();
271 break;
272 case FIX_HREG_VENDOR:
273 memcpy(result->digest, vendor, 20);
274 result->valid = true;
275 break;
276 }
277 } else {
278 result->valid = true;
279 }
280 }
281 if (!result->valid) {
282 hre_err = HRE_E_INVALID_HREG;
283 return NULL;
284 }
285 }
286
287 return result;
288 }
289
compute_and(void * _dst,const void * _src,size_t n)290 static void *compute_and(void *_dst, const void *_src, size_t n)
291 {
292 uint8_t *dst = _dst;
293 const uint8_t *src = _src;
294 size_t i;
295
296 for (i = n; i-- > 0; )
297 *dst++ &= *src++;
298
299 return _dst;
300 }
301
compute_or(void * _dst,const void * _src,size_t n)302 static void *compute_or(void *_dst, const void *_src, size_t n)
303 {
304 uint8_t *dst = _dst;
305 const uint8_t *src = _src;
306 size_t i;
307
308 for (i = n; i-- > 0; )
309 *dst++ |= *src++;
310
311 return _dst;
312 }
313
compute_xor(void * _dst,const void * _src,size_t n)314 static void *compute_xor(void *_dst, const void *_src, size_t n)
315 {
316 uint8_t *dst = _dst;
317 const uint8_t *src = _src;
318 size_t i;
319
320 for (i = n; i-- > 0; )
321 *dst++ ^= *src++;
322
323 return _dst;
324 }
325
compute_extend(void * _dst,const void * _src,size_t n)326 static void *compute_extend(void *_dst, const void *_src, size_t n)
327 {
328 uint8_t digest[20];
329 sha1_context ctx;
330
331 sha1_starts(&ctx);
332 sha1_update(&ctx, _dst, n);
333 sha1_update(&ctx, _src, n);
334 sha1_finish(&ctx, digest);
335 memcpy(_dst, digest, min(n, sizeof(digest)));
336
337 return _dst;
338 }
339
hre_op_loadkey(struct h_reg * src_reg,struct h_reg * dst_reg,const void * key,size_t key_size)340 static int hre_op_loadkey(struct h_reg *src_reg, struct h_reg *dst_reg,
341 const void *key, size_t key_size)
342 {
343 uint32_t parent_handle;
344 uint32_t key_handle;
345
346 if (!src_reg || !dst_reg || !src_reg->valid || !dst_reg->valid)
347 return -1;
348 if (find_key(src_reg->digest, dst_reg->digest, &parent_handle))
349 return -1;
350 hre_tpm_err = tpm_load_key2_oiap(parent_handle, key, key_size,
351 src_reg->digest, &key_handle);
352 if (hre_tpm_err) {
353 hre_err = HRE_E_TPM_FAILURE;
354 return -1;
355 }
356
357 return 0;
358 }
359
360 /**
361 * @brief executes the next opcode on the hash register engine.
362 * @param[in,out] ip pointer to the opcode (instruction pointer)
363 * @param[in,out] code_size (remaining) size of the code
364 * @return new instruction pointer on success, NULL on error.
365 */
hre_execute_op(const uint8_t ** ip,size_t * code_size)366 static const uint8_t *hre_execute_op(const uint8_t **ip, size_t *code_size)
367 {
368 bool dst_modified = false;
369 uint32_t ins;
370 uint8_t opcode;
371 uint8_t src_spec;
372 uint8_t dst_spec;
373 uint16_t data_size;
374 struct h_reg *src_reg, *dst_reg;
375 uint8_t buf[20];
376 const uint8_t *src_buf, *data;
377 uint8_t *ptr;
378 int i;
379 void * (*bin_func)(void *, const void *, size_t);
380
381 if (*code_size < 4)
382 return NULL;
383
384 ins = get_unaligned_be32(*ip);
385 opcode = **ip;
386 data = *ip + 4;
387 src_spec = (ins >> 18) & 0x3f;
388 dst_spec = (ins >> 12) & 0x3f;
389 data_size = (ins & 0x7ff);
390
391 debug("HRE: ins=%08x (op=%02x, s=%02x, d=%02x, L=%d)\n", ins,
392 opcode, src_spec, dst_spec, data_size);
393
394 if ((opcode & 0x80) && (data_size + 4) > *code_size)
395 return NULL;
396
397 src_reg = access_hreg(src_spec, HREG_RD);
398 if (hre_err || hre_tpm_err)
399 return NULL;
400 dst_reg = access_hreg(dst_spec, (opcode & 0x40) ? HREG_RDWR : HREG_WR);
401 if (hre_err || hre_tpm_err)
402 return NULL;
403
404 switch (opcode) {
405 case HRE_NOP:
406 goto end;
407 case HRE_CHECK0:
408 if (src_reg) {
409 for (i = 0; i < 20; ++i) {
410 if (src_reg->digest[i])
411 return NULL;
412 }
413 }
414 break;
415 case HRE_LOAD:
416 bin_func = memcpy;
417 goto do_bin_func;
418 case HRE_XOR:
419 bin_func = compute_xor;
420 goto do_bin_func;
421 case HRE_AND:
422 bin_func = compute_and;
423 goto do_bin_func;
424 case HRE_OR:
425 bin_func = compute_or;
426 goto do_bin_func;
427 case HRE_EXTEND:
428 bin_func = compute_extend;
429 do_bin_func:
430 if (!dst_reg)
431 return NULL;
432 if (src_reg) {
433 src_buf = src_reg->digest;
434 } else {
435 if (!data_size) {
436 memset(buf, 0, 20);
437 src_buf = buf;
438 } else if (data_size == 1) {
439 memset(buf, *data, 20);
440 src_buf = buf;
441 } else if (data_size >= 20) {
442 src_buf = data;
443 } else {
444 src_buf = buf;
445 for (ptr = (uint8_t *)src_buf, i = 20; i > 0;
446 i -= data_size, ptr += data_size)
447 memcpy(ptr, data,
448 min_t(size_t, i, data_size));
449 }
450 }
451 bin_func(dst_reg->digest, src_buf, 20);
452 dst_reg->valid = true;
453 dst_modified = true;
454 break;
455 case HRE_LOADKEY:
456 if (hre_op_loadkey(src_reg, dst_reg, data, data_size))
457 return NULL;
458 break;
459 default:
460 return NULL;
461 }
462
463 if (dst_reg && dst_modified && IS_PCR_HREG(dst_spec)) {
464 hre_tpm_err = tpm_extend(HREG_IDX(dst_spec), dst_reg->digest,
465 dst_reg->digest);
466 if (hre_tpm_err) {
467 hre_err = HRE_E_TPM_FAILURE;
468 return NULL;
469 }
470 }
471 end:
472 *ip += 4;
473 *code_size -= 4;
474 if (opcode & 0x80) {
475 *ip += data_size;
476 *code_size -= data_size;
477 }
478
479 return *ip;
480 }
481
482 /**
483 * @brief runs a program on the hash register engine.
484 * @param code pointer to the (HRE) code.
485 * @param code_size size of the code (in bytes).
486 * @return 0 on success, != 0 on failure.
487 */
hre_run_program(const uint8_t * code,size_t code_size)488 int hre_run_program(const uint8_t *code, size_t code_size)
489 {
490 size_t code_left;
491 const uint8_t *ip = code;
492
493 code_left = code_size;
494 hre_tpm_err = 0;
495 hre_err = HRE_E_OK;
496 while (code_left > 0)
497 if (!hre_execute_op(&ip, &code_left))
498 return -1;
499
500 return hre_err;
501 }
502
hre_verify_program(struct key_program * prg)503 int hre_verify_program(struct key_program *prg)
504 {
505 uint32_t crc;
506
507 crc = crc32(0, prg->code, prg->code_size);
508
509 if (crc != prg->code_crc) {
510 printf("HRC crc mismatch: %08x != %08x\n",
511 crc, prg->code_crc);
512 return 1;
513 }
514 return 0;
515 }
516