Refactor SHA*_file functions into a separate file. Generate them using a C macro.

src/platform/vboot_reference/tests/verify_data.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.
  */
 
 /* Routines for verifying a file's signature. Useful in testing the core
  * RSA verification implementation.
  */
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
+#include "digest_utility.h"
 #include "padding.h"
 #include "rsa.h"
-#include "sha.h"
 #include "verify_data.h"
 
-
 RSAPublicKey* read_RSAkey(char *input_file, int len) {
   int key_fd;
   RSAPublicKey *key = NULL;
 
   if ((key_fd = open(input_file, O_RDONLY)) == -1) {
     fprintf(stderr, "Couldn't open pre-processed key file\n");
     return NULL;
   }
 
   key = (RSAPublicKey *) malloc(sizeof(RSAPublicKey));
@@ skipping 29 matching lines @@
       fprintf(stderr, "%d,", key->rr[i]);
     }
     fprintf(stderr, "\n");
   }
 #endif
 
   close(key_fd);
   return key;
 }
 
-uint8_t* SHA1_file(char *input_file) {
-  int i, input_fd, len;
-  uint8_t data[SHA1_BLOCK_SIZE], *digest = NULL, *p = NULL;
-  SHA1_CTX ctx;
-
-  if( (input_fd = open(input_file, O_RDONLY)) == -1 ) {
-    fprintf(stderr, "Couldn't open input file.\n");
-    return NULL;
-  }
-
-  /* Calculate SHA1 hash of input blocks, reading one block at a time. */
-  SHA1_init(&ctx);
-  while ( (len = read(input_fd, data, SHA1_BLOCK_SIZE)) == SHA1_BLOCK_SIZE)
-    SHA1_update(&ctx, data, len);
-  if (len != -1)
-    SHA1_update(&ctx, data, len);
-  p = SHA1_final(&ctx);
-  close(input_fd);
-
-  digest = (uint8_t*) malloc(SHA1_DIGEST_SIZE);
-  if (!digest)
-    return NULL;
-  for (i=0; i < SHA1_DIGEST_SIZE; i++)
-    digest[i] = *p++;
-
-  return digest;
-}
-
-uint8_t* SHA256_file(char *input_file) {
-  int i, input_fd, len;
-  uint8_t data[SHA256_BLOCK_SIZE], *digest = NULL, *p = NULL;
-  SHA256_CTX ctx;
-
-  if( (input_fd = open(input_file, O_RDONLY)) == -1 ) {
-    fprintf(stderr, "Couldn't open input file.\n");
-    return NULL;
-  }
-
-  /* Calculate SHA256 hash of file, reading one block at a time. */
-  SHA256_init(&ctx);
-  while ( (len = read(input_fd, data, SHA256_BLOCK_SIZE)) == SHA256_BLOCK_SIZE)
-    SHA256_update(&ctx, data, len);
-  if (len != -1)
-    SHA256_update(&ctx, data, len);
-  p = SHA256_final(&ctx);
-  close(input_fd);
-
-  digest = (uint8_t*) malloc(SHA256_DIGEST_SIZE);
-  if (!digest)
-    return NULL;
-  for (i=0; i < SHA256_DIGEST_SIZE; i++)
-    digest[i] = *p++;
-
-  return digest;
-}
-
-uint8_t* SHA512_file(char* input_file) {
-  int input_fd;
-  uint8_t data[SHA512_BLOCK_SIZE], *digest = NULL, *p = NULL;
-  int i, len;
-  SHA512_CTX ctx;
-
-  if( (input_fd = open(input_file, O_RDONLY)) == -1 ) {
-    fprintf(stderr, "Couldn't open input file.\n");
-    return NULL;
-  }
-
-  /* Calculate SHA512 hash of file, reading one block at a time. */
-  SHA512_init(&ctx);
-  while ( (len = read(input_fd, data, SHA512_BLOCK_SIZE)) == SHA512_BLOCK_SIZE)
-    SHA512_update(&ctx, data, len);
-  if (len != -1)
-    SHA512_update(&ctx, data, len);
-  p = SHA512_final(&ctx);
-  close(input_fd);
-
-  digest = (uint8_t*) malloc(SHA512_DIGEST_SIZE);
-  if (!digest)
-    return NULL;
-  for (i=0; i < SHA512_DIGEST_SIZE; i++)
-    digest[i] = *p++;
-
-  return digest;
-}
-
-
-uint8_t* calculate_digest(char *input_file, int algorithm) {
-  typedef uint8_t* (*Hash_file_ptr) (char*);
-  Hash_file_ptr hash_file[] = {
-    SHA1_file, /* RSA 1024 */
-    SHA256_file,
-    SHA512_file,
-    SHA1_file, /* RSA 2048 */
-    SHA256_file,
-    SHA512_file,
-    SHA1_file, /* RSA 4096 */
-    SHA256_file,
-    SHA512_file,
-    SHA1_file, /* RSA 8192 */
-    SHA256_file,
-    SHA512_file,
-  };
-  return hash_file[algorithm](input_file);
-}
-
 uint8_t* read_signature(char *input_file, int len) {
   int i, sigfd;
   uint8_t *signature = NULL;
   if ((sigfd = open(input_file, O_RDONLY)) == -1) {
     fprintf(stderr, "Couldn't open signature file\n");
     return NULL;
   }
 
   /* Read the signature into a buffer*/
   signature = (uint8_t*) malloc(len);
@@ skipping 46 matching lines @@
   else
     fprintf(stderr, "Signature Verification FAILED!\n");
 
 failure:
   free(key);
   free(signature);
   free(digest);
 
   return 0;
 }