a955f536bbf18d7e314a430639868bb26d06ff19
[akaros.git] / kern / lib / crypto / 2misc.c
1 /* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
2  * Use of this source code is governed by a BSD-style license that can be
3  * found in the LICENSE file.
4  *
5  * Misc functions which need access to vb2_context but are not public APIs
6  */
7
8 #include "2sysincludes.h"
9 #include "2api.h"
10 #include "2common.h"
11 #include "2misc.h"
12 #include "2nvstorage.h"
13 #include "2secdata.h"
14 #include "2sha.h"
15 #include "2rsa.h"
16
17 int vb2_validate_gbb_signature(uint8_t *sig) {
18         const static uint8_t sig_xor[VB2_GBB_SIGNATURE_SIZE] =
19                         VB2_GBB_XOR_SIGNATURE;
20         int i;
21         for (i = 0; i < VB2_GBB_SIGNATURE_SIZE; i++) {
22                 if (sig[i] != (sig_xor[i] ^ VB2_GBB_XOR_CHARS[i]))
23                         return VB2_ERROR_GBB_MAGIC;
24         }
25         return VB2_SUCCESS;
26 }
27
28 void vb2_workbuf_from_ctx(struct vb2_context *ctx, struct vb2_workbuf *wb)
29 {
30         vb2_workbuf_init(wb, ctx->workbuf + ctx->workbuf_used,
31                          ctx->workbuf_size - ctx->workbuf_used);
32 }
33
34 int vb2_read_gbb_header(struct vb2_context *ctx, struct vb2_gbb_header *gbb)
35 {
36         int rv;
37
38         /* Read the entire header */
39         rv = vb2ex_read_resource(ctx, VB2_RES_GBB, 0, gbb, sizeof(*gbb));
40         if (rv)
41                 return rv;
42
43         /* Make sure it's really a GBB */
44         rv = vb2_validate_gbb_signature(gbb->signature);
45         if (rv)
46                 return rv;
47
48         /* Check for compatible version */
49         if (gbb->major_version != VB2_GBB_MAJOR_VER)
50                 return VB2_ERROR_GBB_VERSION;
51
52         /* Current code is not backwards-compatible to 1.1 headers or older */
53         if (gbb->minor_version < VB2_GBB_MINOR_VER)
54                 return VB2_ERROR_GBB_TOO_OLD;
55
56         /*
57          * Header size should be at least as big as we expect.  It could be
58          * bigger, if the header has grown.
59          */
60         if (gbb->header_size < sizeof(*gbb))
61                 return VB2_ERROR_GBB_HEADER_SIZE;
62
63         return VB2_SUCCESS;
64 }
65
66 void vb2_fail(struct vb2_context *ctx, uint8_t reason, uint8_t subcode)
67 {
68         struct vb2_shared_data *sd = vb2_get_sd(ctx);
69
70         /* If NV data hasn't been initialized, initialize it now */
71         if (!(sd->status & VB2_SD_STATUS_NV_INIT))
72                 vb2_nv_init(ctx);
73
74         /* See if we were far enough in the boot process to choose a slot */
75         if (sd->status & VB2_SD_STATUS_CHOSE_SLOT) {
76
77                 /* Boot failed */
78                 vb2_nv_set(ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_FAILURE);
79
80                 /* Use up remaining tries */
81                 vb2_nv_set(ctx, VB2_NV_TRY_COUNT, 0);
82
83                 /*
84                  * Try the other slot next time.  We'll alternate
85                  * between slots, which may help if one or both slots is
86                  * flaky.
87                  */
88                 vb2_nv_set(ctx, VB2_NV_TRY_NEXT, 1 - sd->fw_slot);
89
90                 /*
91                  * If we didn't try the other slot last boot, or we tried it
92                  * and it didn't fail, try it next boot.
93                  */
94                 if (sd->last_fw_slot != 1 - sd->fw_slot ||
95                     sd->last_fw_result != VB2_FW_RESULT_FAILURE)
96                         return;
97         }
98
99         /*
100          * If we're still here, we failed before choosing a slot, or both
101          * this slot and the other slot failed in successive boots.  So we
102          * need to go to recovery.
103          *
104          * Set a recovery reason and subcode only if they're not already set.
105          * If recovery is already requested, it's a more specific error code
106          * than later code is providing and we shouldn't overwrite it.
107          */
108         VB2_DEBUG("Need recovery, reason: %#x / %#x\n", reason, subcode);
109         if (!vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST)) {
110                 vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, reason);
111                 vb2_nv_set(ctx, VB2_NV_RECOVERY_SUBCODE, subcode);
112         }
113 }
114
115 int vb2_init_context(struct vb2_context *ctx)
116 {
117         struct vb2_shared_data *sd = vb2_get_sd(ctx);
118
119         /* Don't do anything if the context has already been initialized */
120         if (ctx->workbuf_used)
121                 return VB2_SUCCESS;
122
123         /*
124          * Workbuf had better be big enough for our shared data struct and
125          * aligned.  Not much we can do if it isn't; we'll die before we can
126          * store a recovery reason.
127          */
128         if (ctx->workbuf_size < sizeof(*sd))
129                 return VB2_ERROR_INITCTX_WORKBUF_SMALL;
130         if (!vb2_aligned(ctx->workbuf, VB2_WORKBUF_ALIGN))
131                 return VB2_ERROR_INITCTX_WORKBUF_ALIGN;
132
133         /* Initialize the shared data at the start of the work buffer */
134         memset(sd, 0, sizeof(*sd));
135         ctx->workbuf_used = sizeof(*sd);
136         return VB2_SUCCESS;
137 }
138
139 void vb2_check_recovery(struct vb2_context *ctx)
140 {
141         struct vb2_shared_data *sd = vb2_get_sd(ctx);
142         uint32_t reason = vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST);
143         uint32_t subcode = vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE);
144
145         VB2_DEBUG("Recovery reason from previous boot: %#x / %#x\n",
146                   reason, subcode);
147
148         /*
149          * Sets the current recovery request, unless there's already been a
150          * failure earlier in the boot process.
151          */
152         if (!sd->recovery_reason)
153                 sd->recovery_reason = reason;
154
155         /* Clear request and subcode so we don't get stuck in recovery mode */
156         vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_NOT_REQUESTED);
157         vb2_nv_set(ctx, VB2_NV_RECOVERY_SUBCODE, VB2_RECOVERY_NOT_REQUESTED);
158
159         if (ctx->flags & VB2_CONTEXT_FORCE_RECOVERY_MODE) {
160                 VB2_DEBUG("Recovery was requested manually\n");
161                 if (subcode && !sd->recovery_reason)
162                         /*
163                          * Recovery was requested at 'broken' screen.
164                          * Promote subcode to reason.
165                          */
166                         sd->recovery_reason = subcode;
167                 else
168                         /* Recovery was forced. Override recovery reason */
169                         sd->recovery_reason = VB2_RECOVERY_RO_MANUAL;
170                 sd->flags |= VB2_SD_FLAG_MANUAL_RECOVERY;
171         }
172
173         /* If recovery reason is non-zero, tell caller we need recovery mode */
174         if (sd->recovery_reason) {
175                 ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
176                 VB2_DEBUG("We have a recovery request: %#x / %#x\n",
177                           sd->recovery_reason,
178                           vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE));
179         }
180 }
181
182 int vb2_fw_parse_gbb(struct vb2_context *ctx)
183 {
184         struct vb2_shared_data *sd = vb2_get_sd(ctx);
185         struct vb2_gbb_header *gbb;
186         struct vb2_workbuf wb;
187         int rv;
188
189         vb2_workbuf_from_ctx(ctx, &wb);
190
191         /* Read GBB into next chunk of work buffer */
192         gbb = vb2_workbuf_alloc(&wb, sizeof(*gbb));
193         if (!gbb)
194                 return VB2_ERROR_GBB_WORKBUF;
195
196         rv = vb2_read_gbb_header(ctx, gbb);
197         if (rv)
198                 return rv;
199
200         /* Extract the only things we care about at firmware time */
201         sd->gbb_flags = gbb->flags;
202         sd->gbb_rootkey_offset = gbb->rootkey_offset;
203         sd->gbb_rootkey_size = gbb->rootkey_size;
204         memcpy(sd->gbb_hwid_digest, gbb->hwid_digest, VB2_GBB_HWID_DIGEST_SIZE);
205
206         return VB2_SUCCESS;
207 }
208
209 int vb2_check_dev_switch(struct vb2_context *ctx)
210 {
211         struct vb2_shared_data *sd = vb2_get_sd(ctx);
212         uint32_t flags = 0;
213         uint32_t old_flags;
214         int is_dev = 0;
215         int use_secdata = 1;
216         int rv;
217
218         /* Read secure flags */
219         rv = vb2_secdata_get(ctx, VB2_SECDATA_FLAGS, &flags);
220         if (rv) {
221                 if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) {
222                         /*
223                          * Recovery mode needs to check other ways developer
224                          * mode can be enabled, so don't give up yet.  But
225                          * since we can't read secdata, assume dev mode was
226                          * disabled.
227                          */
228                         use_secdata = 0;
229                         flags = 0;
230                 } else {
231                         /* Normal mode simply fails */
232                         return rv;
233                 }
234         }
235         old_flags = flags;
236
237         /* Handle dev disable request */
238         if (use_secdata && vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST)) {
239                 flags &= ~VB2_SECDATA_FLAG_DEV_MODE;
240
241                 /* Clear the request */
242                 vb2_nv_set(ctx, VB2_NV_DISABLE_DEV_REQUEST, 0);
243         }
244
245         /*
246          * Check if we've been asked by the caller to disable dev mode.  Note
247          * that hardware switch and GBB flag will take precedence over this.
248          */
249         if (ctx->flags & VB2_DISABLE_DEVELOPER_MODE)
250                 flags &= ~VB2_SECDATA_FLAG_DEV_MODE;
251
252         /* Check virtual dev switch */
253         if (flags & VB2_SECDATA_FLAG_DEV_MODE)
254                 is_dev = 1;
255
256         /* Handle forcing dev mode via physical switch */
257         if (ctx->flags & VB2_CONTEXT_FORCE_DEVELOPER_MODE)
258                 is_dev = 1;
259
260         /* Check if GBB is forcing dev mode */
261         if (sd->gbb_flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON)
262                 is_dev = 1;
263
264         /* Handle whichever mode we end up in */
265         if (is_dev) {
266                 /* Developer mode */
267                 sd->flags |= VB2_SD_DEV_MODE_ENABLED;
268                 ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
269
270                 flags |= VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER;
271         } else {
272                 /* Normal mode */
273                 flags &= ~VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER;
274
275                 /*
276                  * Disable dev_boot_* flags.  This ensures they will be
277                  * initially disabled if the user later transitions back into
278                  * developer mode.
279                  */
280                 vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 0);
281                 vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 0);
282                 vb2_nv_set(ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 0);
283                 vb2_nv_set(ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 0);
284                 vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, 0);
285                 vb2_nv_set(ctx, VB2_NV_FASTBOOT_UNLOCK_IN_FW, 0);
286         }
287
288         if (ctx->flags & VB2_CONTEXT_FORCE_WIPEOUT_MODE)
289                 vb2_nv_set(ctx, VB2_NV_REQ_WIPEOUT, 1);
290
291         if (flags != old_flags) {
292                 /*
293                  * Just changed dev mode state.  Clear TPM owner.  This must be
294                  * done here instead of simply passing a flag to
295                  * vb2_check_tpm_clear(), because we don't want to update
296                  * last_boot_developer and then fail to clear the TPM owner.
297                  *
298                  * Note that we do this even if we couldn't read secdata, since
299                  * the TPM owner and secdata may be independent, and we want
300                  * the owner to be cleared if *this boot* is different than the
301                  * last one (perhaps due to GBB or hardware override).
302                  */
303                 rv = vb2ex_tpm_clear_owner(ctx);
304                 if (use_secdata) {
305                         /* Check for failure to clear owner */
306                         if (rv) {
307                                 /*
308                                  * Note that this truncates rv to 8 bit.  Which
309                                  * is not as useful as the full error code, but
310                                  * we don't have NVRAM space to store the full
311                                  * 32-bit code.
312                                  */
313                                 vb2_fail(ctx, VB2_RECOVERY_TPM_CLEAR_OWNER, rv);
314                                 return rv;
315                         }
316
317                         /* Save new flags */
318                         rv = vb2_secdata_set(ctx, VB2_SECDATA_FLAGS, flags);
319                         if (rv)
320                                 return rv;
321                 }
322         }
323
324         return VB2_SUCCESS;
325 }
326
327 int vb2_check_tpm_clear(struct vb2_context *ctx)
328 {
329         int rv;
330
331         /* Check if we've been asked to clear the owner */
332         if (!vb2_nv_get(ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST))
333                 return VB2_SUCCESS;  /* No need to clear */
334
335         /* Request applies one time only */
336         vb2_nv_set(ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 0);
337
338         /* Try clearing */
339         rv = vb2ex_tpm_clear_owner(ctx);
340         if (rv) {
341                 /*
342                  * Note that this truncates rv to 8 bit.  Which is not as
343                  * useful as the full error code, but we don't have NVRAM space
344                  * to store the full 32-bit code.
345                  */
346                 vb2_fail(ctx, VB2_RECOVERY_TPM_CLEAR_OWNER, rv);
347                 return rv;
348         }
349
350         /* Clear successful */
351         vb2_nv_set(ctx, VB2_NV_CLEAR_TPM_OWNER_DONE, 1);
352         return VB2_SUCCESS;
353 }
354
355 int vb2_select_fw_slot(struct vb2_context *ctx)
356 {
357         struct vb2_shared_data *sd = vb2_get_sd(ctx);
358         uint32_t tries;
359
360         /* Get result of last boot */
361         sd->last_fw_slot = vb2_nv_get(ctx, VB2_NV_FW_TRIED);
362         sd->last_fw_result = vb2_nv_get(ctx, VB2_NV_FW_RESULT);
363
364         /* Save to the previous result fields in NV storage */
365         vb2_nv_set(ctx, VB2_NV_FW_PREV_TRIED, sd->last_fw_slot);
366         vb2_nv_set(ctx, VB2_NV_FW_PREV_RESULT, sd->last_fw_result);
367
368         /* Clear result, since we don't know what will happen this boot */
369         vb2_nv_set(ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_UNKNOWN);
370
371         /* Get slot to try */
372         sd->fw_slot = vb2_nv_get(ctx, VB2_NV_TRY_NEXT);
373
374         /* Check try count */
375         tries = vb2_nv_get(ctx, VB2_NV_TRY_COUNT);
376
377         if (sd->last_fw_result == VB2_FW_RESULT_TRYING &&
378             sd->last_fw_slot == sd->fw_slot &&
379             tries == 0) {
380                 /*
381                  * We used up our last try on the previous boot, so fall back
382                  * to the other slot this boot.
383                  */
384                 sd->fw_slot = 1 - sd->fw_slot;
385                 vb2_nv_set(ctx, VB2_NV_TRY_NEXT, sd->fw_slot);
386         }
387
388         if (tries > 0) {
389                 /* Still trying this firmware */
390                 vb2_nv_set(ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
391
392                 /* Decrement non-zero try count, unless told not to */
393                 if (!(ctx->flags & VB2_CONTEXT_NOFAIL_BOOT))
394                         vb2_nv_set(ctx, VB2_NV_TRY_COUNT, tries - 1);
395         }
396
397         /* Store the slot we're trying */
398         vb2_nv_set(ctx, VB2_NV_FW_TRIED, sd->fw_slot);
399
400         /* Set context flag if we're using slot B */
401         if (sd->fw_slot)
402                 ctx->flags |= VB2_CONTEXT_FW_SLOT_B;
403
404         /* Set status flag */
405         sd->status |= VB2_SD_STATUS_CHOSE_SLOT;
406
407         return VB2_SUCCESS;
408 }