Differential D28758 Diff 85087 tools/tools/crypto/cryptocheck.c

Changeset View

Standalone View

tools/tools/crypto/cryptocheck.c

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
* sha1hmac SHA-1 HMAC		* sha1hmac SHA-1 HMAC
* sha224hmac 224-bit SHA-2 HMAC		* sha224hmac 224-bit SHA-2 HMAC
* sha256hmac 256-bit SHA-2 HMAC		* sha256hmac 256-bit SHA-2 HMAC
* sha384hmac 384-bit SHA-2 HMAC		* sha384hmac 384-bit SHA-2 HMAC
* sha512hmac 512-bit SHA-2 HMAC		* sha512hmac 512-bit SHA-2 HMAC
* gmac 128-bit GMAC		* gmac 128-bit GMAC
* gmac192 192-bit GMAC		* gmac192 192-bit GMAC
* gmac256 256-bit GMAC		* gmac256 256-bit GMAC
		* poly1305
*		*
* Ciphers:		* Ciphers:
* aes-cbc 128-bit AES-CBC		* aes-cbc 128-bit AES-CBC
* aes-cbc192 192-bit AES-CBC		* aes-cbc192 192-bit AES-CBC
* aes-cbc256 256-bit AES-CBC		* aes-cbc256 256-bit AES-CBC
* aes-ctr 128-bit AES-CTR		* aes-ctr 128-bit AES-CTR
* aes-ctr192 192-bit AES-CTR		* aes-ctr192 192-bit AES-CTR
* aes-ctr256 256-bit AES-CTR		* aes-ctr256 256-bit AES-CTR
Show All 35 Lines	struct ocf_session {
int ses;		int ses;
int crid;		int crid;
};		};

static const struct alg {		static const struct alg {
const char *name;		const char *name;
int cipher;		int cipher;
int mac;		int mac;
enum { T_HASH, T_HMAC, T_GMAC, T_CIPHER, T_ETA, T_AEAD } type;		enum { T_HASH, T_HMAC, T_GMAC, T_DIGEST, T_CIPHER, T_ETA, T_AEAD } type;
		int key_len;
int tag_len;		int tag_len;
const EVP_CIPHER (evp_cipher)(void);		const EVP_CIPHER (evp_cipher)(void);
const EVP_MD (evp_md)(void);		const EVP_MD (evp_md)(void);
		int pkey;
} algs[] = {		} algs[] = {
{ .name = "sha1", .mac = CRYPTO_SHA1, .type = T_HASH,		{ .name = "sha1", .mac = CRYPTO_SHA1, .type = T_HASH,
.evp_md = EVP_sha1 },		.evp_md = EVP_sha1 },
{ .name = "sha224", .mac = CRYPTO_SHA2_224, .type = T_HASH,		{ .name = "sha224", .mac = CRYPTO_SHA2_224, .type = T_HASH,
.evp_md = EVP_sha224 },		.evp_md = EVP_sha224 },
{ .name = "sha256", .mac = CRYPTO_SHA2_256, .type = T_HASH,		{ .name = "sha256", .mac = CRYPTO_SHA2_256, .type = T_HASH,
.evp_md = EVP_sha256 },		.evp_md = EVP_sha256 },
{ .name = "sha384", .mac = CRYPTO_SHA2_384, .type = T_HASH,		{ .name = "sha384", .mac = CRYPTO_SHA2_384, .type = T_HASH,
Show All 15 Lines	static const struct alg {
{ .name = "blake2s", .mac = CRYPTO_BLAKE2S, .type = T_HASH,		{ .name = "blake2s", .mac = CRYPTO_BLAKE2S, .type = T_HASH,
.evp_md = EVP_blake2s256 },		.evp_md = EVP_blake2s256 },
{ .name = "gmac", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC,		{ .name = "gmac", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC,
.tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_128_gcm },		.tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_128_gcm },
{ .name = "gmac192", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC,		{ .name = "gmac192", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC,
.tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_192_gcm },		.tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_192_gcm },
{ .name = "gmac256", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC,		{ .name = "gmac256", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC,
.tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_256_gcm },		.tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_256_gcm },
		{ .name = "poly1305", .mac = CRYPTO_POLY1305, .type = T_DIGEST,
		.key_len = POLY1305_KEY_LEN, .pkey = EVP_PKEY_POLY1305 },
{ .name = "aes-cbc", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER,		{ .name = "aes-cbc", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER,
.evp_cipher = EVP_aes_128_cbc },		.evp_cipher = EVP_aes_128_cbc },
{ .name = "aes-cbc192", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER,		{ .name = "aes-cbc192", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER,
.evp_cipher = EVP_aes_192_cbc },		.evp_cipher = EVP_aes_192_cbc },
{ .name = "aes-cbc256", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER,		{ .name = "aes-cbc256", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER,
.evp_cipher = EVP_aes_256_cbc },		.evp_cipher = EVP_aes_256_cbc },
{ .name = "aes-ctr", .cipher = CRYPTO_AES_ICM, .type = T_CIPHER,		{ .name = "aes-ctr", .cipher = CRYPTO_AES_ICM, .type = T_CIPHER,
.evp_cipher = EVP_aes_128_ctr },		.evp_cipher = EVP_aes_128_ctr },
▲ Show 20 Lines • Show All 861 Lines • ▼ Show 20 Lines	openssl_gmac(const struct alg alg, const EVP_CIPHER cipher, const char *key,
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, alg->tag_len,		if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, alg->tag_len,
tag) != 1)		tag) != 1)
errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name,		errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name,
size, ERR_error_string(ERR_get_error(), NULL));		size, ERR_error_string(ERR_get_error(), NULL));
EVP_CIPHER_CTX_free(ctx);		EVP_CIPHER_CTX_free(ctx);
}		}

static bool		static bool
ocf_gmac(const struct alg alg, const char input, size_t size, const char *key,		ocf_mac(const struct alg alg, const char input, size_t size, const char *key,
size_t key_len, const char iv, char tag, int *cridp)		size_t key_len, const char iv, char tag, int *cridp)
{		{
struct ocf_session ses;		struct ocf_session ses;
struct session2_op sop;		struct session2_op sop;
struct crypt_op cop;		struct crypt_op cop;

ocf_init_sop(&sop);		ocf_init_sop(&sop);
sop.mackeylen = key_len;		sop.mackeylen = key_len;
sop.mackey = key;		sop.mackey = key;
sop.mac = alg->mac;		sop.mac = alg->mac;
if (!ocf_init_session(&sop, "GMAC", alg->name, &ses))		if (!ocf_init_session(&sop, "MAC", alg->name, &ses))
return (false);		return (false);

ocf_init_cop(&ses, &cop);		ocf_init_cop(&ses, &cop);
cop.op = 0;		cop.op = 0;
cop.len = size;		cop.len = size;
cop.src = input;		cop.src = input;
cop.mac = tag;		cop.mac = tag;
cop.iv = iv;		cop.iv = iv;
Show All 30 Lines	run_gmac_test(const struct alg *alg, size_t size)
key = alloc_buffer(key_len);		key = alloc_buffer(key_len);
iv = generate_iv(iv_len, alg);		iv = generate_iv(iv_len, alg);
buffer = alloc_buffer(size);		buffer = alloc_buffer(size);

/* OpenSSL GMAC. */		/* OpenSSL GMAC. */
openssl_gmac(alg, cipher, key, iv, buffer, size, control_tag);		openssl_gmac(alg, cipher, key, iv, buffer, size, control_tag);

/* OCF GMAC. */		/* OCF GMAC. */
if (!ocf_gmac(alg, buffer, size, key, key_len, iv, test_tag, &crid))		if (!ocf_mac(alg, buffer, size, key, key_len, iv, test_tag, &crid))
goto out;		goto out;
if (memcmp(control_tag, test_tag, sizeof(control_tag)) != 0) {		if (memcmp(control_tag, test_tag, sizeof(control_tag)) != 0) {
printf("%s (%zu) mismatch:\n", alg->name, size);		printf("%s (%zu) mismatch:\n", alg->name, size);
printf("control:\n");		printf("control:\n");
hexdump(control_tag, sizeof(control_tag), NULL, 0);		hexdump(control_tag, sizeof(control_tag), NULL, 0);
printf("test (cryptodev device %s):\n", crfind(crid));		printf("test (cryptodev device %s):\n", crfind(crid));
hexdump(test_tag, sizeof(test_tag), NULL, 0);		hexdump(test_tag, sizeof(test_tag), NULL, 0);
goto out;		goto out;
}		}

if (verbose)		if (verbose)
printf("%s (%zu) matched (cryptodev device %s)\n",		printf("%s (%zu) matched (cryptodev device %s)\n",
alg->name, size, crfind(crid));		alg->name, size, crfind(crid));

out:		out:
free(buffer);		free(buffer);
free(key);		free(key);
}		}

static void		static void
		openssl_digest(const struct alg alg, const char key, u_int key_len,
		const char input, size_t size, char tag, u_int tag_len)
		{
		EVP_MD_CTX *mdctx;
		EVP_PKEY *pkey;
		size_t len;

		pkey = EVP_PKEY_new_raw_private_key(alg->pkey, NULL, key, key_len);
		if (pkey == NULL)
		errx(1, "OpenSSL %s (%zu) pkey new failed: %s", alg->name,
		size, ERR_error_string(ERR_get_error(), NULL));
		mdctx = EVP_MD_CTX_new();
		if (mdctx == NULL)
		errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name,
		size, ERR_error_string(ERR_get_error(), NULL));
		if (EVP_DigestSignInit(mdctx, NULL, NULL, NULL, pkey) != 1)
		errx(1, "OpenSSL %s (%zu) digest sign init failed: %s",
		alg->name, size, ERR_error_string(ERR_get_error(), NULL));
		if (EVP_DigestSignUpdate(mdctx, input, size) != 1)
		errx(1, "OpenSSL %s (%zu) digest update failed: %s", alg->name,
		size, ERR_error_string(ERR_get_error(), NULL));
		len = tag_len;
		if (EVP_DigestSignFinal(mdctx, tag, &len) != 1)
		errx(1, "OpenSSL %s (%zu) digest final failed: %s", alg->name,
		size, ERR_error_string(ERR_get_error(), NULL));
		EVP_MD_CTX_free(mdctx);
		EVP_PKEY_free(pkey);
		}

		static void
		run_digest_test(const struct alg *alg, size_t size)
		{
		char key, buffer;
		u_int key_len;
		int crid;
		char control_tag[EVP_MAX_MD_SIZE], test_tag[EVP_MAX_MD_SIZE];

		memset(control_tag, 0x3c, sizeof(control_tag));
		memset(test_tag, 0x3c, sizeof(test_tag));

		key_len = alg->key_len;

		key = alloc_buffer(key_len);
		buffer = alloc_buffer(size);

		/* OpenSSL Poly1305. */
		openssl_digest(alg, key, key_len, buffer, size, control_tag,
		sizeof(control_tag));

		/* OCF Poly1305. */
		if (!ocf_mac(alg, buffer, size, key, key_len, NULL, test_tag, &crid))
		goto out;
		if (memcmp(control_tag, test_tag, sizeof(control_tag)) != 0) {
		printf("%s (%zu) mismatch:\n", alg->name, size);
		printf("control:\n");
		hexdump(control_tag, sizeof(control_tag), NULL, 0);
		printf("test (cryptodev device %s):\n", crfind(crid));
		hexdump(test_tag, sizeof(test_tag), NULL, 0);
		goto out;
		}

		if (verbose)
		printf("%s (%zu) matched (cryptodev device %s)\n",
		alg->name, size, crfind(crid));

		out:
		free(buffer);
		free(key);
		}

		static void
openssl_aead_encrypt(const struct alg alg, const EVP_CIPHER cipher,		openssl_aead_encrypt(const struct alg alg, const EVP_CIPHER cipher,
const char key, const char iv, const char *aad, size_t aad_len,		const char key, const char iv, const char *aad, size_t aad_len,
const char input, char output, size_t size, char *tag)		const char input, char output, size_t size, char *tag)
{		{
EVP_CIPHER_CTX *ctx;		EVP_CIPHER_CTX *ctx;
int outl, total;		int outl, total;

ctx = EVP_CIPHER_CTX_new();		ctx = EVP_CIPHER_CTX_new();
▲ Show 20 Lines • Show All 315 Lines • ▼ Show 20 Lines	case T_HASH:
run_hash_test(alg, size);		run_hash_test(alg, size);
break;		break;
case T_HMAC:		case T_HMAC:
run_hmac_test(alg, size);		run_hmac_test(alg, size);
break;		break;
case T_GMAC:		case T_GMAC:
run_gmac_test(alg, size);		run_gmac_test(alg, size);
break;		break;
		case T_DIGEST:
		run_digest_test(alg, size);
		break;
case T_CIPHER:		case T_CIPHER:
run_cipher_test(alg, size);		run_cipher_test(alg, size);
break;		break;
case T_ETA:		case T_ETA:
run_eta_test(alg, aad_len, size);		run_eta_test(alg, aad_len, size);
break;		break;
case T_AEAD:		case T_AEAD:
run_aead_test(alg, aad_len, size);		run_aead_test(alg, aad_len, size);
Show All 31 Lines
}		}

static void		static void
run_mac_tests(void)		run_mac_tests(void)
{		{
u_int i;		u_int i;

for (i = 0; i < nitems(algs); i++)		for (i = 0; i < nitems(algs); i++)
if (algs[i].type == T_HMAC \|\| algs[i].type == T_GMAC)		if (algs[i].type == T_HMAC \|\| algs[i].type == T_GMAC \|\|
		algs[i].type == T_DIGEST)
run_test_sizes(&algs[i]);		run_test_sizes(&algs[i]);
}		}

static void		static void
run_cipher_tests(void)		run_cipher_tests(void)
{		{
u_int i;		u_int i;

▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines