Refactor siglen_map[] to store key size in bytes instead of 32-bit words.

src/platform/vboot_reference/utils/firmware_image.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Functions for generating and manipulating a verified boot firmware image.
  */
 
 #include "firmware_image.h"
 
 #include <fcntl.h>
@@ skipping 63 matching lines @@
 
   StatefulMemcpy(&st, &image->header_len, FIELD_LEN(header_len));
   StatefulMemcpy(&st, &image->sign_algorithm, FIELD_LEN(sign_algorithm));
 
   /* Valid Algorithm? */
   if (image->sign_algorithm >= kNumAlgorithms)
     goto parse_failure;
 
   /* Compute size of pre-processed RSA public key and signature. */
   sign_key_len = RSAProcessedKeySize(image->sign_algorithm);
-  signature_len = siglen_map[image->sign_algorithm] * sizeof(uint32_t);
+  signature_len = siglen_map[image->sign_algorithm];
 
 
   /* Check whether the header length is correct. */
   header_len = (FIELD_LEN(header_len) +
                 FIELD_LEN(sign_algorithm) +
                 sign_key_len +
                 FIELD_LEN(key_version) +
                 FIELD_LEN(header_checksum));
   if (header_len != image->header_len) {
     fprintf(stderr, "Header length mismatch. Got: %d Expected: %d\n",
@@ skipping 64 matching lines @@
   if (!image)
     return NULL;
   if (-1 == (fd = creat(input_file, S_IRWXU))) {
     fprintf(stderr, "Couldn't open file for writing.\n");
     return NULL;
   }
 
   write(fd, image->magic, FIELD_LEN(magic));
   WriteFirmwareHeader(fd, image);
   write(fd, image->key_signature, FIELD_LEN(key_signature));
-  signature_len = siglen_map[image->sign_algorithm] * sizeof(uint32_t);
+  signature_len = siglen_map[image->sign_algorithm];
   WriteFirmwarePreamble(fd, image);
   write(fd, image->preamble_signature, signature_len);
   write(fd, image->firmware_signature, signature_len);
   write(fd, image->firmware_data, image->firmware_len);
 
   close(fd);
   return image;
 }
 
 void PrintFirmwareImage(const FirmwareImage* image) {
@@ skipping 106 matching lines @@
   Memcpy(&len, preamble_blob + FIELD_LEN(firmware_version),
          sizeof(len));
   *firmware_len = (int) len;
   return 0;
 }
 
 int VerifyFirmwareData(RSAPublicKey* sign_key,
                        const uint8_t* firmware_data_start,
                        int firmware_len,
                        int algorithm) {
-  int signature_len = siglen_map[algorithm] * sizeof(uint32_t);
+  int signature_len = siglen_map[algorithm];
   if (!RSAVerifyBinary_f(NULL, sign_key,  /* Key to use. */
                          firmware_data_start + signature_len,  /* Data to
                                                                 * verify */
                          firmware_len,  /* Length of data. */
                          firmware_data_start,  /* Expected Signature */
                          algorithm))
     return VERIFY_FIRMWARE_SIGNATURE_FAILED;
   return 0;
 }
 
@@ skipping 21 matching lines @@
   if ((error_code = VerifyFirmwareHeader(root_key_blob, header_ptr, dev_mode,
                                          &algorithm, &header_len)))
     return error_code;  /* AKA jump to revovery. */
 
   /* Parse signing key into RSAPublicKey structure since it is required multiple
    * times. */
   sign_key_len = RSAProcessedKeySize(algorithm);
   sign_key_ptr = header_ptr + (FIELD_LEN(header_len) +
                                FIELD_LEN(sign_algorithm));
   sign_key = RSAPublicKeyFromBuf(sign_key_ptr, sign_key_len);
-  signature_len = siglen_map[algorithm] * sizeof(uint32_t);
+  signature_len = siglen_map[algorithm];
 
   /* Only continue if preamble verification succeeds. */
   preamble_ptr = (header_ptr + header_len +
                   FIELD_LEN(key_signature));
   if ((error_code = VerifyFirmwarePreamble(sign_key, preamble_ptr, algorithm,
                                            &firmware_len)))
     return error_code;  /* AKA jump to recovery. */
 
   /* Only continue if firmware data verification succeeds. */
   firmware_ptr = (preamble_ptr +
@@ skipping 50 matching lines @@
                     header_digest)) {
       error_code =  VERIFY_FIRMWARE_ROOT_SIGNATURE_FAILED;
       goto verify_failure;
     }
   }
 
   /* Get sign key to verify the rest of the firmware. */
   sign_key_size = RSAProcessedKeySize(image->sign_algorithm);
   sign_key = RSAPublicKeyFromBuf(image->sign_key,
                                  sign_key_size);
-  signature_size = siglen_map[image->sign_algorithm] * sizeof(uint32_t);
+  signature_size = siglen_map[image->sign_algorithm];
 
   if (image->sign_algorithm >= kNumAlgorithms)
     return VERIFY_FIRMWARE_INVALID_ALGORITHM;
 
   /* Verify firmware preamble signature. */
   DigestInit(&ctx, image->sign_algorithm);
   DigestUpdate(&ctx, (uint8_t*) &image->firmware_version,
                FIELD_LEN(firmware_version));
   DigestUpdate(&ctx, (uint8_t*) &image->firmware_len,
                FIELD_LEN(firmware_len));
@@ skipping 50 matching lines @@
 }
 
 int AddFirmwareSignature(FirmwareImage* image, const char* signing_key_file,
                          int algorithm) {
   int tmp_preamble_fd;
   char* tmp_preamble_file = ".tmpPreambleFile";
   int tmp_firmware_fd;
   char* tmp_firmware_file = ".tmpFirmwareFile";
   uint8_t* preamble_signature;
   uint8_t* firmware_signature;
-  int signature_len = siglen_map[algorithm] * sizeof(uint32_t);
+  int signature_len = siglen_map[algorithm];
 
   /* Write preamble to a file. */
   if(-1 == (tmp_preamble_fd = creat(tmp_preamble_file, S_IRWXU))) {
     fprintf(stderr, "Could not open temporary file for writing "
             "firmware preamble.\n");
     return 0;
   }
   WriteFirmwarePreamble(tmp_preamble_fd, image);
   close(tmp_preamble_fd);
   if (!(preamble_signature = SignatureFile(tmp_preamble_file, signing_key_file,
@@ skipping 15 matching lines @@
                                            algorithm))) {
     fprintf(stderr, "Could not open temporary file for writing "
             "firmware.\n");
     return 0;
   }
   image->firmware_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->firmware_signature, firmware_signature, signature_len);
   Free(firmware_signature);
   return 1;
 }