test/evp_test.c: improve output in case of errors. (e3d378bc) · Commits · CYBER - Cyber Security / TS 103 523 MSP / ETS / ETS OpenSSL

test/evp_test.c

+145 −146

Original line number	Original line	Diff line number	Diff line
	@@ -206,14 +206,6 @@ static int evp_test_buffer_do(STACK_OF(EVP_TEST_BUFFER) *sk,
	return 1;		return 1;
	}		}

	static int compare_mem(unsigned char *expected, size_t expected_len,
	unsigned char *got, size_t got_len)
	{
	if (!TEST_mem_eq(expected, expected_len, got, got_len))
	return 0;
	return 1;
	}

	/*		/*
	* Unescape some sequences in string literals (only \n for now).		* Unescape some sequences in string literals (only \n for now).
	* Return an allocated buffer, set \|out_len\|. If \|input_len\|		* Return an allocated buffer, set \|out_len\|. If \|input_len\|
	@@ -374,33 +366,33 @@ static int digest_update_fn(void ctx, const unsigned char buf, size_t buflen)

	static int digest_test_run(EVP_TEST *t)		static int digest_test_run(EVP_TEST *t)
	{		{
	DIGEST_DATA *mdata = t->data;		DIGEST_DATA *expected = t->data;
	EVP_MD_CTX *mctx;		EVP_MD_CTX *mctx;
	unsigned char md[EVP_MAX_MD_SIZE];		unsigned char got[EVP_MAX_MD_SIZE];
	unsigned int md_len;		unsigned int got_len;

	t->err = "TEST_FAILURE";		t->err = "TEST_FAILURE";
	if (!TEST_ptr(mctx = EVP_MD_CTX_new()))		if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
	goto err;		goto err;

	if (!EVP_DigestInit_ex(mctx, mdata->digest, NULL)) {		if (!EVP_DigestInit_ex(mctx, expected->digest, NULL)) {
	t->err = "DIGESTINIT_ERROR";		t->err = "DIGESTINIT_ERROR";
	goto err;		goto err;
	}		}
	if (!evp_test_buffer_do(mdata->input, digest_update_fn, mctx)) {		if (!evp_test_buffer_do(expected->input, digest_update_fn, mctx)) {
	t->err = "DIGESTUPDATE_ERROR";		t->err = "DIGESTUPDATE_ERROR";
	goto err;		goto err;
	}		}

	if (!EVP_DigestFinal(mctx, md, &md_len)) {		if (!EVP_DigestFinal(mctx, got, &got_len)) {
	t->err = "DIGESTFINAL_ERROR";		t->err = "DIGESTFINAL_ERROR";
	goto err;		goto err;
	}		}
	if (md_len != mdata->output_len) {		if (!TEST_int_eq(expected->output_len, got_len)) {
	t->err = "DIGEST_LENGTH_MISMATCH";		t->err = "DIGEST_LENGTH_MISMATCH";
	goto err;		goto err;
	}		}
	if (!compare_mem(mdata->output, mdata->output_len, md, md_len)) {		if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
	t->err = "DIGEST_MISMATCH";		t->err = "DIGEST_MISMATCH";
	goto err;		goto err;
	}		}
	@@ -522,8 +514,8 @@ static int cipher_test_parse(EVP_TEST t, const char keyword,
	static int cipher_test_enc(EVP_TEST *t, int enc,		static int cipher_test_enc(EVP_TEST *t, int enc,
	size_t out_misalign, size_t inp_misalign, int frag)		size_t out_misalign, size_t inp_misalign, int frag)
	{		{
	CIPHER_DATA *cdat = t->data;		CIPHER_DATA *expected = t->data;
	unsigned char in, out, *tmp = NULL;		unsigned char in, expected_out, *tmp = NULL;
	size_t in_len, out_len, donelen = 0;		size_t in_len, out_len, donelen = 0;
	int ok = 0, tmplen, chunklen, tmpflen;		int ok = 0, tmplen, chunklen, tmpflen;
	EVP_CIPHER_CTX *ctx = NULL;		EVP_CIPHER_CTX *ctx = NULL;
	@@ -533,15 +525,15 @@ static int cipher_test_enc(EVP_TEST *t, int enc,
	goto err;		goto err;
	EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);		EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
	if (enc) {		if (enc) {
	in = cdat->plaintext;		in = expected->plaintext;
	in_len = cdat->plaintext_len;		in_len = expected->plaintext_len;
	out = cdat->ciphertext;		expected_out = expected->ciphertext;
	out_len = cdat->ciphertext_len;		out_len = expected->ciphertext_len;
	} else {		} else {
	in = cdat->ciphertext;		in = expected->ciphertext;
	in_len = cdat->ciphertext_len;		in_len = expected->ciphertext_len;
	out = cdat->plaintext;		expected_out = expected->plaintext;
	out_len = cdat->plaintext_len;		out_len = expected->plaintext_len;
	}		}
	if (inp_misalign == (size_t)-1) {		if (inp_misalign == (size_t)-1) {
	/*		/*
	@@ -568,89 +560,90 @@ static int cipher_test_enc(EVP_TEST *t, int enc,
	in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +		in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +
	inp_misalign, in, in_len);		inp_misalign, in, in_len);
	}		}
	if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc)) {		if (!EVP_CipherInit_ex(ctx, expected->cipher, NULL, NULL, NULL, enc)) {
	t->err = "CIPHERINIT_ERROR";		t->err = "CIPHERINIT_ERROR";
	goto err;		goto err;
	}		}
	if (cdat->iv) {		if (expected->iv) {
	if (cdat->aead) {		if (expected->aead) {
	if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,		if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
	cdat->iv_len, 0)) {		expected->iv_len, 0)) {
	t->err = "INVALID_IV_LENGTH";		t->err = "INVALID_IV_LENGTH";
	goto err;		goto err;
	}		}
	} else if (cdat->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx)) {		} else if (expected->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx)) {
	t->err = "INVALID_IV_LENGTH";		t->err = "INVALID_IV_LENGTH";
	goto err;		goto err;
	}		}
	}		}
	if (cdat->aead) {		if (expected->aead) {
	unsigned char *tag;		unsigned char *tag;
	/*		/*
	* If encrypting or OCB just set tag length initially, otherwise		* If encrypting or OCB just set tag length initially, otherwise
	* set tag length and value.		* set tag length and value.
	*/		*/
	if (enc \|\| cdat->aead == EVP_CIPH_OCB_MODE) {		if (enc \|\| expected->aead == EVP_CIPH_OCB_MODE) {
	t->err = "TAG_LENGTH_SET_ERROR";		t->err = "TAG_LENGTH_SET_ERROR";
	tag = NULL;		tag = NULL;
	} else {		} else {
	t->err = "TAG_SET_ERROR";		t->err = "TAG_SET_ERROR";
	tag = cdat->tag;		tag = expected->tag;
	}		}
	if (tag \|\| cdat->aead != EVP_CIPH_GCM_MODE) {		if (tag \|\| expected->aead != EVP_CIPH_GCM_MODE) {
	if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,		if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
	cdat->tag_len, tag))		expected->tag_len, tag))
	goto err;		goto err;
	}		}
	}		}

	if (!EVP_CIPHER_CTX_set_key_length(ctx, cdat->key_len)) {		if (!EVP_CIPHER_CTX_set_key_length(ctx, expected->key_len)) {
	t->err = "INVALID_KEY_LENGTH";		t->err = "INVALID_KEY_LENGTH";
	goto err;		goto err;
	}		}
	if (!EVP_CipherInit_ex(ctx, NULL, NULL, cdat->key, cdat->iv, -1)) {		if (!EVP_CipherInit_ex(ctx, NULL, NULL, expected->key, expected->iv, -1)) {
	t->err = "KEY_SET_ERROR";		t->err = "KEY_SET_ERROR";
	goto err;		goto err;
	}		}

	if (!enc && cdat->aead == EVP_CIPH_OCB_MODE) {		if (!enc && expected->aead == EVP_CIPH_OCB_MODE) {
	if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,		if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
	cdat->tag_len, cdat->tag)) {		expected->tag_len, expected->tag)) {
	t->err = "TAG_SET_ERROR";		t->err = "TAG_SET_ERROR";
	goto err;		goto err;
	}		}
	}		}

	if (cdat->aead == EVP_CIPH_CCM_MODE) {		if (expected->aead == EVP_CIPH_CCM_MODE) {
	if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {		if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
	t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";		t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
	goto err;		goto err;
	}		}
	}		}
	if (cdat->aad) {		if (expected->aad) {
	t->err = "AAD_SET_ERROR";		t->err = "AAD_SET_ERROR";
	if (!frag) {		if (!frag) {
	if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad,		if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad,
	cdat->aad_len))		expected->aad_len))
	goto err;		goto err;
	} else {		} else {
	/*		/*
	* Supply the AAD in chunks less than the block size where possible		* Supply the AAD in chunks less than the block size where possible
	*/		*/
	if (cdat->aad_len > 0) {		if (expected->aad_len > 0) {
	if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad, 1))		if (!EVP_CipherUpdate(ctx, NULL, &chunklen, expected->aad, 1))
	goto err;		goto err;
	donelen++;		donelen++;
	}		}
	if (cdat->aad_len > 2) {		if (expected->aad_len > 2) {
	if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad + donelen,		if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
	cdat->aad_len - 2))		expected->aad + donelen,
			expected->aad_len - 2))
	goto err;		goto err;
	donelen += cdat->aad_len - 2;		donelen += expected->aad_len - 2;
	}		}
	if (cdat->aad_len > 1		if (expected->aad_len > 1
	&& !EVP_CipherUpdate(ctx, NULL, &chunklen,		&& !EVP_CipherUpdate(ctx, NULL, &chunklen,
	cdat->aad + donelen, 1))		expected->aad + donelen, 1))
	goto err;		goto err;
	}		}
	}		}
	@@ -689,23 +682,25 @@ static int cipher_test_enc(EVP_TEST *t, int enc,
	t->err = "CIPHERFINAL_ERROR";		t->err = "CIPHERFINAL_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(out, out_len, tmp + out_misalign, tmplen + tmpflen)) {		if (!TEST_mem_eq(expected_out, out_len,
			tmp + out_misalign, tmplen + tmpflen)) {
	t->err = "VALUE_MISMATCH";		t->err = "VALUE_MISMATCH";
	goto err;		goto err;
	}		}
	if (enc && cdat->aead) {		if (enc && expected->aead) {
	unsigned char rtag[16];		unsigned char rtag[16];

	if (cdat->tag_len > sizeof(rtag)) {		if (!TEST_size_t_le(expected->tag_len, sizeof(rtag))) {
	t->err = "TAG_LENGTH_INTERNAL_ERROR";		t->err = "TAG_LENGTH_INTERNAL_ERROR";
	goto err;		goto err;
	}		}
	if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,		if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
	cdat->tag_len, rtag)) {		expected->tag_len, rtag)) {
	t->err = "TAG_RETRIEVE_ERROR";		t->err = "TAG_RETRIEVE_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(cdat->tag, cdat->tag_len, rtag, cdat->tag_len)) {		if (!TEST_mem_eq(expected->tag, expected->tag_len,
			rtag, expected->tag_len)) {
	t->err = "TAG_VALUE_MISMATCH";		t->err = "TAG_VALUE_MISMATCH";
	goto err;		goto err;
	}		}
	@@ -894,23 +889,23 @@ static int mac_test_parse(EVP_TEST *t,

	static int mac_test_run(EVP_TEST *t)		static int mac_test_run(EVP_TEST *t)
	{		{
	MAC_DATA *mdata = t->data;		MAC_DATA *expected = t->data;
	EVP_MD_CTX *mctx = NULL;		EVP_MD_CTX *mctx = NULL;
	EVP_PKEY_CTX pctx = NULL, genctx = NULL;		EVP_PKEY_CTX pctx = NULL, genctx = NULL;
	EVP_PKEY *key = NULL;		EVP_PKEY *key = NULL;
	const EVP_MD *md = NULL;		const EVP_MD *md = NULL;
	unsigned char *mac = NULL;		unsigned char *got = NULL;
	size_t mac_len;		size_t got_len;

	#ifdef OPENSSL_NO_DES		#ifdef OPENSSL_NO_DES
	if (mdata->alg != NULL && strstr(mdata->alg, "DES") != NULL) {		if (expected->alg != NULL && strstr(expected->alg, "DES") != NULL) {
	/* Skip DES */		/* Skip DES */
	t->err = NULL;		t->err = NULL;
	goto err;		goto err;
	}		}
	#endif		#endif

	if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_id(mdata->type, NULL))) {		if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_id(expected->type, NULL))) {
	t->err = "MAC_PKEY_CTX_ERROR";		t->err = "MAC_PKEY_CTX_ERROR";
	goto err;		goto err;
	}		}
	@@ -919,13 +914,14 @@ static int mac_test_run(EVP_TEST *t)
	t->err = "MAC_KEYGEN_INIT_ERROR";		t->err = "MAC_KEYGEN_INIT_ERROR";
	goto err;		goto err;
	}		}
	if (mdata->type == EVP_PKEY_CMAC		if (expected->type == EVP_PKEY_CMAC
	&& EVP_PKEY_CTX_ctrl_str(genctx, "cipher", mdata->alg) <= 0) {		&& EVP_PKEY_CTX_ctrl_str(genctx, "cipher", expected->alg) <= 0) {
	t->err = "MAC_ALGORITHM_SET_ERROR";		t->err = "MAC_ALGORITHM_SET_ERROR";
	goto err;		goto err;
	}		}

	if (EVP_PKEY_CTX_set_mac_key(genctx, mdata->key, mdata->key_len) <= 0) {		if (EVP_PKEY_CTX_set_mac_key(genctx, expected->key,
			expected->key_len) <= 0) {
	t->err = "MAC_KEY_SET_ERROR";		t->err = "MAC_KEY_SET_ERROR";
	goto err;		goto err;
	}		}
	@@ -934,8 +930,8 @@ static int mac_test_run(EVP_TEST *t)
	t->err = "MAC_KEY_GENERATE_ERROR";		t->err = "MAC_KEY_GENERATE_ERROR";
	goto err;		goto err;
	}		}
	if (mdata->type == EVP_PKEY_HMAC) {		if (expected->type == EVP_PKEY_HMAC) {
	if (!TEST_ptr(md = EVP_get_digestbyname(mdata->alg))) {		if (!TEST_ptr(md = EVP_get_digestbyname(expected->alg))) {
	t->err = "MAC_ALGORITHM_SET_ERROR";		t->err = "MAC_ALGORITHM_SET_ERROR";
	goto err;		goto err;
	}		}
	@@ -949,27 +945,28 @@ static int mac_test_run(EVP_TEST *t)
	goto err;		goto err;
	}		}

	if (!EVP_DigestSignUpdate(mctx, mdata->input, mdata->input_len)) {		if (!EVP_DigestSignUpdate(mctx, expected->input, expected->input_len)) {
	t->err = "DIGESTSIGNUPDATE_ERROR";		t->err = "DIGESTSIGNUPDATE_ERROR";
	goto err;		goto err;
	}		}
	if (!EVP_DigestSignFinal(mctx, NULL, &mac_len)) {		if (!EVP_DigestSignFinal(mctx, NULL, &got_len)) {
	t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";		t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
	goto err;		goto err;
	}		}
	if (!TEST_ptr(mac = OPENSSL_malloc(mac_len))) {		if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
	t->err = "TEST_FAILURE";		t->err = "TEST_FAILURE";
	goto err;		goto err;
	}		}
	if (!EVP_DigestSignFinal(mctx, mac, &mac_len)		if (!EVP_DigestSignFinal(mctx, got, &got_len)
	\|\| !compare_mem(mdata->output, mdata->output_len, mac, mac_len)) {		\|\| !TEST_mem_eq(expected->output, expected->output_len,
			got, got_len)) {
	t->err = "TEST_MAC_ERR";		t->err = "TEST_MAC_ERR";
	goto err;		goto err;
	}		}
	t->err = NULL;		t->err = NULL;
	err:		err:
	EVP_MD_CTX_free(mctx);		EVP_MD_CTX_free(mctx);
	OPENSSL_free(mac);		OPENSSL_free(got);
	EVP_PKEY_CTX_free(genctx);		EVP_PKEY_CTX_free(genctx);
	EVP_PKEY_free(key);		EVP_PKEY_free(key);
	return 1;		return 1;
	@@ -1101,28 +1098,28 @@ static int pkey_test_parse(EVP_TEST *t,

	static int pkey_test_run(EVP_TEST *t)		static int pkey_test_run(EVP_TEST *t)
	{		{
	PKEY_DATA *kdata = t->data;		PKEY_DATA *expected = t->data;
	unsigned char *out = NULL;		unsigned char *got = NULL;
	size_t out_len;		size_t got_len;

	if (kdata->keyop(kdata->ctx, NULL, &out_len, kdata->input,		if (expected->keyop(expected->ctx, NULL, &got_len,
	kdata->input_len) <= 0		expected->input, expected->input_len) <= 0
	\|\| !TEST_ptr(out = OPENSSL_malloc(out_len))) {		\|\| !TEST_ptr(got = OPENSSL_malloc(got_len))) {
	t->err = "KEYOP_LENGTH_ERROR";		t->err = "KEYOP_LENGTH_ERROR";
	goto err;		goto err;
	}		}
	if (kdata->keyop(kdata->ctx, out,		if (expected->keyop(expected->ctx, got, &got_len,
	&out_len, kdata->input, kdata->input_len) <= 0) {		expected->input, expected->input_len) <= 0) {
	t->err = "KEYOP_ERROR";		t->err = "KEYOP_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(kdata->output, kdata->output_len, out, out_len)) {		if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
	t->err = "KEYOP_MISMATCH";		t->err = "KEYOP_MISMATCH";
	goto err;		goto err;
	}		}
	t->err = NULL;		t->err = NULL;
	err:		err:
	OPENSSL_free(out);		OPENSSL_free(got);
	return 1;		return 1;
	}		}

	@@ -1218,27 +1215,27 @@ static int pderive_test_parse(EVP_TEST *t,

	static int pderive_test_run(EVP_TEST *t)		static int pderive_test_run(EVP_TEST *t)
	{		{
	PKEY_DATA *kdata = t->data;		PKEY_DATA *expected = t->data;
	unsigned char *out = NULL;		unsigned char *got = NULL;
	size_t out_len;		size_t got_len;

	out_len = kdata->output_len;		got_len = expected->output_len;
	if (!TEST_ptr(out = OPENSSL_malloc(out_len))) {		if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
	t->err = "DERIVE_ERROR";		t->err = "DERIVE_ERROR";
	goto err;		goto err;
	}		}
	if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) {		if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
	t->err = "DERIVE_ERROR";		t->err = "DERIVE_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(kdata->output, kdata->output_len, out, out_len)) {		if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
	t->err = "SHARED_SECRET_MISMATCH";		t->err = "SHARED_SECRET_MISMATCH";
	goto err;		goto err;
	}		}

	t->err = NULL;		t->err = NULL;
	err:		err:
	OPENSSL_free(out);		OPENSSL_free(got);
	return 1;		return 1;
	}		}

	@@ -1415,41 +1412,42 @@ static int pbe_test_parse(EVP_TEST *t,

	static int pbe_test_run(EVP_TEST *t)		static int pbe_test_run(EVP_TEST *t)
	{		{
	PBE_DATA *pdata = t->data;		PBE_DATA *expected = t->data;
	unsigned char *key;		unsigned char *key;

	if (!TEST_ptr(key = OPENSSL_malloc(pdata->key_len))) {		if (!TEST_ptr(key = OPENSSL_malloc(expected->key_len))) {
	t->err = "INTERNAL_ERROR";		t->err = "INTERNAL_ERROR";
	goto err;		goto err;
	}		}
	if (pdata->pbe_type == PBE_TYPE_PBKDF2) {		if (expected->pbe_type == PBE_TYPE_PBKDF2) {
	if (PKCS5_PBKDF2_HMAC((char *)pdata->pass, pdata->pass_len,		if (PKCS5_PBKDF2_HMAC((char *)expected->pass, expected->pass_len,
	pdata->salt, pdata->salt_len,		expected->salt, expected->salt_len,
	pdata->iter, pdata->md,		expected->iter, expected->md,
	pdata->key_len, key) == 0) {		expected->key_len, key) == 0) {
	t->err = "PBKDF2_ERROR";		t->err = "PBKDF2_ERROR";
	goto err;		goto err;
	}		}
	#ifndef OPENSSL_NO_SCRYPT		#ifndef OPENSSL_NO_SCRYPT
	} else if (pdata->pbe_type == PBE_TYPE_SCRYPT) {		} else if (expected->pbe_type == PBE_TYPE_SCRYPT) {
	if (EVP_PBE_scrypt((const char *)pdata->pass, pdata->pass_len,		if (EVP_PBE_scrypt((const char *)expected->pass, expected->pass_len,
	pdata->salt, pdata->salt_len,		expected->salt, expected->salt_len, expected->N,
	pdata->N, pdata->r, pdata->p, pdata->maxmem,		expected->r, expected->p, expected->maxmem,
	key, pdata->key_len) == 0) {		key, expected->key_len) == 0) {
	t->err = "SCRYPT_ERROR";		t->err = "SCRYPT_ERROR";
	goto err;		goto err;
	}		}
	#endif		#endif
	} else if (pdata->pbe_type == PBE_TYPE_PKCS12) {		} else if (expected->pbe_type == PBE_TYPE_PKCS12) {
	if (PKCS12_key_gen_uni(pdata->pass, pdata->pass_len,		if (PKCS12_key_gen_uni(expected->pass, expected->pass_len,
	pdata->salt, pdata->salt_len,		expected->salt, expected->salt_len,
	pdata->id, pdata->iter, pdata->key_len,		expected->id, expected->iter, expected->key_len,
	key, pdata->md) == 0) {		key, expected->md) == 0) {
	t->err = "PKCS12_ERROR";		t->err = "PKCS12_ERROR";
	goto err;		goto err;
	}		}
	}		}
	if (!compare_mem(pdata->key, pdata->key_len, key, pdata->key_len)) {		if (!TEST_mem_eq(expected->key, expected->key_len,
			key, expected->key_len)) {
	t->err = "KEY_MISMATCH";		t->err = "KEY_MISMATCH";
	goto err;		goto err;
	}		}
	@@ -1535,7 +1533,7 @@ static int encode_test_parse(EVP_TEST *t,

	static int encode_test_run(EVP_TEST *t)		static int encode_test_run(EVP_TEST *t)
	{		{
	ENCODE_DATA *edata = t->data;		ENCODE_DATA *expected = t->data;
	unsigned char encode_out = NULL, decode_out = NULL;		unsigned char encode_out = NULL, decode_out = NULL;
	int output_len, chunk_len;		int output_len, chunk_len;
	EVP_ENCODE_CTX *decode_ctx;		EVP_ENCODE_CTX *decode_ctx;
	@@ -1545,17 +1543,17 @@ static int encode_test_run(EVP_TEST *t)
	goto err;		goto err;
	}		}

	if (edata->encoding == BASE64_CANONICAL_ENCODING) {		if (expected->encoding == BASE64_CANONICAL_ENCODING) {
	EVP_ENCODE_CTX *encode_ctx;		EVP_ENCODE_CTX *encode_ctx;

	if (!TEST_ptr(encode_ctx = EVP_ENCODE_CTX_new())		if (!TEST_ptr(encode_ctx = EVP_ENCODE_CTX_new())
	\|\| !TEST_ptr(encode_out =		\|\| !TEST_ptr(encode_out =
	OPENSSL_malloc(EVP_ENCODE_LENGTH(edata->input_len))))		OPENSSL_malloc(EVP_ENCODE_LENGTH(expected->input_len))))
	goto err;		goto err;

	EVP_EncodeInit(encode_ctx);		EVP_EncodeInit(encode_ctx);
	EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,		EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,
	edata->input, edata->input_len);		expected->input, expected->input_len);
	output_len = chunk_len;		output_len = chunk_len;

	EVP_EncodeFinal(encode_ctx, encode_out + chunk_len, &chunk_len);		EVP_EncodeFinal(encode_ctx, encode_out + chunk_len, &chunk_len);
	@@ -1563,7 +1561,7 @@ static int encode_test_run(EVP_TEST *t)

	EVP_ENCODE_CTX_free(encode_ctx);		EVP_ENCODE_CTX_free(encode_ctx);

	if (!compare_mem(edata->output, edata->output_len,		if (!TEST_mem_eq(expected->output, expected->output_len,
	encode_out, output_len)) {		encode_out, output_len)) {
	t->err = "BAD_ENCODING";		t->err = "BAD_ENCODING";
	goto err;		goto err;
	@@ -1571,12 +1569,12 @@ static int encode_test_run(EVP_TEST *t)
	}		}

	if (!TEST_ptr(decode_out =		if (!TEST_ptr(decode_out =
	OPENSSL_malloc(EVP_DECODE_LENGTH(edata->output_len))))		OPENSSL_malloc(EVP_DECODE_LENGTH(expected->output_len))))
	goto err;		goto err;

	EVP_DecodeInit(decode_ctx);		EVP_DecodeInit(decode_ctx);
	if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, edata->output,		if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, expected->output,
	edata->output_len) < 0) {		expected->output_len) < 0) {
	t->err = "DECODE_ERROR";		t->err = "DECODE_ERROR";
	goto err;		goto err;
	}		}
	@@ -1588,8 +1586,8 @@ static int encode_test_run(EVP_TEST *t)
	}		}
	output_len += chunk_len;		output_len += chunk_len;

	if (edata->encoding != BASE64_INVALID_ENCODING		if (expected->encoding != BASE64_INVALID_ENCODING
	&& !compare_mem(edata->input, edata->input_len,		&& !TEST_mem_eq(expected->input, expected->input_len,
	decode_out, output_len)) {		decode_out, output_len)) {
	t->err = "BAD_DECODING";		t->err = "BAD_DECODING";
	goto err;		goto err;
	@@ -1663,26 +1661,26 @@ static int kdf_test_parse(EVP_TEST *t,

	static int kdf_test_run(EVP_TEST *t)		static int kdf_test_run(EVP_TEST *t)
	{		{
	KDF_DATA *kdata = t->data;		KDF_DATA *expected = t->data;
	unsigned char *out = NULL;		unsigned char *got = NULL;
	size_t out_len = kdata->output_len;		size_t got_len = expected->output_len;

	if (!TEST_ptr(out = OPENSSL_malloc(out_len))) {		if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
	t->err = "INTERNAL_ERROR";		t->err = "INTERNAL_ERROR";
	goto err;		goto err;
	}		}
	if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) {		if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
	t->err = "KDF_DERIVE_ERROR";		t->err = "KDF_DERIVE_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(kdata->output, kdata->output_len, out, out_len)) {		if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
	t->err = "KDF_MISMATCH";		t->err = "KDF_MISMATCH";
	goto err;		goto err;
	}		}
	t->err = NULL;		t->err = NULL;

	err:		err:
	OPENSSL_free(out);		OPENSSL_free(got);
	return 1;		return 1;
	}		}

	@@ -1934,34 +1932,35 @@ static int digestsign_update_fn(void ctx, const unsigned char buf,

	static int digestsign_test_run(EVP_TEST *t)		static int digestsign_test_run(EVP_TEST *t)
	{		{
	DIGESTSIGN_DATA *mdata = t->data;		DIGESTSIGN_DATA *expected = t->data;
	unsigned char *buf = NULL;		unsigned char *got = NULL;
	size_t buflen;		size_t got_len;

	if (!evp_test_buffer_do(mdata->input, digestsign_update_fn, mdata->ctx)) {		if (!evp_test_buffer_do(expected->input, digestsign_update_fn,
			expected->ctx)) {
	t->err = "DIGESTUPDATE_ERROR";		t->err = "DIGESTUPDATE_ERROR";
	goto err;		goto err;
	}		}

	if (!EVP_DigestSignFinal(mdata->ctx, NULL, &buflen)) {		if (!EVP_DigestSignFinal(expected->ctx, NULL, &got_len)) {
	t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";		t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
	goto err;		goto err;
	}		}
	if (!TEST_ptr(buf = OPENSSL_malloc(buflen))) {		if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
	t->err = "MALLOC_FAILURE";		t->err = "MALLOC_FAILURE";
	goto err;		goto err;
	}		}
	if (!EVP_DigestSignFinal(mdata->ctx, buf, &buflen)) {		if (!EVP_DigestSignFinal(expected->ctx, got, &got_len)) {
	t->err = "DIGESTSIGNFINAL_ERROR";		t->err = "DIGESTSIGNFINAL_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(mdata->output, mdata->output_len, buf, buflen)) {		if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
	t->err = "SIGNATURE_MISMATCH";		t->err = "SIGNATURE_MISMATCH";
	goto err;		goto err;
	}		}

	err:		err:
	OPENSSL_free(buf);		OPENSSL_free(got);
	return 1;		return 1;
	}		}

	@@ -2014,31 +2013,31 @@ static int oneshot_digestsign_test_init(EVP_TEST t, const char alg)

	static int oneshot_digestsign_test_run(EVP_TEST *t)		static int oneshot_digestsign_test_run(EVP_TEST *t)
	{		{
	DIGESTSIGN_DATA *mdata = t->data;		DIGESTSIGN_DATA *expected = t->data;
	unsigned char *buf = NULL;		unsigned char *got = NULL;
	size_t buflen;		size_t got_len;

	if (!EVP_DigestSign(mdata->ctx, NULL, &buflen, mdata->osin,		if (!EVP_DigestSign(expected->ctx, NULL, &got_len,
	mdata->osin_len)) {		expected->osin, expected->osin_len)) {
	t->err = "DIGESTSIGN_LENGTH_ERROR";		t->err = "DIGESTSIGN_LENGTH_ERROR";
	goto err;		goto err;
	}		}
	if (!TEST_ptr(buf = OPENSSL_malloc(buflen))) {		if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
	t->err = "MALLOC_FAILURE";		t->err = "MALLOC_FAILURE";
	goto err;		goto err;
	}		}
	if (!EVP_DigestSign(mdata->ctx, buf, &buflen, mdata->osin,		if (!EVP_DigestSign(expected->ctx, got, &got_len,
	mdata->osin_len)) {		expected->osin, expected->osin_len)) {
	t->err = "DIGESTSIGN_ERROR";		t->err = "DIGESTSIGN_ERROR";
	goto err;		goto err;
	}		}
	if (!compare_mem(mdata->output, mdata->output_len, buf, buflen)) {		if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
	t->err = "SIGNATURE_MISMATCH";		t->err = "SIGNATURE_MISMATCH";
	goto err;		goto err;
	}		}

	err:		err:
	OPENSSL_free(buf);		OPENSSL_free(got);
	return 1;		return 1;
	}		}

Admin message