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
|
/* Copyright 2013-2016 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 __STB_CONTAINER_H
#define __STB_CONTAINER_H
#include <stdint.h>
#include <stdlib.h>
#include <ccan/endian/endian.h>
#define SECURE_BOOT_HEADERS_SIZE 4096
#define SHA256_DIGEST_LENGTH 32
/*
* The defines and structures below come from the secure ROM source code
* (trusted_boot_rom). Here you will find only the ones required by the
* secure and trusted boot implementation in skiboot.
*/
/* From trusted_boot_rom/src/sha512.h */
#define SHA512_DIGEST_LENGTH 64
typedef uint8_t __attribute__((aligned(8))) sha2_hash_t[ SHA512_DIGEST_LENGTH / sizeof(uint8_t) ];
typedef uint8_t sha2_byte; // Exactly 1 byte
/* From trusted_boot_rom/src/hw_utils.h */
#define ECID_SIZE 16
/* From trusted_boot_rom/src/ecverify.h */
#define EC_COORDBYTES 66 /* P-521 */
typedef uint8_t ecc_key_t[2*EC_COORDBYTES];
typedef uint8_t ecc_signature_t[2*EC_COORDBYTES];
/* From trusted_boot_rom/src/ROM.h */
#define ROM_MAGIC_NUMBER 0x17082011
typedef struct {
be16 version; /* (1: see versions above) */
uint8_t hash_alg; /* (1: SHA-512) */
uint8_t sig_alg; /* (1: SHA-512/ECDSA-521) */
}__attribute__((packed)) ROM_version_raw;
typedef struct {
ROM_version_raw ver_alg;
be64 code_start_offset;
be64 reserved;
be32 flags;
uint8_t sw_key_count;
be64 payload_size;
sha2_hash_t payload_hash;
uint8_t ecid_count;
struct { uint8_t ecid[ECID_SIZE]; } ecid[0]; /* optional ecid place
holder ecid_count * ecid_size(128 bits) */
/* followed by prefix data (sig,keys) key raw */
}__attribute__((packed)) ROM_prefix_header_raw;
typedef struct {
be32 magic_number; /* (17082011) */
be16 version; /* (1: see versions above) */
be64 container_size; /* filled by caller */
be64 target_hrmor; /* filled by caller */
be64 stack_pointer; /* filled by caller */
/* bottom of stack -> 128k added by rom code to get real stack pointer */
ecc_key_t hw_pkey_a;
ecc_key_t hw_pkey_b;
ecc_key_t hw_pkey_c;
/* followed by sw header (if not special prefix) */
/* followed by optional unprotected payload data */
}__attribute__((packed)) ROM_container_raw;
typedef struct {
ecc_signature_t hw_sig_a;
ecc_signature_t hw_sig_b;
ecc_signature_t hw_sig_c;
ecc_key_t sw_pkey_p;
ecc_key_t sw_pkey_q;
ecc_key_t sw_pkey_r;
}__attribute__((packed)) ROM_prefix_data_raw;
typedef struct {
ROM_version_raw ver_alg;
be64 code_start_offset;
be64 reserved;
be32 flags;
uint8_t reserved_0;
be64 payload_size;
sha2_hash_t payload_hash;
uint8_t ecid_count;
struct { uint8_t ecid[ECID_SIZE]; } ecid[0]; /* optional ecid place
holder ecid_count * ecid_size(128 bits) */
/* followed by sw sig raw */
}__attribute__((packed)) ROM_sw_header_raw;
typedef struct {
ecc_signature_t sw_sig_p;
ecc_signature_t sw_sig_q;
ecc_signature_t sw_sig_r;
/* followed by zero's padding to 4K */
/* followed by protected sw payload_data */
/* followed by unprotected sw payload_text */
}__attribute__((packed)) ROM_sw_sig_raw;
typedef enum { ROM_DONE, ROM_FAILED, PHYP_PARTIAL } ROM_response;
typedef struct {
sha2_hash_t hw_key_hash;
uint8_t my_ecid[ECID_SIZE];
be64 entry_point;
be64 log;
}__attribute__((packed)) ROM_hw_params;
struct parsed_stb_container {
const void *buf;
size_t bufsz;
const ROM_container_raw *c;
const ROM_prefix_header_raw *ph;
const ROM_prefix_data_raw *pd;
const ROM_sw_header_raw *sh;
const ROM_sw_sig_raw *ssig;
};
/*
* Helper functions
*/
/* Get the container payload eyecatcher */
uint32_t stb_payload_magic(const void *buf, size_t size);
/* Check if buf is a secure boot container */
bool stb_is_container(const void* buf, size_t size);
/* Get the pointer for the sw-payload-hash field of the container header */
const uint8_t* stb_sw_payload_hash(const void* buf, size_t size);
uint64_t stb_sw_payload_size(const void *buf, size_t size);
int parse_stb_container(const void* data, size_t len, struct parsed_stb_container *c);
void stb_print_data(const void *data, size_t len);
void getPublicKeyRaw(ecc_key_t *pubkeyraw, char *inFile);
void getSigRaw(ecc_signature_t *sigraw, char *inFile);
void writeHdr(void *ph, const char *outFile, int hdr_type);
void printBytes(char *lead, unsigned char *buffer, size_t buflen, int wrap);
#endif /* __STB_CONTAINER_H */
|
