[mirror_zfs.git] / tests / zfs-tests / tests / functional / checksum / skein_test.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://opensource.org/licenses/CDDL-1.0.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2013 Saso Kiselkov. All rights reserved.
 */

/*
 * This is just to keep the compiler happy about sys/time.h not declaring
 * gettimeofday due to -D_KERNEL (we can do this since we're actually
 * running in userspace, but we need -D_KERNEL for the remaining Skein code).
 */
#ifdef	_KERNEL
#undef	_KERNEL
#endif

#include <sys/skein.h>
#include <stdlib.h>
#include <strings.h>
#include <stdio.h>
#include <sys/time.h>
#include <sys/stdtypes.h>

/*
 * Skein test suite using values from the Skein V1.3 specification found at:
 * http://www.skein-hash.info/sites/default/files/skein1.3.pdf
 */

/*
 * Test messages from the Skein spec, Appendix C.
 */
const uint8_t	test_msg0[] = {
	0xFF
};

const uint8_t	test_msg1[] = {
	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0
};

const uint8_t	test_msg2[] = {
	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0,
	0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8,
	0xD7, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0,
	0xCF, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 0xC9, 0xC8,
	0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0
};

const uint8_t	test_msg3[] = {
	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0,
	0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8,
	0xD7, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0,
	0xCF, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 0xC9, 0xC8,
	0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0,
	0xBF, 0xBE, 0xBD, 0xBC, 0xBB, 0xBA, 0xB9, 0xB8,
	0xB7, 0xB6, 0xB5, 0xB4, 0xB3, 0xB2, 0xB1, 0xB0,
	0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8,
	0xA7, 0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0,
	0x9F, 0x9E, 0x9D, 0x9C, 0x9B, 0x9A, 0x99, 0x98,
	0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
	0x8F, 0x8E, 0x8D, 0x8C, 0x8B, 0x8A, 0x89, 0x88,
	0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80
};

const uint8_t	test_msg4[] = {
	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0,
	0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8,
	0xD7, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0,
	0xCF, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 0xC9, 0xC8,
	0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0,
	0xBF, 0xBE, 0xBD, 0xBC, 0xBB, 0xBA, 0xB9, 0xB8,
	0xB7, 0xB6, 0xB5, 0xB4, 0xB3, 0xB2, 0xB1, 0xB0,
	0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8,
	0xA7, 0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0,
	0x9F, 0x9E, 0x9D, 0x9C, 0x9B, 0x9A, 0x99, 0x98,
	0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
	0x8F, 0x8E, 0x8D, 0x8C, 0x8B, 0x8A, 0x89, 0x88,
	0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
	0x7F, 0x7E, 0x7D, 0x7C, 0x7B, 0x7A, 0x79, 0x78,
	0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
	0x6F, 0x6E, 0x6D, 0x6C, 0x6B, 0x6A, 0x69, 0x68,
	0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
	0x5F, 0x5E, 0x5D, 0x5C, 0x5B, 0x5A, 0x59, 0x58,
	0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
	0x4F, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A, 0x49, 0x48,
	0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
	0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39, 0x38,
	0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
	0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 0x28,
	0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
	0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18,
	0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
	0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
	0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00
};

/*
 * Test digests from the Skein spec, Appendix C.
 */
const uint8_t	skein_256_test_digests[][32] = {
	{
		/* for test_msg0 */
		0x0B, 0x98, 0xDC, 0xD1, 0x98, 0xEA, 0x0E, 0x50,
		0xA7, 0xA2, 0x44, 0xC4, 0x44, 0xE2, 0x5C, 0x23,
		0xDA, 0x30, 0xC1, 0x0F, 0xC9, 0xA1, 0xF2, 0x70,
		0xA6, 0x63, 0x7F, 0x1F, 0x34, 0xE6, 0x7E, 0xD2
	},
	{
		/* for test_msg1 */
		0x8D, 0x0F, 0xA4, 0xEF, 0x77, 0x7F, 0xD7, 0x59,
		0xDF, 0xD4, 0x04, 0x4E, 0x6F, 0x6A, 0x5A, 0xC3,
		0xC7, 0x74, 0xAE, 0xC9, 0x43, 0xDC, 0xFC, 0x07,
		0x92, 0x7B, 0x72, 0x3B, 0x5D, 0xBF, 0x40, 0x8B
	},
	{
		/* for test_msg2 */
		0xDF, 0x28, 0xE9, 0x16, 0x63, 0x0D, 0x0B, 0x44,
		0xC4, 0xA8, 0x49, 0xDC, 0x9A, 0x02, 0xF0, 0x7A,
		0x07, 0xCB, 0x30, 0xF7, 0x32, 0x31, 0x82, 0x56,
		0xB1, 0x5D, 0x86, 0x5A, 0xC4, 0xAE, 0x16, 0x2F
	}
	/* no test digests for test_msg3 and test_msg4 */
};

const uint8_t	skein_512_test_digests[][64] = {
	{
		/* for test_msg0 */
		0x71, 0xB7, 0xBC, 0xE6, 0xFE, 0x64, 0x52, 0x22,
		0x7B, 0x9C, 0xED, 0x60, 0x14, 0x24, 0x9E, 0x5B,
		0xF9, 0xA9, 0x75, 0x4C, 0x3A, 0xD6, 0x18, 0xCC,
		0xC4, 0xE0, 0xAA, 0xE1, 0x6B, 0x31, 0x6C, 0xC8,
		0xCA, 0x69, 0x8D, 0x86, 0x43, 0x07, 0xED, 0x3E,
		0x80, 0xB6, 0xEF, 0x15, 0x70, 0x81, 0x2A, 0xC5,
		0x27, 0x2D, 0xC4, 0x09, 0xB5, 0xA0, 0x12, 0xDF,
		0x2A, 0x57, 0x91, 0x02, 0xF3, 0x40, 0x61, 0x7A
	},
	{
		/* no test vector for test_msg1 */
		0,
	},
	{
		/* for test_msg2 */
		0x45, 0x86, 0x3B, 0xA3, 0xBE, 0x0C, 0x4D, 0xFC,
		0x27, 0xE7, 0x5D, 0x35, 0x84, 0x96, 0xF4, 0xAC,
		0x9A, 0x73, 0x6A, 0x50, 0x5D, 0x93, 0x13, 0xB4,
		0x2B, 0x2F, 0x5E, 0xAD, 0xA7, 0x9F, 0xC1, 0x7F,
		0x63, 0x86, 0x1E, 0x94, 0x7A, 0xFB, 0x1D, 0x05,
		0x6A, 0xA1, 0x99, 0x57, 0x5A, 0xD3, 0xF8, 0xC9,
		0xA3, 0xCC, 0x17, 0x80, 0xB5, 0xE5, 0xFA, 0x4C,
		0xAE, 0x05, 0x0E, 0x98, 0x98, 0x76, 0x62, 0x5B
	},
	{
		/* for test_msg3 */
		0x91, 0xCC, 0xA5, 0x10, 0xC2, 0x63, 0xC4, 0xDD,
		0xD0, 0x10, 0x53, 0x0A, 0x33, 0x07, 0x33, 0x09,
		0x62, 0x86, 0x31, 0xF3, 0x08, 0x74, 0x7E, 0x1B,
		0xCB, 0xAA, 0x90, 0xE4, 0x51, 0xCA, 0xB9, 0x2E,
		0x51, 0x88, 0x08, 0x7A, 0xF4, 0x18, 0x87, 0x73,
		0xA3, 0x32, 0x30, 0x3E, 0x66, 0x67, 0xA7, 0xA2,
		0x10, 0x85, 0x6F, 0x74, 0x21, 0x39, 0x00, 0x00,
		0x71, 0xF4, 0x8E, 0x8B, 0xA2, 0xA5, 0xAD, 0xB7
	}
	/* no test digests for test_msg4 */
};

const uint8_t	skein_1024_test_digests[][128] = {
	{
		/* for test_msg0 */
		0xE6, 0x2C, 0x05, 0x80, 0x2E, 0xA0, 0x15, 0x24,
		0x07, 0xCD, 0xD8, 0x78, 0x7F, 0xDA, 0x9E, 0x35,
		0x70, 0x3D, 0xE8, 0x62, 0xA4, 0xFB, 0xC1, 0x19,
		0xCF, 0xF8, 0x59, 0x0A, 0xFE, 0x79, 0x25, 0x0B,
		0xCC, 0xC8, 0xB3, 0xFA, 0xF1, 0xBD, 0x24, 0x22,
		0xAB, 0x5C, 0x0D, 0x26, 0x3F, 0xB2, 0xF8, 0xAF,
		0xB3, 0xF7, 0x96, 0xF0, 0x48, 0x00, 0x03, 0x81,
		0x53, 0x1B, 0x6F, 0x00, 0xD8, 0x51, 0x61, 0xBC,
		0x0F, 0xFF, 0x4B, 0xEF, 0x24, 0x86, 0xB1, 0xEB,
		0xCD, 0x37, 0x73, 0xFA, 0xBF, 0x50, 0xAD, 0x4A,
		0xD5, 0x63, 0x9A, 0xF9, 0x04, 0x0E, 0x3F, 0x29,
		0xC6, 0xC9, 0x31, 0x30, 0x1B, 0xF7, 0x98, 0x32,
		0xE9, 0xDA, 0x09, 0x85, 0x7E, 0x83, 0x1E, 0x82,
		0xEF, 0x8B, 0x46, 0x91, 0xC2, 0x35, 0x65, 0x65,
		0x15, 0xD4, 0x37, 0xD2, 0xBD, 0xA3, 0x3B, 0xCE,
		0xC0, 0x01, 0xC6, 0x7F, 0xFD, 0xE1, 0x5B, 0xA8
	},
	{
		/* no test vector for test_msg1 */
		0
	},
	{
		/* no test vector for test_msg2 */
		0
	},
	{
		/* for test_msg3 */
		0x1F, 0x3E, 0x02, 0xC4, 0x6F, 0xB8, 0x0A, 0x3F,
		0xCD, 0x2D, 0xFB, 0xBC, 0x7C, 0x17, 0x38, 0x00,
		0xB4, 0x0C, 0x60, 0xC2, 0x35, 0x4A, 0xF5, 0x51,
		0x18, 0x9E, 0xBF, 0x43, 0x3C, 0x3D, 0x85, 0xF9,
		0xFF, 0x18, 0x03, 0xE6, 0xD9, 0x20, 0x49, 0x31,
		0x79, 0xED, 0x7A, 0xE7, 0xFC, 0xE6, 0x9C, 0x35,
		0x81, 0xA5, 0xA2, 0xF8, 0x2D, 0x3E, 0x0C, 0x7A,
		0x29, 0x55, 0x74, 0xD0, 0xCD, 0x7D, 0x21, 0x7C,
		0x48, 0x4D, 0x2F, 0x63, 0x13, 0xD5, 0x9A, 0x77,
		0x18, 0xEA, 0xD0, 0x7D, 0x07, 0x29, 0xC2, 0x48,
		0x51, 0xD7, 0xE7, 0xD2, 0x49, 0x1B, 0x90, 0x2D,
		0x48, 0x91, 0x94, 0xE6, 0xB7, 0xD3, 0x69, 0xDB,
		0x0A, 0xB7, 0xAA, 0x10, 0x6F, 0x0E, 0xE0, 0xA3,
		0x9A, 0x42, 0xEF, 0xC5, 0x4F, 0x18, 0xD9, 0x37,
		0x76, 0x08, 0x09, 0x85, 0xF9, 0x07, 0x57, 0x4F,
		0x99, 0x5E, 0xC6, 0xA3, 0x71, 0x53, 0xA5, 0x78
	},
	{
		/* for test_msg4 */
		0x84, 0x2A, 0x53, 0xC9, 0x9C, 0x12, 0xB0, 0xCF,
		0x80, 0xCF, 0x69, 0x49, 0x1B, 0xE5, 0xE2, 0xF7,
		0x51, 0x5D, 0xE8, 0x73, 0x3B, 0x6E, 0xA9, 0x42,
		0x2D, 0xFD, 0x67, 0x66, 0x65, 0xB5, 0xFA, 0x42,
		0xFF, 0xB3, 0xA9, 0xC4, 0x8C, 0x21, 0x77, 0x77,
		0x95, 0x08, 0x48, 0xCE, 0xCD, 0xB4, 0x8F, 0x64,
		0x0F, 0x81, 0xFB, 0x92, 0xBE, 0xF6, 0xF8, 0x8F,
		0x7A, 0x85, 0xC1, 0xF7, 0xCD, 0x14, 0x46, 0xC9,
		0x16, 0x1C, 0x0A, 0xFE, 0x8F, 0x25, 0xAE, 0x44,
		0x4F, 0x40, 0xD3, 0x68, 0x00, 0x81, 0xC3, 0x5A,
		0xA4, 0x3F, 0x64, 0x0F, 0xD5, 0xFA, 0x3C, 0x3C,
		0x03, 0x0B, 0xCC, 0x06, 0xAB, 0xAC, 0x01, 0xD0,
		0x98, 0xBC, 0xC9, 0x84, 0xEB, 0xD8, 0x32, 0x27,
		0x12, 0x92, 0x1E, 0x00, 0xB1, 0xBA, 0x07, 0xD6,
		0xD0, 0x1F, 0x26, 0x90, 0x70, 0x50, 0x25, 0x5E,
		0xF2, 0xC8, 0xE2, 0x4F, 0x71, 0x6C, 0x52, 0xA5
	}
};

int
main(int argc, char *argv[])
{
	boolean_t	failed = B_FALSE;
	uint64_t	cpu_mhz = 0;

	if (argc == 2)
		cpu_mhz = atoi(argv[1]);

#define	SKEIN_ALGO_TEST(_m, mode, diglen, testdigest)			\
	do {								\
		Skein ## mode ## _Ctxt_t	ctx;			\
		uint8_t				digest[diglen / 8];	\
		(void) Skein ## mode ## _Init(&ctx, diglen);		\
		(void) Skein ## mode ## _Update(&ctx, _m, sizeof (_m));	\
		(void) Skein ## mode ## _Final(&ctx, digest);		\
		(void) printf("Skein" #mode "/" #diglen			\
		    "\tMessage: " #_m "\tResult: ");			\
		if (memcmp(digest, testdigest, diglen / 8) == 0) {	\
			(void) printf("OK\n");				\
		} else {						\
			(void) printf("FAILED!\n");			\
			failed = B_TRUE;				\
		}							\
	} while (0)

#define	SKEIN_PERF_TEST(mode, diglen)					\
	do {								\
		Skein ## mode ## _Ctxt_t ctx;				\
		uint8_t		digest[diglen / 8];			\
		uint8_t		block[131072];				\
		uint64_t	delta;					\
		double		cpb = 0;				\
		int		i;					\
		struct timeval	start, end;				\
		memset(block, 0, sizeof (block));			\
		(void) gettimeofday(&start, NULL);			\
		(void) Skein ## mode ## _Init(&ctx, diglen);		\
		for (i = 0; i < 8192; i++) {				\
			(void) Skein ## mode ## _Update(&ctx, block,	\
			    sizeof (block));				\
		}							\
		(void) Skein ## mode ## _Final(&ctx, digest);		\
		(void) gettimeofday(&end, NULL);			\
		delta = (end.tv_sec * 1000000llu + end.tv_usec) -	\
		    (start.tv_sec * 1000000llu + start.tv_usec);	\
		if (cpu_mhz != 0) {					\
			cpb = (cpu_mhz * 1e6 * ((double)delta /		\
			    1000000)) / (8192 * 128 * 1024);		\
		}							\
		(void) printf("Skein" #mode "/" #diglen "\t%llu us "	\
		    "(%.02f CPB)\n", (u_longlong_t)delta, cpb);		\
	} while (0)

	(void) printf("Running algorithm correctness tests:\n");
	SKEIN_ALGO_TEST(test_msg0, _256, 256, skein_256_test_digests[0]);
	SKEIN_ALGO_TEST(test_msg1, _256, 256, skein_256_test_digests[1]);
	SKEIN_ALGO_TEST(test_msg2, _256, 256, skein_256_test_digests[2]);
	SKEIN_ALGO_TEST(test_msg0, _512, 512, skein_512_test_digests[0]);
	SKEIN_ALGO_TEST(test_msg2, _512, 512, skein_512_test_digests[2]);
	SKEIN_ALGO_TEST(test_msg3, _512, 512, skein_512_test_digests[3]);
	SKEIN_ALGO_TEST(test_msg0, 1024, 1024, skein_1024_test_digests[0]);
	SKEIN_ALGO_TEST(test_msg3, 1024, 1024, skein_1024_test_digests[3]);
	SKEIN_ALGO_TEST(test_msg4, 1024, 1024, skein_1024_test_digests[4]);
	if (failed)
		return (1);

	(void) printf("Running performance tests (hashing 1024 MiB of "
	    "data):\n");
	SKEIN_PERF_TEST(_256, 256);
	SKEIN_PERF_TEST(_512, 512);
	SKEIN_PERF_TEST(1024, 1024);

	return (0);
}
Commit	Line	Data
3c67d83a TH	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License (the "License").
	6	* You may not use this file except in compliance with the License.
	7	*
	8	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
	9	* or http://opensource.org/licenses/CDDL-1.0.
	10	* See the License for the specific language governing permissions
	11	* and limitations under the License.
	12	*
	13	* When distributing Covered Code, include this CDDL HEADER in each
	14	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	15	* If applicable, add the following below this CDDL HEADER, with the
	16	* fields enclosed by brackets "[]" replaced with your own identifying
	17	* information: Portions Copyright [yyyy] [name of copyright owner]
	18	*
	19	* CDDL HEADER END
	20	*/
	21
	22	/*
	23	* Copyright 2013 Saso Kiselkov. All rights reserved.
	24	*/
	25
	26	/*
	27	* This is just to keep the compiler happy about sys/time.h not declaring
	28	* gettimeofday due to -D_KERNEL (we can do this since we're actually
	29	* running in userspace, but we need -D_KERNEL for the remaining Skein code).
	30	*/
	31	#ifdef _KERNEL
	32	#undef _KERNEL
	33	#endif
	34
	35	#include <sys/skein.h>
	36	#include <stdlib.h>
	37	#include <strings.h>
	38	#include <stdio.h>
	39	#include <sys/time.h>
d31277ab	40	#include <sys/stdtypes.h>
3c67d83a	41
3c67d83a TH	42	/*
	43	* Skein test suite using values from the Skein V1.3 specification found at:
	44	* http://www.skein-hash.info/sites/default/files/skein1.3.pdf
	45	*/
	46
	47	/*
	48	* Test messages from the Skein spec, Appendix C.
	49	*/
	50	const uint8_t test_msg0[] = {
	51	0xFF
	52	};
	53
	54	const uint8_t test_msg1[] = {
	55	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	56	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	57	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	58	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0
	59	};
	60
	61	const uint8_t test_msg2[] = {
	62	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	63	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	64	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	65	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0,
	66	0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8,
	67	0xD7, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0,
	68	0xCF, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 0xC9, 0xC8,
	69	0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0
	70	};
	71
	72	const uint8_t test_msg3[] = {
	73	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	74	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	75	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	76	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0,
	77	0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8,
	78	0xD7, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0,
	79	0xCF, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 0xC9, 0xC8,
	80	0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0,
	81	0xBF, 0xBE, 0xBD, 0xBC, 0xBB, 0xBA, 0xB9, 0xB8,
	82	0xB7, 0xB6, 0xB5, 0xB4, 0xB3, 0xB2, 0xB1, 0xB0,
	83	0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8,
	84	0xA7, 0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0,
	85	0x9F, 0x9E, 0x9D, 0x9C, 0x9B, 0x9A, 0x99, 0x98,
	86	0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
	87	0x8F, 0x8E, 0x8D, 0x8C, 0x8B, 0x8A, 0x89, 0x88,
	88	0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80
	89	};
	90
	91	const uint8_t test_msg4[] = {
	92	0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8,
	93	0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0,
	94	0xEF, 0xEE, 0xED, 0xEC, 0xEB, 0xEA, 0xE9, 0xE8,
	95	0xE7, 0xE6, 0xE5, 0xE4, 0xE3, 0xE2, 0xE1, 0xE0,
	96	0xDF, 0xDE, 0xDD, 0xDC, 0xDB, 0xDA, 0xD9, 0xD8,
	97	0xD7, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xD0,
	98	0xCF, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 0xC9, 0xC8,
	99	0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0,
	100	0xBF, 0xBE, 0xBD, 0xBC, 0xBB, 0xBA, 0xB9, 0xB8,
	101	0xB7, 0xB6, 0xB5, 0xB4, 0xB3, 0xB2, 0xB1, 0xB0,
	102	0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8,
	103	0xA7, 0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0,
	104	0x9F, 0x9E, 0x9D, 0x9C, 0x9B, 0x9A, 0x99, 0x98,
	105	0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
106	0x8F, 0x8E, 0x8D, 0x8C, 0x8B, 0x8A, 0x89, 0x88,
107	0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
108	0x7F, 0x7E, 0x7D, 0x7C, 0x7B, 0x7A, 0x79, 0x78,
109	0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
110	0x6F, 0x6E, 0x6D, 0x6C, 0x6B, 0x6A, 0x69, 0x68,
111	0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
112	0x5F, 0x5E, 0x5D, 0x5C, 0x5B, 0x5A, 0x59, 0x58,
113	0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
114	0x4F, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A, 0x49, 0x48,
115	0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
116	0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39, 0x38,
117	0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
118	0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 0x28,
119	0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
120	0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18,
121	0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
122	0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
123	0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00
124	};
125
126	/*
127	* Test digests from the Skein spec, Appendix C.
128	*/
129	const uint8_t skein_256_test_digests[][32] = {
130	{
131	/* for test_msg0 */
132	0x0B, 0x98, 0xDC, 0xD1, 0x98, 0xEA, 0x0E, 0x50,
133	0xA7, 0xA2, 0x44, 0xC4, 0x44, 0xE2, 0x5C, 0x23,
134	0xDA, 0x30, 0xC1, 0x0F, 0xC9, 0xA1, 0xF2, 0x70,
135	0xA6, 0x63, 0x7F, 0x1F, 0x34, 0xE6, 0x7E, 0xD2
136	},
137	{
138	/* for test_msg1 */
139	0x8D, 0x0F, 0xA4, 0xEF, 0x77, 0x7F, 0xD7, 0x59,
140	0xDF, 0xD4, 0x04, 0x4E, 0x6F, 0x6A, 0x5A, 0xC3,
141	0xC7, 0x74, 0xAE, 0xC9, 0x43, 0xDC, 0xFC, 0x07,
142	0x92, 0x7B, 0x72, 0x3B, 0x5D, 0xBF, 0x40, 0x8B
143	},
144	{
145	/* for test_msg2 */
146	0xDF, 0x28, 0xE9, 0x16, 0x63, 0x0D, 0x0B, 0x44,
147	0xC4, 0xA8, 0x49, 0xDC, 0x9A, 0x02, 0xF0, 0x7A,
148	0x07, 0xCB, 0x30, 0xF7, 0x32, 0x31, 0x82, 0x56,
149	0xB1, 0x5D, 0x86, 0x5A, 0xC4, 0xAE, 0x16, 0x2F
150	}
151	/* no test digests for test_msg3 and test_msg4 */
152	};
153
154	const uint8_t skein_512_test_digests[][64] = {
155	{
156	/* for test_msg0 */
157	0x71, 0xB7, 0xBC, 0xE6, 0xFE, 0x64, 0x52, 0x22,
158	0x7B, 0x9C, 0xED, 0x60, 0x14, 0x24, 0x9E, 0x5B,
159	0xF9, 0xA9, 0x75, 0x4C, 0x3A, 0xD6, 0x18, 0xCC,
160	0xC4, 0xE0, 0xAA, 0xE1, 0x6B, 0x31, 0x6C, 0xC8,
161	0xCA, 0x69, 0x8D, 0x86, 0x43, 0x07, 0xED, 0x3E,
162	0x80, 0xB6, 0xEF, 0x15, 0x70, 0x81, 0x2A, 0xC5,
163	0x27, 0x2D, 0xC4, 0x09, 0xB5, 0xA0, 0x12, 0xDF,
164	0x2A, 0x57, 0x91, 0x02, 0xF3, 0x40, 0x61, 0x7A
165	},
166	{
167	/* no test vector for test_msg1 */
168	0,
169	},
170	{
171	/* for test_msg2 */
172	0x45, 0x86, 0x3B, 0xA3, 0xBE, 0x0C, 0x4D, 0xFC,
173	0x27, 0xE7, 0x5D, 0x35, 0x84, 0x96, 0xF4, 0xAC,
174	0x9A, 0x73, 0x6A, 0x50, 0x5D, 0x93, 0x13, 0xB4,
175	0x2B, 0x2F, 0x5E, 0xAD, 0xA7, 0x9F, 0xC1, 0x7F,
176	0x63, 0x86, 0x1E, 0x94, 0x7A, 0xFB, 0x1D, 0x05,
177	0x6A, 0xA1, 0x99, 0x57, 0x5A, 0xD3, 0xF8, 0xC9,
178	0xA3, 0xCC, 0x17, 0x80, 0xB5, 0xE5, 0xFA, 0x4C,
179	0xAE, 0x05, 0x0E, 0x98, 0x98, 0x76, 0x62, 0x5B
180	},
181	{
182	/* for test_msg3 */
183	0x91, 0xCC, 0xA5, 0x10, 0xC2, 0x63, 0xC4, 0xDD,
184	0xD0, 0x10, 0x53, 0x0A, 0x33, 0x07, 0x33, 0x09,
185	0x62, 0x86, 0x31, 0xF3, 0x08, 0x74, 0x7E, 0x1B,
186	0xCB, 0xAA, 0x90, 0xE4, 0x51, 0xCA, 0xB9, 0x2E,
187	0x51, 0x88, 0x08, 0x7A, 0xF4, 0x18, 0x87, 0x73,
188	0xA3, 0x32, 0x30, 0x3E, 0x66, 0x67, 0xA7, 0xA2,
189	0x10, 0x85, 0x6F, 0x74, 0x21, 0x39, 0x00, 0x00,
190	0x71, 0xF4, 0x8E, 0x8B, 0xA2, 0xA5, 0xAD, 0xB7
191	}
192	/* no test digests for test_msg4 */
193	};
194
195	const uint8_t skein_1024_test_digests[][128] = {
196	{
197	/* for test_msg0 */
198	0xE6, 0x2C, 0x05, 0x80, 0x2E, 0xA0, 0x15, 0x24,
199	0x07, 0xCD, 0xD8, 0x78, 0x7F, 0xDA, 0x9E, 0x35,
200	0x70, 0x3D, 0xE8, 0x62, 0xA4, 0xFB, 0xC1, 0x19,
201	0xCF, 0xF8, 0x59, 0x0A, 0xFE, 0x79, 0x25, 0x0B,
202	0xCC, 0xC8, 0xB3, 0xFA, 0xF1, 0xBD, 0x24, 0x22,
203	0xAB, 0x5C, 0x0D, 0x26, 0x3F, 0xB2, 0xF8, 0xAF,
204	0xB3, 0xF7, 0x96, 0xF0, 0x48, 0x00, 0x03, 0x81,
205	0x53, 0x1B, 0x6F, 0x00, 0xD8, 0x51, 0x61, 0xBC,
206	0x0F, 0xFF, 0x4B, 0xEF, 0x24, 0x86, 0xB1, 0xEB,
207	0xCD, 0x37, 0x73, 0xFA, 0xBF, 0x50, 0xAD, 0x4A,
208	0xD5, 0x63, 0x9A, 0xF9, 0x04, 0x0E, 0x3F, 0x29,
209	0xC6, 0xC9, 0x31, 0x30, 0x1B, 0xF7, 0x98, 0x32,
210	0xE9, 0xDA, 0x09, 0x85, 0x7E, 0x83, 0x1E, 0x82,
211	0xEF, 0x8B, 0x46, 0x91, 0xC2, 0x35, 0x65, 0x65,
212	0x15, 0xD4, 0x37, 0xD2, 0xBD, 0xA3, 0x3B, 0xCE,
213	0xC0, 0x01, 0xC6, 0x7F, 0xFD, 0xE1, 0x5B, 0xA8
214	},
215	{
216	/* no test vector for test_msg1 */
217	0
218	},
219	{
220	/* no test vector for test_msg2 */
221	0
222	},
223	{
224	/* for test_msg3 */
225	0x1F, 0x3E, 0x02, 0xC4, 0x6F, 0xB8, 0x0A, 0x3F,
226	0xCD, 0x2D, 0xFB, 0xBC, 0x7C, 0x17, 0x38, 0x00,
227	0xB4, 0x0C, 0x60, 0xC2, 0x35, 0x4A, 0xF5, 0x51,
228	0x18, 0x9E, 0xBF, 0x43, 0x3C, 0x3D, 0x85, 0xF9,
229	0xFF, 0x18, 0x03, 0xE6, 0xD9, 0x20, 0x49, 0x31,
230	0x79, 0xED, 0x7A, 0xE7, 0xFC, 0xE6, 0x9C, 0x35,
231	0x81, 0xA5, 0xA2, 0xF8, 0x2D, 0x3E, 0x0C, 0x7A,
232	0x29, 0x55, 0x74, 0xD0, 0xCD, 0x7D, 0x21, 0x7C,
233	0x48, 0x4D, 0x2F, 0x63, 0x13, 0xD5, 0x9A, 0x77,
234	0x18, 0xEA, 0xD0, 0x7D, 0x07, 0x29, 0xC2, 0x48,
235	0x51, 0xD7, 0xE7, 0xD2, 0x49, 0x1B, 0x90, 0x2D,
236	0x48, 0x91, 0x94, 0xE6, 0xB7, 0xD3, 0x69, 0xDB,
237	0x0A, 0xB7, 0xAA, 0x10, 0x6F, 0x0E, 0xE0, 0xA3,
238	0x9A, 0x42, 0xEF, 0xC5, 0x4F, 0x18, 0xD9, 0x37,
239	0x76, 0x08, 0x09, 0x85, 0xF9, 0x07, 0x57, 0x4F,
240	0x99, 0x5E, 0xC6, 0xA3, 0x71, 0x53, 0xA5, 0x78
241	},
242	{
243	/* for test_msg4 */
244	0x84, 0x2A, 0x53, 0xC9, 0x9C, 0x12, 0xB0, 0xCF,
245	0x80, 0xCF, 0x69, 0x49, 0x1B, 0xE5, 0xE2, 0xF7,
246	0x51, 0x5D, 0xE8, 0x73, 0x3B, 0x6E, 0xA9, 0x42,
247	0x2D, 0xFD, 0x67, 0x66, 0x65, 0xB5, 0xFA, 0x42,
248	0xFF, 0xB3, 0xA9, 0xC4, 0x8C, 0x21, 0x77, 0x77,
249	0x95, 0x08, 0x48, 0xCE, 0xCD, 0xB4, 0x8F, 0x64,
250	0x0F, 0x81, 0xFB, 0x92, 0xBE, 0xF6, 0xF8, 0x8F,
251	0x7A, 0x85, 0xC1, 0xF7, 0xCD, 0x14, 0x46, 0xC9,
252	0x16, 0x1C, 0x0A, 0xFE, 0x8F, 0x25, 0xAE, 0x44,
253	0x4F, 0x40, 0xD3, 0x68, 0x00, 0x81, 0xC3, 0x5A,
254	0xA4, 0x3F, 0x64, 0x0F, 0xD5, 0xFA, 0x3C, 0x3C,
255	0x03, 0x0B, 0xCC, 0x06, 0xAB, 0xAC, 0x01, 0xD0,
256	0x98, 0xBC, 0xC9, 0x84, 0xEB, 0xD8, 0x32, 0x27,
257	0x12, 0x92, 0x1E, 0x00, 0xB1, 0xBA, 0x07, 0xD6,
258	0xD0, 0x1F, 0x26, 0x90, 0x70, 0x50, 0x25, 0x5E,
259	0xF2, 0xC8, 0xE2, 0x4F, 0x71, 0x6C, 0x52, 0xA5
260	}
261	};
262
263	int
264	main(int argc, char *argv[])
265	{
266	boolean_t failed = B_FALSE;
267	uint64_t cpu_mhz = 0;
268
269	if (argc == 2)
270	cpu_mhz = atoi(argv[1]);
271
272	#define SKEIN_ALGO_TEST(_m, mode, diglen, testdigest) \
273	do { \
274	Skein ## mode ## _Ctxt_t ctx; \
275	uint8_t digest[diglen / 8]; \
276	(void) Skein ## mode ## _Init(&ctx, diglen); \
277	(void) Skein ## mode ## _Update(&ctx, _m, sizeof (_m)); \
278	(void) Skein ## mode ## _Final(&ctx, digest); \
279	(void) printf("Skein" #mode "/" #diglen \
280	"\tMessage: " #_m "\tResult: "); \
861166b0	281	if (memcmp(digest, testdigest, diglen / 8) == 0) { \
3c67d83a TH	282	(void) printf("OK\n"); \
	283	} else { \
	284	(void) printf("FAILED!\n"); \
	285	failed = B_TRUE; \
	286	} \
3c67d83a TH	287	} while (0)
	288
	289	#define SKEIN_PERF_TEST(mode, diglen) \
	290	do { \
	291	Skein ## mode ## _Ctxt_t ctx; \
	292	uint8_t digest[diglen / 8]; \
	293	uint8_t block[131072]; \
	294	uint64_t delta; \
	295	double cpb = 0; \
	296	int i; \
	297	struct timeval start, end; \
861166b0	298	memset(block, 0, sizeof (block)); \
3c67d83a TH	299	(void) gettimeofday(&start, NULL); \
	300	(void) Skein ## mode ## _Init(&ctx, diglen); \
	301	for (i = 0; i < 8192; i++) { \
	302	(void) Skein ## mode ## _Update(&ctx, block, \
	303	sizeof (block)); \
	304	} \
	305	(void) Skein ## mode ## _Final(&ctx, digest); \
	306	(void) gettimeofday(&end, NULL); \
	307	delta = (end.tv_sec * 1000000llu + end.tv_usec) - \
	308	(start.tv_sec * 1000000llu + start.tv_usec); \
	309	if (cpu_mhz != 0) { \
	310	cpb = (cpu_mhz * 1e6 * ((double)delta / \
	311	1000000)) / (8192 * 128 * 1024); \
	312	} \
	313	(void) printf("Skein" #mode "/" #diglen "\t%llu us " \
	314	"(%.02f CPB)\n", (u_longlong_t)delta, cpb); \
3c67d83a TH	315	} while (0)
	316
	317	(void) printf("Running algorithm correctness tests:\n");
	318	SKEIN_ALGO_TEST(test_msg0, _256, 256, skein_256_test_digests[0]);
	319	SKEIN_ALGO_TEST(test_msg1, _256, 256, skein_256_test_digests[1]);
	320	SKEIN_ALGO_TEST(test_msg2, _256, 256, skein_256_test_digests[2]);
	321	SKEIN_ALGO_TEST(test_msg0, _512, 512, skein_512_test_digests[0]);
	322	SKEIN_ALGO_TEST(test_msg2, _512, 512, skein_512_test_digests[2]);
	323	SKEIN_ALGO_TEST(test_msg3, _512, 512, skein_512_test_digests[3]);
	324	SKEIN_ALGO_TEST(test_msg0, 1024, 1024, skein_1024_test_digests[0]);
	325	SKEIN_ALGO_TEST(test_msg3, 1024, 1024, skein_1024_test_digests[3]);
	326	SKEIN_ALGO_TEST(test_msg4, 1024, 1024, skein_1024_test_digests[4]);
	327	if (failed)
	328	return (1);
	329
	330	(void) printf("Running performance tests (hashing 1024 MiB of "
	331	"data):\n");
	332	SKEIN_PERF_TEST(_256, 256);
	333	SKEIN_PERF_TEST(_512, 512);
	334	SKEIN_PERF_TEST(1024, 1024);
	335
	336	return (0);
	337	}