VBoot Reference: Fix many memory leaks.

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 482 matching lines @@
                                       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];
   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)))
+                                       &kernel_len))) {
+    RSAPublicKeyFree(kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
+  }
   /* Only continue if kernel data verification succeeds. */
   kernel_ptr = (config_ptr +
                 FIELD_LEN(kernel_version) +
                 FIELD_LEN(options.version) +
                 FIELD_LEN(options.kernel_len) +
                 FIELD_LEN(options.kernel_entry_addr) +
                 FIELD_LEN(options.kernel_load_addr) +
                 kernel_signature_len);
 
   if ((error_code = VerifyKernelData(kernel_sign_key, kernel_ptr, kernel_len,
-                                     kernel_sign_algorithm)))
+                                     kernel_sign_algorithm))) {
+    RSAPublicKeyFree(kernel_sign_key);
     return error_code;  /* AKA jump to recovery. */
+  }
+  RSAPublicKeyFree(kernel_sign_key);
   return 0;  /* Success! */
 }
 
 int VerifyKernelImage(const RSAPublicKey* firmware_key,
                       const KernelImage* image,
                       const int dev_mode) {
-  RSAPublicKey* kernel_sign_key;
+  RSAPublicKey* kernel_sign_key = NULL;
   uint8_t* header_digest = NULL;
   uint8_t* config_digest = NULL;
   uint8_t* kernel_digest = NULL;
   int kernel_sign_key_size;
   int kernel_signature_size;
   int error_code = 0;
   DigestContext ctx;
 
   if (!image)
     return VERIFY_KERNEL_INVALID_IMAGE;
@@ skipping 69 matching lines @@
                             image->options.kernel_len,
                             image->kernel_sign_algorithm);
   if (!RSAVerify(kernel_sign_key, image->kernel_signature,
                  kernel_signature_size, image->kernel_sign_algorithm,
                  kernel_digest)) {
     error_code = VERIFY_KERNEL_SIGNATURE_FAILED;
     goto verify_failure;
   }
 
 verify_failure:
+  RSAPublicKeyFree(kernel_sign_key);
   Free(kernel_digest);
   Free(config_digest);
   Free(header_digest);
   return error_code;
 }
 
 const char* VerifyKernelErrorString(int error) {
   return kVerifyKernelErrors[error];
 }
 
 int AddKernelKeySignature(KernelImage* image, const char* firmware_key_file) {
   uint8_t* header_blob = NULL;
-  uint8_t* signature;
+  uint8_t* signature = NULL;
   int signature_len = siglen_map[image->firmware_sign_algorithm];
   if (!image || !firmware_key_file)
     return 0;
   header_blob = GetKernelHeaderBlob(image);
   if (!header_blob)
     return 0;
   if (!(signature = SignatureBuf(header_blob,
                                  GetKernelHeaderLen(image),
                                  firmware_key_file,
                                  image->firmware_sign_algorithm))) {
     Free(header_blob);
     return 0;
   }
   image->kernel_key_signature = Malloc(signature_len);
   Memcpy(image->kernel_key_signature, signature, signature_len);
   Free(signature);
   Free(header_blob);
   return 1;
 }
 
 int AddKernelSignature(KernelImage* image,
                        const char* kernel_signing_key_file) {
-  uint8_t* config_blob;
-  uint8_t* config_signature;
-  uint8_t* kernel_signature;
+  uint8_t* config_blob = NULL;
+  uint8_t* config_signature = NULL;
+  uint8_t* kernel_signature = NULL;
   int signature_len = siglen_map[image->kernel_sign_algorithm];
 
   config_blob = GetKernelConfigBlob(image);
   if (!(config_signature = SignatureBuf(config_blob,
                                         GetKernelConfigLen(image),
                                         kernel_signing_key_file,
                                         image->kernel_sign_algorithm))) {
     fprintf(stderr, "Could not compute signature on the kernel config.\n");
     Free(config_blob);
     return 0;
   }
+  Free(config_blob);
 
   image->config_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->config_signature, config_signature, signature_len);
   Free(config_signature);
 
   if (!(kernel_signature = SignatureBuf(image->kernel_data,
                                         image->options.kernel_len,
                                         kernel_signing_key_file,
                                         image->kernel_sign_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;
 }