Remove unused files, and tidy the directory structure of the remaining ones.

Review URL: http://codereview.chromium.org/2815011

4 files changed, 44 insertions, 175 deletions

diff --git a/tests/Makefile b/tests/Makefile
index dc8620e4..1e8fc9da 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -6,29 +6,17 @@ INCLUDES += -I./include \
 		-I$(FWDIR)/lib/include \
 		-I$(FWDIR)/lib/cgptlib/include \
 		-I$(FWDIR)/lib/cryptolib/include \
-		-I../host/include \
-		-I../misclibs/include \
-		-I../vboot_firmware/lib/include\
-		-I../vkernel/include
-IMAGE_LIBS = $(BUILD)/vkernel/kernel_image.o \
-		$(BUILD)/vkernel/kernel_image_fw.o
-UTIL_LIBS = $(BUILD)/misclibs/file_keys.o $(BUILD)/misclibs/signature_digest.o
+		-I$(HOSTDIR)/include
 BUILD_ROOT = ${BUILD}/tests
 
-TEST_NAMES = big_kernel_tests \
-		cgptlib_test \
-		kernel_image_tests \
-		kernel_rollback_tests \
-		kernel_splicing_tests \
-		kernel_verify_benchmark \
+TEST_NAMES = cgptlib_test \
 		rsa_padding_test \
 		rsa_verify_benchmark \
 		sha_benchmark \
 		sha_tests \
 		vboot_common_tests \
 		vboot_common2_tests \
-		vboot_common3_tests \
-		verify_kernel_fuzz_driver
+		vboot_common3_tests
 TEST_BINS = $(addprefix ${BUILD_ROOT}/,$(TEST_NAMES))
 
 TEST_LIB = ${BUILD_ROOT}/test.a
@@ -37,7 +25,7 @@ TEST_LIB_OBJS = $(TEST_LIB_SRCS:%.c=${BUILD_ROOT}/%.o)
 ALL_DEPS = $(addsuffix .d,${TEST_BINS} ${TEST_LIB_OBJS})
 CFLAGS +=  -MMD -MF $@.d
 
-LIBS := ${TEST_LIB} $(IMAGE_LIBS) $(UTIL_LIBS) $(HOSTLIB) $(FWLIB)
+LIBS := ${TEST_LIB} $(HOSTLIB) $(FWLIB)
 
 all: $(TEST_BINS) ${EXTRA_TARGET}
 
@@ -51,37 +39,57 @@ ${BUILD_ROOT}/%.o : %.c
 ${BUILD_ROOT}/%: %.c ${LIBS}
 	$(CC) $(CFLAGS) $(INCLUDES) $< ${LIBS} -o $@ -lcrypto -lrt
 
-# TODO: port these tests to vboot_firmware, if not already eqivalent
-# functionality
+# TODO: port these tests to new API, if not already eqivalent
+# functionality in other tests
+#
 #		big_firmware_tests
 #		firmware_image_tests
 #		firmware_rollback_tests
 #		firmware_splicing_tests
 #		firmware_verify_benchmark
 #		verify_firmware_fuzz_driver
+#
+#		big_kernel_tests
+#		kernel_image_tests 
+#		kernel_rollback_tests 
+#		kernel_splicing_tests 
+#		kernel_verify_benchmark 
+#		verify_kernel_fuzz_driver
 
 
 ifneq (${RUNTESTS},)
 EXTRA_TARGET = runtests
 endif
 
-runtests:
+# Generate test keys
+genkeys:
 	./gen_test_keys.sh
-	# Crypto tests
+
+# Run cgpt tests
+runcgpttests:
+	${BUILD_ROOT}/cgptlib_test
+	./run_cgpt_tests.sh  ${BUILD}/cgpt/cgpt
+
+# Run crypto tests
+runcryptotests:
 	./run_rsa_tests.sh
 	${BUILD_ROOT}/sha_tests
-	./run_vbutil_tests.sh
 	./run_vboot_common_tests.sh
-	./run_image_verification_tests.sh
-	# Splicing tests
-	#${BUILD_ROOT}/firmware_splicing_tests
-	${BUILD_ROOT}/kernel_splicing_tests
-	# Rollback Tests
-	#${BUILD_ROOT}/firmware_rollback_tests
-	${BUILD_ROOT}/kernel_rollback_tests
-	# Helper Library Tests
-	${BUILD_ROOT}/cgptlib_test
-	# Tool tests
-	./run_cgpt_tests.sh  ${BUILD}/cgpt/cgpt
 
--include ${ALL_DEPS}
\ No newline at end of file
+# Run other misc tests
+runmisctests:
+	./run_vbutil_tests.sh
+
+
+runtests: genkeys runcgpttests runcryptotests runmisctests
+
+# TODO: tests to run when ported to new API
+#	./run_image_verification_tests.sh
+#	# Splicing tests
+#	${BUILD_ROOT}/firmware_splicing_tests
+#	${BUILD_ROOT}/kernel_splicing_tests
+#	# Rollback Tests
+#	${BUILD_ROOT}/firmware_rollback_tests
+#	${BUILD_ROOT}/kernel_rollback_tests
+
+-include ${ALL_DEPS}
diff --git a/tests/run_image_verification_tests.sh b/tests/run_image_verification_tests.sh
index 9a2e68cb..025066a4 100755
--- a/tests/run_image_verification_tests.sh
+++ b/tests/run_image_verification_tests.sh
@@ -70,10 +70,9 @@ ${kernel_hashalgo}${COL_STOP}"
 
 check_test_keys
 
-# TODO: re-enable when tests are ported to new vboot
-#echo
-#echo "Testing high-level firmware image verification..."
-#test_firmware_verification
+echo
+echo "Testing high-level firmware image verification..."
+test_firmware_verification
 
 echo
 echo "Testing high-level kernel image verification..."
diff --git a/tests/test_common.c b/tests/test_common.c
index 1c0fae23..e53f596b 100644
--- a/tests/test_common.c
+++ b/tests/test_common.c
@@ -44,114 +44,3 @@ int TEST_NEQ(int result, int not_expected_result, char* testname) {
     return 0;
   }
 }
-
-KernelImage* GenerateTestKernelImage(int firmware_sign_algorithm,
-                                     int kernel_sign_algorithm,
-                                     const uint8_t* kernel_sign_key,
-                                     int kernel_key_version,
-                                     int kernel_version,
-                                     uint64_t kernel_len,
-                                     const char* firmware_key_file,
-                                     const char* kernel_key_file,
-                                     uint8_t kernel_data_fill_char) {
-  KernelImage* image = KernelImageNew();
-
-  Memcpy(image->magic, KERNEL_MAGIC, KERNEL_MAGIC_SIZE);
-  image->header_version = 1;
-  image->firmware_sign_algorithm = firmware_sign_algorithm;
-  image->kernel_sign_algorithm = kernel_sign_algorithm;
-  image->kernel_key_version = kernel_key_version;
-  image->kernel_sign_key = (uint8_t*) Malloc(
-      RSAProcessedKeySize(image->kernel_sign_algorithm));
-  Memcpy(image->kernel_sign_key, kernel_sign_key,
-         RSAProcessedKeySize(image->kernel_sign_algorithm));
-
-  /* Update correct header length. */
-  image->header_len = GetKernelHeaderLen(image);
-
-  /* Calculate SHA-512 digest on header and populate header_checksum. */
-  CalculateKernelHeaderChecksum(image, image->header_checksum);
-
-  /* Populate kernel options and data with dummy data. */
-  image->kernel_version = kernel_version;
-  image->bootloader_offset = 0;
-  image->bootloader_size = 512;
-  image->padded_header_size = 100;
-  image->kernel_len = kernel_len;
-  image->kernel_key_signature = image->kernel_signature = NULL;
-  image->kernel_data = Malloc(kernel_len);
-  Memset(image->kernel_data, kernel_data_fill_char, kernel_len);
-
-  /* Generate and populate signatures. */
-  if (!AddKernelKeySignature(image, firmware_key_file)) {
-    debug("Couldn't create key signature.\n");
-    KernelImageFree(image);
-    return NULL;
-  }
-
-  if (!AddKernelSignature(image, kernel_key_file)) {
-    debug("Couldn't create kernel option and kernel signature.\n");
-    KernelImageFree(image);
-    return NULL;
-  }
-
-  return image;
-}
-
-uint8_t* GenerateTestKernelBlob(int firmware_sign_algorithm,
-                                int kernel_sign_algorithm,
-                                const uint8_t* kernel_sign_key,
-                                int kernel_key_version,
-                                int kernel_version,
-                                uint64_t kernel_len,
-                                const char* firmware_key_file,
-                                const char* kernel_key_file) {
-  KernelImage* image = NULL;
-  uint8_t* kernel_blob = NULL;
-  uint64_t kernel_blob_len = 0;
-
-  image = GenerateTestKernelImage(firmware_sign_algorithm,
-                                  kernel_sign_algorithm,
-                                  kernel_sign_key,
-                                  kernel_key_version,
-                                  kernel_version,
-                                  kernel_len,
-                                  firmware_key_file,
-                                  kernel_key_file,
-                                  'K');
-
-  kernel_blob = GetKernelBlob(image, &kernel_blob_len);
-  KernelImageFree(image);
-  return kernel_blob;
-}
-
-uint8_t* GenerateRollbackTestKernelBlob(int kernel_key_version,
-                                        int kernel_version,
-                                        int is_corrupt) {
- KernelImage* image = NULL;
- uint64_t len;
- uint8_t* kernel_blob = NULL;
- uint8_t* kernel_sign_key = NULL;
- kernel_sign_key = BufferFromFile("testkeys/key_rsa1024.keyb",
-                                  &len);
- if (!kernel_sign_key)
-   return NULL;
- image = GenerateTestKernelImage(0,  /* Firmware algo: RSA1024/SHA1 */
-                                 0,  /* Kernel algo: RSA1024/SHA1 */
-                                 kernel_sign_key,
-                                 kernel_key_version,
-                                 kernel_version,
-                                 1,  /* kernel length. */
-                                 "testkeys/key_rsa1024.pem",
-                                 "testkeys/key_rsa1024.pem",
-                                 'K');
- if (!image)
-   return NULL;
- if (is_corrupt) {
-   /* Invalidate image. */
-   Memset(image->kernel_data, 'X', image->kernel_len);
- }
- kernel_blob = GetKernelBlob(image, &len);
- KernelImageFree(image);
- return kernel_blob;
-}
diff --git a/tests/test_common.h b/tests/test_common.h
index 5485fc45..d62071f7 100644
--- a/tests/test_common.h
+++ b/tests/test_common.h
@@ -9,8 +9,6 @@
 
 #include <stdint.h>
 
-#include "kernel_image.h"
-
 extern int gTestSuccess;
 
 /* Return 1 if result is equal to expected_result, else return 0.
@@ -20,29 +18,4 @@ int TEST_EQ(int result, int expected_result, char* testname);
  * Also update the global gTestSuccess flag if test fails. */
 int TEST_NEQ(int result, int not_expected_result, char* testname);
 
-/* Test kernel image generation functions. */
-KernelImage* GenerateTestKernelImage(int firmware_sign_algorithm,
-                                     int kernel_sign_algorithm,
-                                     const uint8_t* kernel_sign_key,
-                                     int kernel_key_version,
-                                     int kernel_version,
-                                     uint64_t kernel_len,
-                                     const char* firmware_key_file,
-                                     const char* kernel_key_file,
-                                     uint8_t kernel_data_fill_char);
-uint8_t* GenerateTestKernelBlob(int firmware_sign_algorithm,
-                                int kernel_sign_algorithm,
-                                const uint8_t* kernel_sign_key,
-                                int kernel_key_version,
-                                int kernel_version,
-                                uint64_t kernel_len,
-                                const char* firmware_key_file,
-                                const char* kernel_key_file);
-
-/* Generates a test kernel iamge for rollback tests with a given
- * [kernel_key_version} and [kernel_version]. If [is_corrupt] is 1,
- * then the image has invalid signatures and will fail verification. */
-uint8_t* GenerateRollbackTestKernelBlob(int kernel_key_version,
-                                        int kernel_version,
-                                        int is_corrupt);
 #endif  /* VBOOT_REFERENCE_TEST_COMMON_H_ */