kernel_samsung_msm8974/drivers/char/hw_random/msm_fips_selftest.c

/*
 * Copyright (c) 2014, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include "fips_drbg.h"
#include "ctr_drbg.h"
#include "msm_rng.h"
#include "msm_fips_selftest.h"

#define CTRAES128_ENTROPY_BYTES       (16)
#define CTRAES128_NONCE_BYTES         (8)
#define CTRAES128_MAX_OUTPUT_BYTES    (64)

struct ctr_drbg_testcase_s {
	char *name;
	char *entropy_string;
	char *nonce_string;
	char *reseed_entropy_string;
	char *expected_string;
};

static struct ctr_drbg_testcase_s t0 = {
	.name = "use_pr_0",
	.entropy_string = "\x8f\xb9\x57\x3a\x54\x62\x53\xcd"
			  "\xbf\x62\x15\xa1\x80\x5a\x41\x38",
	.nonce_string   = "\x7c\x2c\xe6\x54\x02\xbc\xa6\x83",
	.reseed_entropy_string = "\xbc\x5a\xd8\x9a\xe1\x8c\x49\x1f"
				 "\x90\xa2\xae\x9e\x7e\x2c\xf9\x9d",
	.expected_string = "\x07\x62\x82\xe8\x0e\x65\xd7\x70"
			   "\x1a\x35\xb3\x44\x63\x68\xb6\x16"
			   "\xf8\xd9\x62\x23\xb9\xb5\x11\x64"
			   "\x23\xa3\xa2\x32\xc7\x2c\xea\xbf"
			   "\x4a\xcc\xc4\x0a\xc6\x19\xd6\xaa"
			   "\x68\xae\xdb\x8b\x26\x70\xb8\x07"
			   "\xcc\xe9\x9f\xc2\x1b\x8f\xa5\x16"
			   "\xef\x75\xb6\x8f\xc0\x6c\x87\xc7",
};

static struct ctr_drbg_testcase_s t1 = {
	.name = "use_pr_1",
	.entropy_string = "\xa3\x56\xf3\x9a\xce\x48\x59\xb1"
			  "\xe1\x99\x49\x40\x22\x8e\xa4\xeb",
	.nonce_string   = "\xff\x33\xe9\x51\x39\xf7\x67\xf1",
	.reseed_entropy_string = "\x66\x8f\x0f\xe2\xd8\xa9\xa9\x29"
				 "\x20\xfc\xb9\xf3\x55\xd6\xc3\x4c",
	.expected_string = "\xa1\x06\x61\x65\x7b\x98\x0f\xac"
			   "\xce\x77\x91\xde\x7f\x6f\xe6\x1e"
			   "\x88\x15\xe5\xe2\x4c\xce\xb8\xa6"
			   "\x63\xf2\xe8\x2f\x5b\xfb\x16\x92"
			   "\x06\x2a\xf3\xa8\x59\x05\xe0\x5a"
			   "\x92\x9a\x07\x65\xc7\x41\x29\x3a"
			   "\x4b\x1d\x15\x3e\x02\x14\x7b\xdd"
			   "\x74\x5e\xbd\x70\x07\x4d\x6c\x08",
};

static struct ctr_drbg_testcase_s *testlist[] = {
	&t0, &t1
};

static int allzeroP(void *p, size_t len)
{
	size_t i;

	for (i = 0; i < len; ++i)
		if (((uint8_t *)p)[i] != 0)
			return 0;

	return 1;
}

/*
 * basic test.  return value is error count.
 */
int fips_ctraes128_df_known_answer_test(struct ctr_debg_test_inputs_s *tcase)
{
	struct ctr_drbg_ctx_s ctx;
	enum ctr_drbg_status_t rv;

	if (tcase->observed_string_len > CTRAES128_MAX_OUTPUT_BYTES) {
		pr_debug("known answer test output is bigger than 64!\n");
		return 1;
	}

	memset(&ctx, 0, sizeof(ctx));

	ctx.continuous_test_started = 1;

	rv = ctr_drbg_instantiate(&ctx,
				  tcase->entropy_string,
				  8 * CTRAES128_ENTROPY_BYTES,
				  tcase->nonce_string,
				  8 * CTRAES128_NONCE_BYTES,
				  1<<19);
	if (rv != CTR_DRBG_SUCCESS) {
		pr_err("test instantiate failed with code %d\n", rv);
		return 1;
	}

	rv = ctr_drbg_reseed(&ctx,
			     tcase->reseed_entropy_string,
			     8 * CTRAES128_ENTROPY_BYTES);
	if (rv != CTR_DRBG_SUCCESS) {
		pr_err("test reseed failed with code %d\n", rv);
		return 1;
	}

	rv = ctr_drbg_generate(&ctx,
			       tcase->observed_string,
			       tcase->observed_string_len * 8);
	if (rv != CTR_DRBG_SUCCESS) {
		pr_err("test generate (2) failed with code %d\n", rv);
		return 1;
	}

	rv = ctr_drbg_generate(&ctx,
			       tcase->observed_string,
			       tcase->observed_string_len * 8);
	if (rv != CTR_DRBG_SUCCESS) {
		pr_err("test generate (2) failed with code %d\n", rv);
		return 1;
	}

	ctr_drbg_uninstantiate(&ctx);

	if (!allzeroP(&ctx.seed, sizeof(ctx.seed))) {
		pr_err("test Final failed to zeroize the context\n");
		return 1;
	}

	pr_info("\n DRBG counter test done");
	return 0;

}

static int fips_drbg_healthcheck_sanitytest(void)
{
	struct ctr_drbg_ctx_s *p_ctx = NULL;
	enum ctr_drbg_status_t rv = CTR_DRBG_SUCCESS;
	char entropy_string[MSM_ENTROPY_BUFFER_SIZE];
	char nonce[MSM_NONCE_BUFFER_SIZE];
	char buffer[32];

	pr_info("start DRBG health check sanity test.\n");
	p_ctx = kzalloc(sizeof(struct ctr_drbg_ctx_s), GFP_KERNEL);
	if (NULL == p_ctx) {
		rv = CTR_DRBG_GENERAL_ERROR;
		pr_err("p_ctx kzalloc fail\n");
		goto outbuf;
	}

	/*
	 * test DRGB Instantiaion function error handling.
	 * Sends a NULL pointer as DTR-DRBG context.
	 */
	rv = ctr_drbg_instantiate(NULL,
				  entropy_string,
				  8 * CTRAES128_ENTROPY_BYTES,
				  nonce,
				  8 * CTRAES128_NONCE_BYTES,
				  1<<19);
	if (CTR_DRBG_SUCCESS == rv) {
		rv = CTR_DRBG_INVALID_ARG;
		pr_err("failed to handle NULL pointer of CTR context\n");
		goto outbuf;
	}

	/*
	 * test DRGB Instantiaion function error handling.
	 * Sends a NULL pointer as entropy input.
	 */
	rv = ctr_drbg_instantiate(p_ctx,
				  NULL,
				  8 * CTRAES128_ENTROPY_BYTES,
				  nonce,
				  8 * CTRAES128_NONCE_BYTES,
				  1<<19);
	if (CTR_DRBG_SUCCESS == rv) {
		rv = CTR_DRBG_INVALID_ARG;
		pr_err("failed to handle NULL pointer of entropy string\n");
		goto outbuf;
	}

	rv = ctr_drbg_instantiate(p_ctx,
				  entropy_string,
				  8 * CTRAES128_ENTROPY_BYTES,
				  NULL,
				  8 * CTRAES128_NONCE_BYTES,
				  1<<19);
	if (CTR_DRBG_SUCCESS == rv) {
		rv = CTR_DRBG_INVALID_ARG;
		pr_err("failed to handle NULL pointer of nonce string\n");
		goto outbuf;
	}

	/*
	 * test DRGB Instantiaion function error handling.
	 * Sends very long seed length.
	 */
	rv = ctr_drbg_instantiate(p_ctx,
				  entropy_string,
				  8 * CTRAES128_ENTROPY_BYTES,
				  nonce,
				  32 * CTRAES128_NONCE_BYTES,
				  1<<19);
	if (CTR_DRBG_SUCCESS == rv) {
		rv = CTR_DRBG_INVALID_ARG;
		pr_err("failed to handle incorrect seed size\n");
		goto outbuf;
	}


	rv = ctr_drbg_instantiate(p_ctx,
				  entropy_string,
				  8 * CTRAES128_ENTROPY_BYTES,
				  nonce,
				  8 * CTRAES128_NONCE_BYTES,
				  1<<19);
	if (CTR_DRBG_SUCCESS != rv) {
		pr_err("Instantiation failed to handle CTR-DRBG instance\n");
		goto outbuf;
	}

	/*
	 * test DRGB generator function error handling.
	 * set output string as NULL.
	 */
	rv = ctr_drbg_generate(p_ctx, NULL, 256);
	if (CTR_DRBG_SUCCESS == rv) {
		pr_err("failed to handle incorrect buffer pointer\n");
		rv = CTR_DRBG_INVALID_ARG;
		goto outdrbg;
	}

	rv = ctr_drbg_generate(p_ctx, &buffer,  1 << 20);
	if (CTR_DRBG_SUCCESS == rv) {
		pr_err("failed to handle too long output length\n");
		rv = CTR_DRBG_INVALID_ARG;
		goto outdrbg;
	}

	rv = ctr_drbg_generate(p_ctx, &buffer,  177);
	if (CTR_DRBG_SUCCESS == rv) {
		pr_err("failed to handle incorrect output length\n");
		rv = CTR_DRBG_INVALID_ARG;
		goto outdrbg;
	}

	pr_info("DRBG health check sanity test passed.\n");
	rv = CTR_DRBG_SUCCESS;

outdrbg:
	ctr_drbg_uninstantiate(p_ctx);

outbuf:
	if (p_ctx)
		kzfree(p_ctx);
	p_ctx = NULL;

	memset(buffer, 0, 32);
	memset(nonce, 0, MSM_NONCE_BUFFER_SIZE);
	memset(entropy_string, 0, MSM_ENTROPY_BUFFER_SIZE);

	return rv;
}

int fips_self_test(void)
{
	struct ctr_debg_test_inputs_s cavs_input;
	uint8_t entropy[CTRAES128_ENTROPY_BYTES];
	uint8_t nonce[CTRAES128_NONCE_BYTES];
	uint8_t reseed_entropy[CTRAES128_ENTROPY_BYTES];
	uint8_t expected[CTRAES128_MAX_OUTPUT_BYTES];
	uint8_t observed[CTRAES128_MAX_OUTPUT_BYTES];
	unsigned int i;
	int errors = 0;
	int ret;

	cavs_input.entropy_string = entropy;
	cavs_input.nonce_string = nonce;
	cavs_input.reseed_entropy_string = reseed_entropy;
	cavs_input.observed_string = observed;
	cavs_input.observed_string_len = CTRAES128_MAX_OUTPUT_BYTES;


	ret = fips_drbg_healthcheck_sanitytest();
	if (CTR_DRBG_SUCCESS != ret) {
		pr_err("DRBG health check fail\n");
		errors++;
		return errors;
	}

	for (i = 0;
	     i < sizeof(testlist)/sizeof(struct ctr_drbg_testcase_s *);
	     ++i) {
		memcpy(entropy,
			testlist[i]->entropy_string,
			CTRAES128_ENTROPY_BYTES);
		memcpy(nonce,
			testlist[i]->nonce_string,
			CTRAES128_NONCE_BYTES);
		memcpy(reseed_entropy,
			testlist[i]->reseed_entropy_string,
			CTRAES128_ENTROPY_BYTES);
		memcpy(expected,
			testlist[i]->expected_string,
			CTRAES128_MAX_OUTPUT_BYTES);

		pr_debug("starting test %s\n", testlist[i]->name);
		ret = fips_ctraes128_df_known_answer_test(&cavs_input);
		pr_debug("completed test %s\n\n", testlist[i]->name);
		if (0 != ret) {
			pr_debug("got error from drbg known answer test!\n");
			return 1;
		}

		if (memcmp(expected,
			cavs_input.observed_string,
			CTRAES128_MAX_OUTPUT_BYTES) != 0) {
			errors++;
			pr_info("%s: generate failed\n", testlist[i]->name);
			return 1;
		} else
			pr_info("%s: generate PASSED!\n", testlist[i]->name);
	}

	if (errors == 0)
		pr_debug("All tests passed\n");
	else
		pr_debug("%d tests failed\n", errors);

	return errors;

}