# 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 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)()