1 /* Copyright 2014 The ChromiumOS Authors
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 *
5 * Common functions between firmware and kernel verified boot.
6 * (Firmware portion)
7 */
8
9 #include "2common.h"
10 #include "2rsa.h"
11
12 test_mockable
vb2_safe_memcmp(const void * s1,const void * s2,size_t size)13 vb2_error_t vb2_safe_memcmp(const void *s1, const void *s2, size_t size)
14 {
15 const unsigned char *us1 = s1;
16 const unsigned char *us2 = s2;
17 int result = 0;
18
19 if (0 == size)
20 return 0;
21
22 /*
23 * Code snippet without data-dependent branch due to Nate Lawson
24 * ([email protected]) of Root Labs.
25 */
26 while (size--)
27 result |= *us1++ ^ *us2++;
28
29 return result != 0;
30 }
31
vb2_align(uint8_t ** ptr,uint32_t * size,uint32_t align,uint32_t want_size)32 vb2_error_t vb2_align(uint8_t **ptr, uint32_t *size, uint32_t align,
33 uint32_t want_size)
34 {
35 uintptr_t p = (uintptr_t)*ptr;
36 uintptr_t offs = p & (align - 1);
37
38 if (offs) {
39 offs = align - offs;
40
41 if (*size < offs)
42 return VB2_ERROR_ALIGN_BIGGER_THAN_SIZE;
43
44 *ptr += offs;
45 *size -= offs;
46 }
47
48 if (*size < want_size)
49 return VB2_ERROR_ALIGN_SIZE;
50
51 return VB2_SUCCESS;
52 }
53
vb2_workbuf_init(struct vb2_workbuf * wb,uint8_t * buf,uint32_t size)54 void vb2_workbuf_init(struct vb2_workbuf *wb, uint8_t *buf, uint32_t size)
55 {
56 wb->buf = buf;
57 wb->size = size;
58
59 /* Align the buffer so allocations will be aligned */
60 if (vb2_align(&wb->buf, &wb->size, VB2_WORKBUF_ALIGN, 0))
61 wb->size = 0;
62 }
63
vb2_workbuf_alloc(struct vb2_workbuf * wb,uint32_t size)64 void *vb2_workbuf_alloc(struct vb2_workbuf *wb, uint32_t size)
65 {
66 uint8_t *ptr = wb->buf;
67
68 /* Round up size to work buffer alignment */
69 size = vb2_wb_round_up(size);
70
71 if (size > wb->size)
72 return NULL;
73
74 wb->buf += size;
75 wb->size -= size;
76
77 return ptr;
78 }
79
vb2_workbuf_realloc(struct vb2_workbuf * wb,uint32_t oldsize,uint32_t newsize)80 void *vb2_workbuf_realloc(struct vb2_workbuf *wb, uint32_t oldsize,
81 uint32_t newsize)
82 {
83 /*
84 * Just free and allocate to update the size. No need to move/copy
85 * memory, since the new pointer is guaranteed to be the same as the
86 * old one. The new allocation can fail, if the new size is too big.
87 */
88 vb2_workbuf_free(wb, oldsize);
89 return vb2_workbuf_alloc(wb, newsize);
90 }
91
vb2_workbuf_free(struct vb2_workbuf * wb,uint32_t size)92 void vb2_workbuf_free(struct vb2_workbuf *wb, uint32_t size)
93 {
94 /* Round up size to work buffer alignment */
95 size = vb2_wb_round_up(size);
96
97 wb->buf -= size;
98 wb->size += size;
99 }
100
vb2_offset_of(const void * base,const void * ptr)101 ptrdiff_t vb2_offset_of(const void *base, const void *ptr)
102 {
103 return (uintptr_t)ptr - (uintptr_t)base;
104 }
105
vb2_member_of(void * parent,ptrdiff_t offset)106 void *vb2_member_of(void *parent, ptrdiff_t offset)
107 {
108 /* TODO(kitching): vb2_assert(parent && offset) */
109 return parent + offset;
110 }
111
vb2_verify_member_inside(const void * parent,size_t parent_size,const void * member,size_t member_size,ptrdiff_t member_data_offset,size_t member_data_size)112 vb2_error_t vb2_verify_member_inside(const void *parent, size_t parent_size,
113 const void *member, size_t member_size,
114 ptrdiff_t member_data_offset,
115 size_t member_data_size)
116 {
117 const uintptr_t parent_end = (uintptr_t)parent + parent_size;
118 const ptrdiff_t member_offs = vb2_offset_of(parent, member);
119 const ptrdiff_t member_end_offs = member_offs + member_size;
120 const ptrdiff_t data_offs = member_offs + member_data_offset;
121 const ptrdiff_t data_end_offs = data_offs + member_data_size;
122
123 /* Make sure parent doesn't wrap */
124 if (parent_end < (uintptr_t)parent)
125 return VB2_ERROR_INSIDE_PARENT_WRAPS;
126
127 /*
128 * Make sure the member is fully contained in the parent and doesn't
129 * wrap. Use >, not >=, since member_size = 0 is possible.
130 */
131 if (member_end_offs < member_offs)
132 return VB2_ERROR_INSIDE_MEMBER_WRAPS;
133 if (member_offs < 0 || member_offs > parent_size ||
134 member_end_offs > parent_size)
135 return VB2_ERROR_INSIDE_MEMBER_OUTSIDE;
136
137 /* Make sure the member data is after the member */
138 if (member_data_size > 0 && data_offs < member_end_offs)
139 return VB2_ERROR_INSIDE_DATA_OVERLAP;
140
141 /* Make sure parent fully contains member data, if any */
142 if (data_end_offs < data_offs)
143 return VB2_ERROR_INSIDE_DATA_WRAPS;
144 if (data_offs < 0 || data_offs > parent_size ||
145 data_end_offs > parent_size)
146 return VB2_ERROR_INSIDE_DATA_OUTSIDE;
147
148 return VB2_SUCCESS;
149 }
150
151 test_mockable
vb2_verify_digest(const struct vb2_public_key * key,struct vb2_signature * sig,const uint8_t * digest,const struct vb2_workbuf * wb)152 vb2_error_t vb2_verify_digest(const struct vb2_public_key *key,
153 struct vb2_signature *sig, const uint8_t *digest,
154 const struct vb2_workbuf *wb)
155 {
156 /* A signature is destroyed in the process of being verified. */
157 uint8_t *sig_data = vb2_signature_data_mutable(sig);
158
159 if (!sig->data_size)
160 return VB2_ERROR_VDATA_NOT_ENOUGH_DATA;
161
162 if (sig->sig_size != vb2_rsa_sig_size(key->sig_alg)) {
163 VB2_DEBUG("Wrong data signature size for algorithm, "
164 "sig_size=%d, expected %d for algorithm %d.\n",
165 sig->sig_size, vb2_rsa_sig_size(key->sig_alg),
166 key->sig_alg);
167 return VB2_ERROR_VDATA_SIG_SIZE;
168 }
169
170 if (key->allow_hwcrypto) {
171 vb2_error_t rv =
172 vb2ex_hwcrypto_rsa_verify_digest(key, sig_data, digest);
173
174 if (rv != VB2_ERROR_EX_HWCRYPTO_UNSUPPORTED) {
175 VB2_DEBUG("Using HW RSA engine for sig_alg %d %s\n",
176 key->sig_alg,
177 rv ? "failed" : "succeeded");
178 return rv;
179 }
180
181 VB2_DEBUG("HW RSA for sig_alg %d not supported, using SW\n",
182 key->sig_alg);
183 } else {
184 VB2_DEBUG("HW RSA forbidden, using SW\n");
185 }
186
187 return vb2_rsa_verify_digest(key, sig_data, digest, wb);
188 }
189
190 test_mockable
vb2_verify_data(const uint8_t * data,uint32_t size,struct vb2_signature * sig,const struct vb2_public_key * key,const struct vb2_workbuf * wb)191 vb2_error_t vb2_verify_data(const uint8_t *data, uint32_t size,
192 struct vb2_signature *sig,
193 const struct vb2_public_key *key,
194 const struct vb2_workbuf *wb)
195 {
196 struct vb2_hash hash;
197
198 if (sig->data_size > size) {
199 VB2_DEBUG("Data buffer smaller than length of signed data.\n");
200 return VB2_ERROR_VDATA_NOT_ENOUGH_DATA;
201 }
202
203 VB2_TRY(vb2_hash_calculate(key->allow_hwcrypto, data, sig->data_size,
204 key->hash_alg, &hash));
205
206 return vb2_verify_digest(key, sig, hash.raw, wb);
207 }
208