192 lines
6.8 KiB
Python
192 lines
6.8 KiB
Python
# 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.
|
|
|
|
import os
|
|
|
|
from autotest_lib.client.bin import test, utils
|
|
from autotest_lib.client.common_lib import error
|
|
|
|
class firmware_VbootCrypto(test.test):
|
|
"""
|
|
Tests for correctness of verified boot reference crypto implementation.
|
|
"""
|
|
version = 1
|
|
preserve_srcdir = True
|
|
|
|
# TODO(gauravsh): Disable this autotest until we have a way
|
|
# of running these in a 64-bit environment (since for x86, this
|
|
# code is run in 64-bit mode.
|
|
#
|
|
# This issue is tracked as Issue 3792 on the Chromium OS Bug Tracker.
|
|
# http://code.google.com/p/chromium-os/issues/detail?id=3792
|
|
def setup_Disabled(self):
|
|
os.chdir(self.srcdir)
|
|
utils.make('clean')
|
|
utils.make('all')
|
|
|
|
|
|
# Parses the [result] and output the key-value pairs.
|
|
def __output_result_keyvals(self, results):
|
|
for keyval in results.splitlines():
|
|
if keyval.strip().startswith('#'):
|
|
continue
|
|
key, val = keyval.split(':')
|
|
self.keyvals[key.strip()] = float(val)
|
|
|
|
|
|
def __generate_test_cases(self):
|
|
gen_test_case_cmd = os.path.join(self.srcdir, "tests",
|
|
"gen_test_cases.sh")
|
|
return_code = utils.system(gen_test_case_cmd, ignore_status = True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("Couldn't generate test cases")
|
|
return True
|
|
|
|
|
|
def __sha_test(self):
|
|
sha_test_cmd = os.path.join(self.srcdir, "tests", "sha_tests")
|
|
return_code = utils.system(sha_test_cmd, ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("SHA Test Error")
|
|
return True
|
|
|
|
|
|
def __rsa_test(self):
|
|
os.chdir(self.srcdir)
|
|
rsa_test_cmd = os.path.join(self.srcdir, "tests",
|
|
"run_rsa_tests.sh")
|
|
return_code = utils.system(rsa_test_cmd, ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("RSA Test Error")
|
|
return True
|
|
|
|
|
|
def __image_verification_test(self):
|
|
image_verification_cmd = "cd %s && ./run_image_verification_tests.sh" \
|
|
% os.path.join(self.srcdir, "tests")
|
|
return_code = utils.system(image_verification_cmd,
|
|
ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("Image Verification Test Error")
|
|
return True
|
|
|
|
|
|
def __sha_benchmark(self):
|
|
sha_benchmark_cmd = os.path.join(self.srcdir, "tests",
|
|
"sha_benchmark")
|
|
self.results = utils.system_output(sha_benchmark_cmd,
|
|
retain_output=True)
|
|
self.__output_result_keyvals(self.results)
|
|
|
|
|
|
def __rsa_benchmark(self):
|
|
rsa_benchmark_cmd = "cd %s && ./rsa_verify_benchmark" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
self.results = utils.system_output(rsa_benchmark_cmd,
|
|
retain_output=True)
|
|
self.__output_result_keyvals(self.results)
|
|
|
|
|
|
def __verify_image_benchmark(self):
|
|
firmware_benchmark_cmd = "cd %s && ./firmware_verify_benchmark" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
kernel_benchmark_cmd = "cd %s && ./kernel_verify_benchmark" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
self.results = utils.system_output(firmware_benchmark_cmd,
|
|
retain_output=True)
|
|
self.__output_result_keyvals(self.results)
|
|
self.results = utils.system_output(kernel_benchmark_cmd,
|
|
retain_output=True)
|
|
self.__output_result_keyvals(self.results)
|
|
|
|
|
|
def __rollback_tests(self):
|
|
firmware_rollback_test_cmd = "cd %s && ./firmware_rollback_tests" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
kernel_rollback_test_cmd = "cd %s && ./kernel_rollback_tests" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
return_code = utils.system(firmware_rollback_test_cmd,
|
|
ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("Firmware Rollback Test Error")
|
|
|
|
return_code = utils.system(kernel_rollback_test_cmd,
|
|
ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("KernelRollback Test Error")
|
|
return True
|
|
|
|
|
|
def __splicing_tests(self):
|
|
firmware_splicing_test_cmd = "cd %s && ./firmware_splicing_tests" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
kernel_splicing_test_cmd = "cd %s && ./kernel_splicing_tests" % \
|
|
os.path.join(self.srcdir, "tests")
|
|
return_code = utils.system(firmware_splicing_test_cmd,
|
|
ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("Firmware Splicing Test Error")
|
|
|
|
return_code = utils.system(kernel_splicing_test_cmd,
|
|
ignore_status=True)
|
|
if return_code == 255:
|
|
return False
|
|
if return_code == 1:
|
|
raise error.TestError("Kernel Splicing Test Error")
|
|
return True
|
|
|
|
|
|
def run_crypto(self):
|
|
success = self.__sha_test()
|
|
if not success:
|
|
raise error.TestFail("SHA Test Failed")
|
|
success = self.__rsa_test()
|
|
if not success:
|
|
raise error.TestFail("RSA Test Failed")
|
|
|
|
|
|
def run_verification(self):
|
|
success = self.__image_verification_test()
|
|
if not success:
|
|
raise error.TestFail("Image Verification Test Failed")
|
|
|
|
|
|
def run_benchmarks(self):
|
|
self.keyvals = {}
|
|
self.__sha_benchmark()
|
|
self.__rsa_benchmark()
|
|
self.__verify_image_benchmark()
|
|
self.write_perf_keyval(self.keyvals)
|
|
|
|
|
|
def run_rollback(self):
|
|
success = self.__rollback_tests()
|
|
if not success:
|
|
raise error.TestFail("Rollback Tests Failed")
|
|
|
|
|
|
def run_splicing(self):
|
|
success = self.__splicing_tests()
|
|
if not success:
|
|
raise error.TestFail("Splicing Tests Failed")
|
|
|
|
|
|
def run_once(self, suite='crypto'):
|
|
self.__generate_test_cases()
|
|
getattr(self, 'run_' + suite)()
|