1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright 2018 Linaro Limited
4 * Author: AKASHI Takahiro
14 #include <linux/types.h>
17 #include <sys/types.h>
18 #include <uuid/uuid.h>
19 #include <linux/kconfig.h>
21 #include <gnutls/gnutls.h>
22 #include <gnutls/pkcs7.h>
23 #include <gnutls/abstract.h>
25 #include "eficapsule.h"
27 static const char *tool_name = "mkeficapsule";
29 efi_guid_t efi_guid_fm_capsule = EFI_FIRMWARE_MANAGEMENT_CAPSULE_ID_GUID;
30 efi_guid_t efi_guid_image_type_uboot_fit =
31 EFI_FIRMWARE_IMAGE_TYPE_UBOOT_FIT_GUID;
32 efi_guid_t efi_guid_image_type_uboot_raw =
33 EFI_FIRMWARE_IMAGE_TYPE_UBOOT_RAW_GUID;
34 efi_guid_t efi_guid_cert_type_pkcs7 = EFI_CERT_TYPE_PKCS7_GUID;
36 static const char *opts_short = "frg:i:I:v:p:c:m:dh";
38 static struct option options[] = {
39 {"fit", no_argument, NULL, 'f'},
40 {"raw", no_argument, NULL, 'r'},
41 {"guid", required_argument, NULL, 'g'},
42 {"index", required_argument, NULL, 'i'},
43 {"instance", required_argument, NULL, 'I'},
44 {"private-key", required_argument, NULL, 'p'},
45 {"certificate", required_argument, NULL, 'c'},
46 {"monotonic-count", required_argument, NULL, 'm'},
47 {"dump-sig", no_argument, NULL, 'd'},
48 {"help", no_argument, NULL, 'h'},
52 static void print_usage(void)
54 fprintf(stderr, "Usage: %s [options] <image blob> <output file>\n"
57 "\t-f, --fit FIT image type\n"
58 "\t-r, --raw raw image type\n"
59 "\t-g, --guid <guid string> guid for image blob type\n"
60 "\t-i, --index <index> update image index\n"
61 "\t-I, --instance <instance> update hardware instance\n"
62 "\t-p, --private-key <privkey file> private key file\n"
63 "\t-c, --certificate <cert file> signer's certificate file\n"
64 "\t-m, --monotonic-count <count> monotonic count\n"
65 "\t-d, --dump_sig dump signature (*.p7)\n"
66 "\t-h, --help print a help message\n",
71 * auth_context - authentication context
72 * @key_file: Path to a private key file
73 * @cert_file: Path to a certificate file
74 * @image_data: Pointer to firmware data
75 * @image_size: Size of firmware data
76 * @auth: Authentication header
77 * @sig_data: Signature data
78 * @sig_size: Size of signature data
80 * Data structure used in create_auth_data(). @key_file through
81 * @image_size are input parameters. @auth, @sig_data and @sig_size
82 * are filled in by create_auth_data().
89 struct efi_firmware_image_authentication auth;
97 * read_bin_file - read a firmware binary file
98 * @bin: Path to a firmware binary file
99 * @data: Pointer to pointer of allocated buffer
100 * @bin_size: Size of allocated buffer
102 * Read out a content of binary, @bin, into @data.
103 * A caller should free @data.
109 static int read_bin_file(char *bin, uint8_t **data, off_t *bin_size)
112 struct stat bin_stat;
119 fprintf(stderr, "cannot open %s\n", bin);
122 if (stat(bin, &bin_stat) < 0) {
123 fprintf(stderr, "cannot determine the size of %s\n", bin);
127 if (bin_stat.st_size > SIZE_MAX) {
128 fprintf(stderr, "file size is too large for malloc: %s\n", bin);
132 buf = malloc(bin_stat.st_size);
134 fprintf(stderr, "cannot allocate memory: %zx\n",
135 (size_t)bin_stat.st_size);
140 size = fread(buf, 1, bin_stat.st_size, g);
141 if (size < bin_stat.st_size) {
142 fprintf(stderr, "read failed (%zx)\n", size);
148 *bin_size = bin_stat.st_size;
156 * write_capsule_file - write a capsule file
158 * @data: Pointer to data
159 * @bin_size: Size of data
161 * Write out data, @data, with the size @bin_size.
167 static int write_capsule_file(FILE *f, void *data, size_t size, const char *msg)
171 size_written = fwrite(data, 1, size, f);
172 if (size_written < size) {
173 fprintf(stderr, "%s: write failed (%zx != %zx)\n", msg,
182 * create_auth_data - compose authentication data in capsule
183 * @auth_context: Pointer to authentication context
185 * Fill up an authentication header (.auth) and signature data (.sig_data)
186 * in @auth_context, using library functions from openssl.
187 * All the parameters in @auth_context must be filled in by a caller.
193 static int create_auth_data(struct auth_context *ctx)
198 gnutls_privkey_t pkey;
199 gnutls_x509_crt_t x509;
200 gnutls_pkcs7_t pkcs7;
202 gnutls_datum_t signature;
205 ret = read_bin_file(ctx->cert_file, &cert.data, &file_size);
208 if (file_size > UINT_MAX)
210 cert.size = file_size;
212 ret = read_bin_file(ctx->key_file, &key.data, &file_size);
215 if (file_size > UINT_MAX)
217 key.size = file_size;
221 * gnutls_global_set_time_function(mytime);
222 * gnutls_global_set_log_function(tls_log_func);
223 * gnutls_global_set_log_level(6);
226 ret = gnutls_privkey_init(&pkey);
228 fprintf(stderr, "error in gnutls_privkey_init(): %s\n",
229 gnutls_strerror(ret));
233 ret = gnutls_x509_crt_init(&x509);
235 fprintf(stderr, "error in gnutls_x509_crt_init(): %s\n",
236 gnutls_strerror(ret));
240 /* load a private key */
241 ret = gnutls_privkey_import_x509_raw(pkey, &key, GNUTLS_X509_FMT_PEM,
245 "error in gnutls_privkey_import_x509_raw(): %s\n",
246 gnutls_strerror(ret));
250 /* load x509 certificate */
251 ret = gnutls_x509_crt_import(x509, &cert, GNUTLS_X509_FMT_PEM);
253 fprintf(stderr, "error in gnutls_x509_crt_import(): %s\n",
254 gnutls_strerror(ret));
258 /* generate a PKCS #7 structure */
259 ret = gnutls_pkcs7_init(&pkcs7);
261 fprintf(stderr, "error in gnutls_pkcs7_init(): %s\n",
262 gnutls_strerror(ret));
272 * See EDK2's FmpAuthenticatedHandlerRsa2048Sha256()
274 data.size = ctx->image_size + sizeof(ctx->auth.monotonic_count);
275 data.data = malloc(data.size);
277 fprintf(stderr, "allocating memory (0x%x) failed\n", data.size);
280 memcpy(data.data, ctx->image_data, ctx->image_size);
281 memcpy(data.data + ctx->image_size, &ctx->auth.monotonic_count,
282 sizeof(ctx->auth.monotonic_count));
284 ret = gnutls_pkcs7_sign(pkcs7, x509, pkey, &data, NULL, NULL,
286 /* GNUTLS_PKCS7_EMBED_DATA? */
287 GNUTLS_PKCS7_INCLUDE_CERT |
288 GNUTLS_PKCS7_INCLUDE_TIME);
290 fprintf(stderr, "error in gnutls_pkcs7)sign(): %s\n",
291 gnutls_strerror(ret));
296 ret = gnutls_pkcs7_export2(pkcs7, GNUTLS_X509_FMT_DER, &signature);
298 fprintf(stderr, "error in gnutls_pkcs7_export2: %s\n",
299 gnutls_strerror(ret));
302 ctx->sig_data = signature.data;
303 ctx->sig_size = signature.size;
306 ctx->auth.auth_info.hdr.dwLength = sizeof(ctx->auth.auth_info)
308 ctx->auth.auth_info.hdr.wRevision = WIN_CERT_REVISION_2_0;
309 ctx->auth.auth_info.hdr.wCertificateType = WIN_CERT_TYPE_EFI_GUID;
310 memcpy(&ctx->auth.auth_info.cert_type, &efi_guid_cert_type_pkcs7,
311 sizeof(efi_guid_cert_type_pkcs7));
314 * For better clean-ups,
315 * gnutls_pkcs7_deinit(pkcs7);
316 * gnutls_privkey_deinit(pkey);
317 * gnutls_x509_crt_deinit(x509);
321 * gnutls_free(signature.data);
328 * dump_signature - dump out a signature
329 * @path: Path to a capsule file
330 * @signature: Signature data
331 * @sig_size: Size of signature data
333 * Signature data pointed to by @signature will be saved into
334 * a file whose file name is @path with ".p7" suffix.
340 static int dump_signature(const char *path, uint8_t *signature, size_t sig_size)
347 sig_path = malloc(strlen(path) + 3 + 1);
351 sprintf(sig_path, "%s.p7", path);
352 f = fopen(sig_path, "w");
356 size = fwrite(signature, 1, sig_size, f);
357 if (size == sig_size)
367 * free_sig_data - free out signature data
368 * @ctx: Pointer to authentication context
370 * Free signature data allocated in create_auth_data().
372 static void free_sig_data(struct auth_context *ctx)
375 gnutls_free(ctx->sig_data);
379 * create_fwbin - create an uefi capsule file
380 * @path: Path to a created capsule file
381 * @bin: Path to a firmware binary to encapsulate
382 * @guid: GUID of related FMP driver
383 * @index: Index number in capsule
384 * @instance: Instance number in capsule
385 * @mcount: Monotonic count in authentication information
386 * @private_file: Path to a private key file
387 * @cert_file: Path to a certificate file
389 * This function actually does the job of creating an uefi capsule file.
390 * All the arguments must be supplied.
391 * If either @private_file ror @cert_file is NULL, the capsule file
398 static int create_fwbin(char *path, char *bin, efi_guid_t *guid,
399 unsigned long index, unsigned long instance,
400 uint64_t mcount, char *privkey_file, char *cert_file)
402 struct efi_capsule_header header;
403 struct efi_firmware_management_capsule_header capsule;
404 struct efi_firmware_management_capsule_image_header image;
405 struct auth_context auth_context;
413 fprintf(stderr, "For output: %s\n", path);
414 fprintf(stderr, "\tbin: %s\n\ttype: %pUl\n", bin, guid);
415 fprintf(stderr, "\tindex: %lu\n\tinstance: %lu\n", index, instance);
417 auth_context.sig_size = 0;
423 * read a firmware binary
425 if (read_bin_file(bin, &data, &bin_size))
428 /* first, calculate signature to determine its size */
429 if (privkey_file && cert_file) {
430 auth_context.key_file = privkey_file;
431 auth_context.cert_file = cert_file;
432 auth_context.auth.monotonic_count = mcount;
433 auth_context.image_data = data;
434 auth_context.image_size = bin_size;
436 if (create_auth_data(&auth_context)) {
437 fprintf(stderr, "Signing firmware image failed\n");
442 dump_signature(path, auth_context.sig_data,
443 auth_context.sig_size)) {
444 fprintf(stderr, "Creating signature file failed\n");
450 * write a capsule file
452 f = fopen(path, "w");
454 fprintf(stderr, "cannot open %s\n", path);
459 * capsule file header
461 header.capsule_guid = efi_guid_fm_capsule;
462 header.header_size = sizeof(header);
463 /* TODO: The current implementation ignores flags */
464 header.flags = CAPSULE_FLAGS_PERSIST_ACROSS_RESET;
465 header.capsule_image_size = sizeof(header)
466 + sizeof(capsule) + sizeof(uint64_t)
469 if (auth_context.sig_size)
470 header.capsule_image_size += sizeof(auth_context.auth)
471 + auth_context.sig_size;
472 if (write_capsule_file(f, &header, sizeof(header),
477 * firmware capsule header
478 * This capsule has only one firmware capsule image.
480 capsule.version = 0x00000001;
481 capsule.embedded_driver_count = 0;
482 capsule.payload_item_count = 1;
483 if (write_capsule_file(f, &capsule, sizeof(capsule),
484 "Firmware capsule header"))
487 offset = sizeof(capsule) + sizeof(uint64_t);
488 if (write_capsule_file(f, &offset, sizeof(offset),
489 "Offset to capsule image"))
493 * firmware capsule image header
495 image.version = 0x00000003;
496 memcpy(&image.update_image_type_id, guid, sizeof(*guid));
497 image.update_image_index = index;
498 image.reserved[0] = 0;
499 image.reserved[1] = 0;
500 image.reserved[2] = 0;
501 image.update_image_size = bin_size;
502 if (auth_context.sig_size)
503 image.update_image_size += sizeof(auth_context.auth)
504 + auth_context.sig_size;
505 image.update_vendor_code_size = 0; /* none */
506 image.update_hardware_instance = instance;
507 image.image_capsule_support = 0;
508 if (auth_context.sig_size)
509 image.image_capsule_support |= CAPSULE_SUPPORT_AUTHENTICATION;
510 if (write_capsule_file(f, &image, sizeof(image),
511 "Firmware capsule image header"))
517 if (auth_context.sig_size) {
518 if (write_capsule_file(f, &auth_context.auth,
519 sizeof(auth_context.auth),
520 "Authentication header"))
523 if (write_capsule_file(f, auth_context.sig_data,
524 auth_context.sig_size, "Signature"))
531 if (write_capsule_file(f, data, bin_size, "Firmware binary"))
538 free_sig_data(&auth_context);
545 * convert_uuid_to_guid() - convert UUID to GUID
548 * UUID and GUID have the same data structure, but their binary
549 * formats are different due to the endianness. See lib/uuid.c.
550 * Since uuid_parse() can handle only UUID, this function must
551 * be called to get correct data for GUID when parsing a string.
553 * The correct data will be returned in @buf.
555 void convert_uuid_to_guid(unsigned char *buf)
576 * main - main entry function of mkeficapsule
577 * @argc: Number of arguments
578 * @argv: Array of pointers to arguments
580 * Create an uefi capsule file, optionally signing it.
581 * Parse all the arguments and pass them on to create_fwbin().
587 int main(int argc, char **argv)
590 unsigned char uuid_buf[16];
591 unsigned long index, instance;
593 char *privkey_file, *cert_file;
604 c = getopt_long(argc, argv, opts_short, options, &idx);
612 "Image type already specified\n");
615 guid = &efi_guid_image_type_uboot_fit;
620 "Image type already specified\n");
623 guid = &efi_guid_image_type_uboot_raw;
628 "Image type already specified\n");
631 if (uuid_parse(optarg, uuid_buf)) {
632 fprintf(stderr, "Wrong guid format\n");
635 convert_uuid_to_guid(uuid_buf);
636 guid = (efi_guid_t *)uuid_buf;
639 index = strtoul(optarg, NULL, 0);
642 instance = strtoul(optarg, NULL, 0);
647 "Private Key already specified\n");
650 privkey_file = optarg;
655 "Certificate file already specified\n");
661 mcount = strtoul(optarg, NULL, 0);
672 /* check necessary parameters */
673 if ((argc != optind + 2) || !guid ||
674 ((privkey_file && !cert_file) ||
675 (!privkey_file && cert_file))) {
680 if (create_fwbin(argv[argc - 1], argv[argc - 2], guid, index, instance,
681 mcount, privkey_file, cert_file) < 0) {
682 fprintf(stderr, "Creating firmware capsule failed\n");