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

src/platform/vboot_reference/utils/kernel_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 kernel image.
  */
 
 #include "kernel_image.h"
 
 #include <fcntl.h>
@@ skipping 74 matching lines @@
   /* Valid Kernel Key signing algorithm. */
   if (image->firmware_sign_algorithm >= kNumAlgorithms)
     goto parse_failure;
 
   /* Valid Kernel Signing Algorithm? */
   if (image->kernel_sign_algorithm >= kNumAlgorithms)
     goto parse_failure;
 
   /* Compute size of pre-processed RSA public keys and signatures. */
   firmware_sign_key_len = RSAProcessedKeySize(image->firmware_sign_algorithm);
-  /* TODO(gauravsh): Make siglen_map track the signature length in number
-   * of bytes rather than 32-bit words. */
-  kernel_key_signature_len  = (siglen_map[image->firmware_sign_algorithm] *
-                               sizeof(uint32_t));
+  kernel_key_signature_len  = siglen_map[image->firmware_sign_algorithm];
   kernel_sign_key_len = RSAProcessedKeySize(image->kernel_sign_algorithm);
-  kernel_signature_len = (siglen_map[image->kernel_sign_algorithm] *
-                          sizeof(uint32_t));
+  kernel_signature_len = siglen_map[image->kernel_sign_algorithm];
 
   /* Check whether key header length is correct. */
   header_len = (FIELD_LEN(header_version) +
                 FIELD_LEN(header_len) +
                 FIELD_LEN(firmware_sign_algorithm) +
                 FIELD_LEN(kernel_sign_algorithm) +
                 FIELD_LEN(kernel_key_version) +
                 kernel_sign_key_len +
                 FIELD_LEN(header_checksum));
 
@@ skipping 81 matching lines @@
   int kernel_key_signature_len;
   int kernel_signature_len;
   if (!image)
     return NULL;
   if (-1 == (fd = creat(input_file,
                         S_IRUSR | S_IWUSR))) {  /* Owner has R/W permissions. */
     fprintf(stderr, "Couldn't open file for writing.\n");
     return NULL;
   }
 
-  kernel_key_signature_len = (siglen_map[image->firmware_sign_algorithm] *
-                              sizeof(uint32_t));
-  kernel_signature_len = (siglen_map[image->kernel_sign_algorithm] *
-                          sizeof(uint32_t));
+  kernel_key_signature_len = siglen_map[image->firmware_sign_algorithm];
+  kernel_signature_len = siglen_map[image->kernel_sign_algorithm];
 
   write(fd, image->magic, FIELD_LEN(magic));
   WriteKernelHeader(fd, image);
   write(fd, image->kernel_key_signature, kernel_key_signature_len);
   WriteKernelConfig(fd, image);
   write(fd, image->config_signature, kernel_signature_len);
   write(fd, image->kernel_signature, kernel_signature_len);
   write(fd, image->kernel_data, image->options.kernel_len);
 
   close(fd);
@@ skipping 141 matching lines @@
                               FIELD_LEN(options.version)),
          sizeof(len));
   *kernel_len = (int) len;
   return 0;
 }
 
 int VerifyKernelData(RSAPublicKey* kernel_sign_key,
                      const uint8_t* kernel_data_start,
                      int kernel_len,
                      int algorithm) {
-  int signature_len = siglen_map[algorithm] * sizeof(uint32_t);
+  int signature_len = siglen_map[algorithm];
   if (!RSAVerifyBinary_f(NULL, kernel_sign_key,  /* Key to use. */
                          kernel_data_start + signature_len,  /* Data to
                                                               * verify */
                          kernel_len,  /* Length of data. */
                          kernel_data_start,  /* Expected Signature */
                          algorithm))
     return VERIFY_KERNEL_SIGNATURE_FAILED;
   return 0;
 }
 
@@ skipping 29 matching lines @@
   /* Parse signing key into RSAPublicKey structure since it is required multiple
    * times. */
   kernel_sign_key_len = RSAProcessedKeySize(kernel_sign_algorithm);
   kernel_sign_key_ptr = header_ptr + (FIELD_LEN(header_version) +
                                       FIELD_LEN(header_len) +
                                       FIELD_LEN(firmware_sign_algorithm) +
                                       FIELD_LEN(kernel_sign_algorithm) +
                                       FIELD_LEN(kernel_key_version));
   kernel_sign_key = RSAPublicKeyFromBuf(kernel_sign_key_ptr,
                                         kernel_sign_key_len);
-  kernel_signature_len = siglen_map[kernel_sign_algorithm] * sizeof(uint32_t);
-  kernel_key_signature_len = siglen_map[firmware_sign_algorithm] *
-      sizeof(uint32_t);
+  kernel_signature_len = siglen_map[kernel_sign_algorithm];
+  kernel_key_signature_len = siglen_map[firmware_sign_algorithm];
 
   /* Only continue if config verification succeeds. */
   config_ptr = (header_ptr + header_len + kernel_key_signature_len);
   if ((error_code = VerifyKernelConfig(kernel_sign_key, config_ptr,
                                        kernel_sign_algorithm,
                                        &kernel_len)))
     return error_code;  /* AKA jump to recovery. */
   /* Only continue if kernel data verification succeeds. */
   kernel_ptr = (config_ptr +
                 FIELD_LEN(kernel_version) +
@@ skipping 48 matching lines @@
     DigestUpdate(&ctx, (uint8_t*) &image->kernel_sign_algorithm,
                  FIELD_LEN(kernel_sign_algorithm));
     DigestUpdate(&ctx, (uint8_t*) &image->kernel_key_version,
                  FIELD_LEN(kernel_key_version));
     DigestUpdate(&ctx, image->kernel_sign_key,
                  RSAProcessedKeySize(image->kernel_sign_algorithm));
     DigestUpdate(&ctx, image->header_checksum,
                  FIELD_LEN(header_checksum));
     header_digest = DigestFinal(&ctx);
     if (!RSA_verify(firmware_key, image->kernel_key_signature,
-                    siglen_map[image->firmware_sign_algorithm] *
-                    sizeof(uint32_t),
+                    siglen_map[image->firmware_sign_algorithm],
                     image->firmware_sign_algorithm,
                     header_digest)) {
       fprintf(stderr, "VerifyKernelImage(): Key signature check failed.\n");
       error_code =  VERIFY_KERNEL_KEY_SIGNATURE_FAILED;
       goto verify_failure;
     }
   }
 
   /* Get kernel signing key to verify the rest of the kernel. */
   kernel_sign_key_size = RSAProcessedKeySize(image->kernel_sign_algorithm);
   kernel_sign_key = RSAPublicKeyFromBuf(image->kernel_sign_key,
                                         kernel_sign_key_size);
-  kernel_signature_size = siglen_map[image->kernel_sign_algorithm] *
-      sizeof(uint32_t);
+  kernel_signature_size = siglen_map[image->kernel_sign_algorithm];
 
   /* Verify kernel config signature. */
   DigestInit(&ctx, image->kernel_sign_algorithm);
   DigestUpdate(&ctx, (uint8_t*) &image->kernel_version,
                FIELD_LEN(kernel_version));
   DigestUpdate(&ctx, (uint8_t*) &image->options.version,
                FIELD_LEN(options.version));
   DigestUpdate(&ctx, (uint8_t*) &image->options.kernel_len,
                FIELD_LEN(options.kernel_len));
   DigestUpdate(&ctx, (uint8_t*) &image->options.kernel_load_addr,
@@ skipping 27 matching lines @@
 }
 
 const char* VerifyKernelErrorString(int error) {
   return kVerifyKernelErrors[error];
 }
 
 int AddKernelKeySignature(KernelImage* image, const char* firmware_key_file) {
   int tmp_hdr_fd;
   char* tmp_hdr_file = ".tmpKernelHdrFile";
   uint8_t* signature;
-  int signature_len = siglen_map[image->firmware_sign_algorithm] *
-      sizeof(uint32_t);
+  int signature_len = siglen_map[image->firmware_sign_algorithm];
 
   if(-1 == (tmp_hdr_fd = creat(tmp_hdr_file, S_IRWXU))) {
     fprintf(stderr, "Could not open temporary file for writing "
             "kernel header.\n");
     return 0;
   }
   WriteKernelHeader(tmp_hdr_fd, image);
   close(tmp_hdr_fd);
   if (!(signature = SignatureFile(tmp_hdr_file, firmware_key_file,
                                   image->firmware_sign_algorithm)))
     return 0;
   image->kernel_key_signature = Malloc(signature_len);
   Memcpy(image->kernel_key_signature, signature, signature_len);
   return 1;
 }
 
 int AddKernelSignature(KernelImage* image, const char* kernel_signing_key_file,
                        int algorithm) {
   int tmp_config_fd;
   char* tmp_config_file = ".tmpConfigFile";
   int tmp_kernel_fd;
   char* tmp_kernel_file = ".tmpKernelFile";
   uint8_t* config_signature;
   uint8_t* kernel_signature;
-  int signature_len = siglen_map[algorithm] * sizeof(uint32_t);
+  int signature_len = siglen_map[algorithm];
 
   /* Write config to a file. */
   if(-1 == (tmp_config_fd = creat(tmp_config_file, S_IRWXU))) {
     fprintf(stderr, "Could not open temporary file for writing "
             "kernel config.\n");
     return 0;
   }
   WriteKernelConfig(tmp_config_fd, image);
   close(tmp_config_fd);
   if (!(config_signature = SignatureFile(tmp_config_file,
@@ skipping 16 matching lines @@
                                          kernel_signing_key_file,
                                          algorithm))) {
     fprintf(stderr, "Could not compute signature on the kernel.\n");
     return 0;
   }
   image->kernel_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->kernel_signature, kernel_signature, signature_len);
   Free(kernel_signature);
   return 1;
 }