Add some convenience/helper functions for RSA.

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 "rsa_utility.h"
 #include "verify_data.h"
 
-RSAPublicKey* read_RSAkey(char *input_file, int len) {
+RSAPublicKey* read_RSAkey(char* input_file, int len) {
   int key_fd;
-  RSAPublicKey *key = NULL;
+  int buf_len;
+  struct stat stat_fd;
+  uint8_t* buf = 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));
-  if (!key)
+  if (-1 == fstat(key_fd, &stat_fd)) {
+    fprintf(stderr, "Couldn't stat key file\n");
+    return NULL;
+  }
+  buf_len = stat_fd.st_size;
+
+  /* Read entire key binary blob into a buffer. */
+  buf = (uint8_t*) malloc(buf_len);
+  if (!buf)
     return NULL;
 
-  /* Read the pre-processed RSA key into a RSAPublicKey structure */
-  /* TODO(gauravsh): Add error checking here? */
-
-  read(key_fd, &key->len, sizeof(key->len));
-  read(key_fd, &key->n0inv, sizeof(key->n0inv));
-
-#ifndef NDEBUG
-  fprintf(stderr, "%d\n", key->len);
-  fprintf(stderr, "%d\n", key->n0inv);
-#endif
-
-  key->n = (uint32_t *) malloc(len);
-  read(key_fd, key->n, len);
-
-  key->rr = (uint32_t *) malloc(len);
-  read(key_fd, key->rr, len);
-
-#ifndef NDEBUG
-  {
-    int i;
-    for(i=0; i<key->len; i++) {
-      fprintf(stderr, "%d,", key->n[i]);
-    }
-    fprintf(stderr, "\n");
-
-    for(i=0; i<key->len; i++) {
-      fprintf(stderr, "%d,", key->rr[i]);
-    }
-    fprintf(stderr, "\n");
+  if (buf_len != read(key_fd, buf, buf_len)) {
+    fprintf(stderr, "Couldn't read key into a buffer.\n");
+    return NULL;
   }
-#endif
 
   close(key_fd);
-  return key;
+  return RSAPublicKeyFromBuf(buf, buf_len);
 }
 
-uint8_t* read_signature(char *input_file, int len) {
+uint8_t* read_signature(char* input_file, int len) {
   int i, sigfd;
-  uint8_t *signature = NULL;
+  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);
   if (!signature)
     return NULL;
 
   if( (i = read(sigfd, signature, len)) != len ) {
     fprintf(stderr, "Wrong signature length - Expected = %d, Received = %d\n",
             len, i);
     close(sigfd);
     return NULL;
   }
 
   close(sigfd);
   return signature;
 }
 
 
 int main(int argc, char* argv[]) {
   int i, algorithm, sig_len;
-  uint8_t *digest = NULL, *signature = NULL;
+  uint8_t* digest = NULL;

[sosa, 2010/02/05 19:37:59]

Is this extra whitespace?

[gauravsh, 2010/02/05 19:40:45]

No, I think it's just the diff, as I split the declaration to separate lines.

+  uint8_t* signature = NULL;
   RSAPublicKey* key = NULL;
 
   if (argc!=5) {
     fprintf(stderr, "Usage: %s <algorithm> <key file> <signature file>"
             " <input file>\n\n", argv[0]);
     fprintf(stderr, "where <algorithm> depends on the signature algorithm"
             " used:\n");
     for(i = 0; i<kNumAlgorithms; i++)
       fprintf(stderr, "\t%d for %s\n", i, algo_strings[i]);
     return -1;
@@ skipping 18 matching lines @@
   else
     fprintf(stderr, "Signature Verification FAILED!\n");
 
 failure:
   free(key);
   free(signature);
   free(digest);
 
   return 0;
 }