EVP support for wrapping algorithms.

Add support for key wrap algorithms via EVP interface.

Generalise AES wrap algorithm and add to modes, making existing
AES wrap algorithm a special case.

Move test code to evptests.txt
(cherry picked from commit 97cf1f6c2854a3a955fd7dd3a1f113deba00c9ef)

Conflicts:

	CHANGES

8 files changed, 261 insertions, 3 deletions

diff --git a/crypto/evp/c_allc.c b/crypto/evp/c_allc.c
index 6a39d7a5d0..e8718f4357 100644
--- a/crypto/evp/c_allc.c
+++ b/crypto/evp/c_allc.c
@@ -93,6 +93,7 @@ void OpenSSL_add_all_ciphers(void)
 	EVP_add_cipher(EVP_des_ecb());
 	EVP_add_cipher(EVP_des_ede());
 	EVP_add_cipher(EVP_des_ede3());
+	EVP_add_cipher(EVP_des_ede3_wrap());
 #endif
 
 #ifndef OPENSSL_NO_RC4
@@ -173,6 +174,7 @@ void OpenSSL_add_all_ciphers(void)
 	EVP_add_cipher(EVP_aes_128_gcm());
 	EVP_add_cipher(EVP_aes_128_xts());
 	EVP_add_cipher(EVP_aes_128_ccm());
+	EVP_add_cipher(EVP_aes_128_wrap());
 	EVP_add_cipher_alias(SN_aes_128_cbc,"AES128");
 	EVP_add_cipher_alias(SN_aes_128_cbc,"aes128");
 	EVP_add_cipher(EVP_aes_192_ecb());
@@ -184,6 +186,7 @@ void OpenSSL_add_all_ciphers(void)
 	EVP_add_cipher(EVP_aes_192_ctr());
 	EVP_add_cipher(EVP_aes_192_gcm());
 	EVP_add_cipher(EVP_aes_192_ccm());
+	EVP_add_cipher(EVP_aes_192_wrap());
 	EVP_add_cipher_alias(SN_aes_192_cbc,"AES192");
 	EVP_add_cipher_alias(SN_aes_192_cbc,"aes192");
 	EVP_add_cipher(EVP_aes_256_ecb());
@@ -196,6 +199,7 @@ void OpenSSL_add_all_ciphers(void)
 	EVP_add_cipher(EVP_aes_256_gcm());
 	EVP_add_cipher(EVP_aes_256_xts());
 	EVP_add_cipher(EVP_aes_256_ccm());
+	EVP_add_cipher(EVP_aes_256_wrap());
 	EVP_add_cipher_alias(SN_aes_256_cbc,"AES256");
 	EVP_add_cipher_alias(SN_aes_256_cbc,"aes256");
 #if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA1)
diff --git a/crypto/evp/e_aes.c b/crypto/evp/e_aes.c
index 24a4176f2d..66507f8935 100644
--- a/crypto/evp/e_aes.c
+++ b/crypto/evp/e_aes.c
@@ -1879,4 +1879,102 @@ BLOCK_CIPHER_custom(NID_aes,128,1,12,ccm,CCM,EVP_CIPH_FLAG_FIPS|CUSTOM_FLAGS)
 BLOCK_CIPHER_custom(NID_aes,192,1,12,ccm,CCM,EVP_CIPH_FLAG_FIPS|CUSTOM_FLAGS)
 BLOCK_CIPHER_custom(NID_aes,256,1,12,ccm,CCM,EVP_CIPH_FLAG_FIPS|CUSTOM_FLAGS)
 
+typedef struct
+	{
+	union { double align; AES_KEY ks; } ks;
+	/* Indicates if IV has been set */
+	unsigned char *iv;
+	} EVP_AES_WRAP_CTX;
+
+static int aes_wrap_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+                        const unsigned char *iv, int enc)
+	{
+	EVP_AES_WRAP_CTX *wctx = ctx->cipher_data;
+	if (!iv && !key)
+		return 1;
+	if (key)
+		{
+		if (ctx->encrypt)
+			AES_set_encrypt_key(key, ctx->key_len * 8, &wctx->ks.ks);
+		else
+			AES_set_decrypt_key(key, ctx->key_len * 8, &wctx->ks.ks);
+		if (!iv)
+			wctx->iv = NULL;
+		}
+	if (iv)
+		{
+		memcpy(ctx->iv, iv, 8);
+		wctx->iv = ctx->iv;
+		}
+	return 1;
+	}
+
+static int aes_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+		const unsigned char *in, size_t inlen)
+	{
+	EVP_AES_WRAP_CTX *wctx = ctx->cipher_data;
+	size_t rv;
+	if (inlen % 8)
+		return 0;
+	if (!out)
+		{
+		if (ctx->encrypt)
+			return inlen + 8;
+		else
+			return inlen - 8;
+		}
+	if (!in)
+		return 0;
+	if (ctx->encrypt)
+		rv = CRYPTO_128_wrap(&wctx->ks.ks, wctx->iv, out, in, inlen,
+						(block128_f)AES_encrypt);
+	else
+		rv = CRYPTO_128_unwrap(&wctx->ks.ks, wctx->iv, out, in, inlen,
+						(block128_f)AES_decrypt);
+	return rv ? (int)rv : -1;
+	}
+
+#define WRAP_FLAGS	(EVP_CIPH_WRAP_MODE \
+		| EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
+		| EVP_CIPH_ALWAYS_CALL_INIT)
+
+static const EVP_CIPHER aes_128_wrap = {
+	NID_id_aes128_wrap,
+	8, 16, 8, WRAP_FLAGS,
+	aes_wrap_init_key, aes_wrap_cipher,
+	NULL,	
+	sizeof(EVP_AES_WRAP_CTX),
+	NULL,NULL,NULL,NULL };
+
+const EVP_CIPHER *EVP_aes_128_wrap(void)
+	{
+	return &aes_128_wrap;
+	}
+
+static const EVP_CIPHER aes_192_wrap = {
+	NID_id_aes192_wrap,
+	8, 24, 8, WRAP_FLAGS,
+	aes_wrap_init_key, aes_wrap_cipher,
+	NULL,	
+	sizeof(EVP_AES_WRAP_CTX),
+	NULL,NULL,NULL,NULL };
+
+const EVP_CIPHER *EVP_aes_192_wrap(void)
+	{
+	return &aes_192_wrap;
+	}
+
+static const EVP_CIPHER aes_256_wrap = {
+	NID_id_aes256_wrap,
+	8, 32, 8, WRAP_FLAGS,
+	aes_wrap_init_key, aes_wrap_cipher,
+	NULL,	
+	sizeof(EVP_AES_WRAP_CTX),
+	NULL,NULL,NULL,NULL };
+
+const EVP_CIPHER *EVP_aes_256_wrap(void)
+	{
+	return &aes_256_wrap;
+	}
+
 #endif
diff --git a/crypto/evp/e_des3.c b/crypto/evp/e_des3.c
index fb247bf4a9..6fe6453be1 100644
--- a/crypto/evp/e_des3.c
+++ b/crypto/evp/e_des3.c
@@ -372,4 +372,111 @@ const EVP_CIPHER *EVP_des_ede3(void)
 {
 	return &des_ede3_ecb;
 }
+
+#ifndef OPENSSL_NO_SHA
+
+#include <openssl/sha.h>
+
+static const unsigned char wrap_iv[8] = {0x4a,0xdd,0xa2,0x2c,0x79,0xe8,0x21,0x05};
+
+static int des_ede3_unwrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
+				const unsigned char *in, size_t inl)
+	{
+	unsigned char icv[8], iv[8], sha1tmp[SHA_DIGEST_LENGTH];
+	int rv = -1;
+	if (inl < 24)
+		return -1;
+	if (!out)
+		return inl - 16;
+	memcpy(ctx->iv, wrap_iv, 8);
+	/* Decrypt first block which will end up as icv */
+	des_ede_cbc_cipher(ctx, icv, in, 8);
+	/* Decrypt central blocks */
+	/* If decrypting in place move whole output along a block
+	 * so the next des_ede_cbc_cipher is in place.
+	 */
+	if (out == in)
+		{
+		memmove(out, out + 8, inl - 8);
+		in -= 8;
+		}
+	des_ede_cbc_cipher(ctx, out, in + 8, inl - 16);
+	/* Decrypt final block which will be IV */
+	des_ede_cbc_cipher(ctx, iv, in + inl - 8, 8);
+	/* Reverse order of everything */
+	BUF_reverse(icv, NULL, 8);
+	BUF_reverse(out, NULL, inl - 16);
+	BUF_reverse(ctx->iv, iv, 8);
+	/* Decrypt again using new IV */
+	des_ede_cbc_cipher(ctx, out, out, inl - 16);
+	des_ede_cbc_cipher(ctx, icv, icv, 8);
+	/* Work out SHA1 hash of first portion */
+	SHA1(out, inl - 16, sha1tmp);
+
+	if (!CRYPTO_memcmp(sha1tmp, icv, 8))
+		rv = inl - 16;
+	OPENSSL_cleanse(icv, 8);
+	OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
+	OPENSSL_cleanse(iv, 8);
+	OPENSSL_cleanse(ctx->iv, 8);
+	if (rv == -1)
+		OPENSSL_cleanse(out, inl - 16);
+	
+	return rv;
+	}
+
+static int des_ede3_wrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
+				const unsigned char *in, size_t inl)
+	{
+	unsigned char sha1tmp[SHA_DIGEST_LENGTH];
+	if (!out)
+		return inl + 16;
+	/* Copy input to output buffer + 8 so we have space for IV */
+	memmove(out + 8, in, inl);
+	/* Work out ICV */
+	SHA1(in, inl, sha1tmp);
+	memcpy(out + inl + 8, sha1tmp, 8);
+	OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
+	/* Generate random IV */
+	RAND_bytes(ctx->iv, 8);
+	memcpy(out, ctx->iv, 8);
+	/* Encrypt everything after IV in place */
+	des_ede_cbc_cipher(ctx, out + 8, out + 8, inl + 8);
+	BUF_reverse(out, NULL, inl + 16);
+	memcpy(ctx->iv, wrap_iv, 8);
+	des_ede_cbc_cipher(ctx, out, out, inl + 16);
+	return inl + 16;
+	}
+
+static int des_ede3_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+				const unsigned char *in, size_t inl)
+	{
+	/* Sanity check input length: we typically only wrap keys
+	 * so EVP_MAXCHUNK is more than will ever be needed. Also
+	 * input length must be a multiple of 8 bits.
+	 */
+	if (inl >= EVP_MAXCHUNK || inl % 8)
+		return -1;
+	if (ctx->encrypt)
+		return des_ede3_wrap(ctx, out, in, inl);
+	else
+		return des_ede3_unwrap(ctx, out, in, inl);
+	}
+
+static const EVP_CIPHER des3_wrap = {
+	NID_id_smime_alg_CMS3DESwrap,
+	8, 24, 0,
+	EVP_CIPH_WRAP_MODE|EVP_CIPH_CUSTOM_IV|EVP_CIPH_FLAG_CUSTOM_CIPHER,
+	des_ede3_init_key, des_ede3_wrap_cipher,
+	NULL,	
+	sizeof(DES_EDE_KEY),
+	NULL,NULL,NULL,NULL };
+
+
+const EVP_CIPHER *EVP_des_ede3_wrap(void)
+	{
+	return &des3_wrap;
+	}
+
+# endif
 #endif
diff --git a/crypto/evp/evp.h b/crypto/evp/evp.h
index 1cf1da2fea..9be75cc3e6 100644
--- a/crypto/evp/evp.h
+++ b/crypto/evp/evp.h
@@ -333,6 +333,7 @@ struct evp_cipher_st
 #define		EVP_CIPH_GCM_MODE		0x6
 #define		EVP_CIPH_CCM_MODE		0x7
 #define		EVP_CIPH_XTS_MODE		0x10001
+#define		EVP_CIPH_WRAP_MODE		0x10002
 #define 	EVP_CIPH_MODE			0xF0007
 /* Set if variable length cipher */
 #define 	EVP_CIPH_VARIABLE_LENGTH	0x8
@@ -364,6 +365,13 @@ struct evp_cipher_st
 #define 	EVP_CIPH_FLAG_CUSTOM_CIPHER	0x100000
 #define		EVP_CIPH_FLAG_AEAD_CIPHER	0x200000
 
+/* Cipher context flag to indicate we can handle
+ * wrap mode: if allowed in older applications it could
+ * overflow buffers.
+ */
+
+#define 	EVP_CIPHER_CTX_FLAG_WRAP_ALLOW	0x1
+
 /* ctrl() values */
 
 #define		EVP_CTRL_INIT			0x0
@@ -726,6 +734,7 @@ const EVP_CIPHER *EVP_des_cbc(void);
 const EVP_CIPHER *EVP_des_ede_cbc(void);
 const EVP_CIPHER *EVP_des_ede3_cbc(void);
 const EVP_CIPHER *EVP_desx_cbc(void);
+const EVP_CIPHER *EVP_des_ede3_wrap(void);
 /* This should now be supported through the dev_crypto ENGINE. But also, why are
  * rc4 and md5 declarations made here inside a "NO_DES" precompiler branch? */
 #if 0
@@ -792,6 +801,7 @@ const EVP_CIPHER *EVP_aes_128_ctr(void);
 const EVP_CIPHER *EVP_aes_128_ccm(void);
 const EVP_CIPHER *EVP_aes_128_gcm(void);
 const EVP_CIPHER *EVP_aes_128_xts(void);
+const EVP_CIPHER *EVP_aes_128_wrap(void);
 const EVP_CIPHER *EVP_aes_192_ecb(void);
 const EVP_CIPHER *EVP_aes_192_cbc(void);
 const EVP_CIPHER *EVP_aes_192_cfb1(void);
@@ -802,6 +812,7 @@ const EVP_CIPHER *EVP_aes_192_ofb(void);
 const EVP_CIPHER *EVP_aes_192_ctr(void);
 const EVP_CIPHER *EVP_aes_192_ccm(void);
 const EVP_CIPHER *EVP_aes_192_gcm(void);
+const EVP_CIPHER *EVP_aes_192_wrap(void);
 const EVP_CIPHER *EVP_aes_256_ecb(void);
 const EVP_CIPHER *EVP_aes_256_cbc(void);
 const EVP_CIPHER *EVP_aes_256_cfb1(void);
@@ -813,6 +824,7 @@ const EVP_CIPHER *EVP_aes_256_ctr(void);
 const EVP_CIPHER *EVP_aes_256_ccm(void);
 const EVP_CIPHER *EVP_aes_256_gcm(void);
 const EVP_CIPHER *EVP_aes_256_xts(void);
+const EVP_CIPHER *EVP_aes_256_wrap(void);
 # if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA1)
 const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
 const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
@@ -1407,6 +1419,7 @@ void ERR_load_EVP_strings(void);
 #define EVP_R_UNSUPPORTED_PRF				 125
 #define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM		 118
 #define EVP_R_UNSUPPORTED_SALT_TYPE			 126
+#define EVP_R_WRAP_MODE_NOT_ALLOWED			 170
 #define EVP_R_WRONG_FINAL_BLOCK_LENGTH			 109
 #define EVP_R_WRONG_PUBLIC_KEY_TYPE			 110
 
diff --git a/crypto/evp/evp_enc.c b/crypto/evp/evp_enc.c
index 6da323077a..177fe43ac6 100644
--- a/crypto/evp/evp_enc.c
+++ b/crypto/evp/evp_enc.c
@@ -195,7 +195,8 @@ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *imp
 			ctx->cipher_data = NULL;
 			}
 		ctx->key_len = cipher->key_len;
-		ctx->flags = 0;
+		/* Preserve wrap enable flag, zero everything else */
+		ctx->flags &= EVP_CIPHER_CTX_FLAG_WRAP_ALLOW;
 		if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT)
 			{
 			if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL))
@@ -222,6 +223,13 @@ skip_to_init:
 	    || ctx->cipher->block_size == 8
 	    || ctx->cipher->block_size == 16);
 
+	if(!(ctx->flags & EVP_CIPHER_CTX_FLAG_WRAP_ALLOW)
+		&& EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_WRAP_MODE)
+		{
+		EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_WRAP_MODE_NOT_ALLOWED);
+		return 0;
+		}
+
 	if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {
 		switch(EVP_CIPHER_CTX_mode(ctx)) {
 
@@ -255,6 +263,7 @@ skip_to_init:
 			break;
 		}
 	}
+		
 
 	if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
 		if(!ctx->cipher->init(ctx,key,iv,enc)) return 0;
diff --git a/crypto/evp/evp_err.c b/crypto/evp/evp_err.c
index 9997da3459..0a433d7252 100644
--- a/crypto/evp/evp_err.c
+++ b/crypto/evp/evp_err.c
@@ -1,6 +1,6 @@
 /* crypto/evp/evp_err.c */
 /* ====================================================================
- * Copyright (c) 1999-2012 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1999-2013 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -222,6 +222,7 @@ static ERR_STRING_DATA EVP_str_reasons[]=
 {ERR_REASON(EVP_R_UNSUPPORTED_PRF)       ,"unsupported prf"},
 {ERR_REASON(EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM),"unsupported private key algorithm"},
 {ERR_REASON(EVP_R_UNSUPPORTED_SALT_TYPE) ,"unsupported salt type"},
+{ERR_REASON(EVP_R_WRAP_MODE_NOT_ALLOWED) ,"wrap mode not allowed"},
 {ERR_REASON(EVP_R_WRONG_FINAL_BLOCK_LENGTH),"wrong final block length"},
 {ERR_REASON(EVP_R_WRONG_PUBLIC_KEY_TYPE) ,"wrong public key type"},
 {0,NULL}
diff --git a/crypto/evp/evp_test.c b/crypto/evp/evp_test.c
index bc15348f5e..ad36b84640 100644
--- a/crypto/evp/evp_test.c
+++ b/crypto/evp/evp_test.c
@@ -164,6 +164,7 @@ static void test1(const EVP_CIPHER *c,const unsigned char *key,int kn,
 	test1_exit(5);
 	}
     EVP_CIPHER_CTX_init(&ctx);
+    EVP_CIPHER_CTX_set_flags(&ctx,EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
     if (encdec != 0)
         {
 	if (mode == EVP_CIPH_GCM_MODE)
@@ -232,6 +233,15 @@ static void test1(const EVP_CIPHER *c,const unsigned char *key,int kn,
 		test1_exit(13);
 		}
 	    }
+	else if (mode == EVP_CIPH_WRAP_MODE)
+	    {
+	    if(!EVP_EncryptInit_ex(&ctx,c,NULL,key,in ? iv : NULL))
+	        {
+		fprintf(stderr,"EncryptInit failed\n");
+		ERR_print_errors_fp(stderr);
+		test1_exit(10);
+		}
+	    }
 	else if(!EVP_EncryptInit_ex(&ctx,c,NULL,key,iv))
 	    {
 	    fprintf(stderr,"EncryptInit failed\n");
@@ -363,6 +373,15 @@ static void test1(const EVP_CIPHER *c,const unsigned char *key,int kn,
 		test1_exit(13);
 		}
 	    }
+	else if (mode == EVP_CIPH_WRAP_MODE)
+	    {
+	    if(!EVP_DecryptInit_ex(&ctx,c,NULL,key,in ? iv : NULL))
+	        {
+		fprintf(stderr,"EncryptInit failed\n");
+		ERR_print_errors_fp(stderr);
+		test1_exit(10);
+		}
+	    }
 	else if(!EVP_DecryptInit_ex(&ctx,c,NULL,key,iv))
 	    {
 	    fprintf(stderr,"DecryptInit failed\n");
@@ -505,7 +524,7 @@ int main(int argc,char **argv)
 	perror(szTestFile);
 	EXIT(2);
 	}
-
+    ERR_load_crypto_strings();
     /* Load up the software EVP_CIPHER and EVP_MD definitions */
     OpenSSL_add_all_ciphers();
     OpenSSL_add_all_digests();
diff --git a/crypto/evp/evptests.txt b/crypto/evp/evptests.txt
index ea55158acf..4e9958b3b5 100644
--- a/crypto/evp/evptests.txt
+++ b/crypto/evp/evptests.txt
@@ -392,3 +392,10 @@ aes-128-xts:fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0bfbebdbcbbbab9b8b7b6b5b4b3b2b1b0:9a7
 aes-128-xts:fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0bfbebdbcbbbab9b8b7b6b5b4b3b2b1b0:9a785634120000000000000000000000:000102030405060708090a0b0c0d0e0f101112:e5df1351c0544ba1350b3363cd8ef4beedbf9d
 aes-128-xts:fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0bfbebdbcbbbab9b8b7b6b5b4b3b2b1b0:9a785634120000000000000000000000:000102030405060708090a0b0c0d0e0f10111213:9d84c813f719aa2c7be3f66171c7c5c2edbf9dac
 aes-128-xts:e0e1e2e3e4e5e6e7e8e9eaebecedeeefc0c1c2c3c4c5c6c7c8c9cacbcccdcecf:21436587a90000000000000000000000:000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff:38b45812ef43a05bd957e545907e223b954ab4aaf088303ad910eadf14b42be68b2461149d8c8ba85f992be970bc621f1b06573f63e867bf5875acafa04e42ccbd7bd3c2a0fb1fff791ec5ec36c66ae4ac1e806d81fbf709dbe29e471fad38549c8e66f5345d7c1eb94f405d1ec785cc6f6a68f6254dd8339f9d84057e01a17741990482999516b5611a38f41bb6478e6f173f320805dd71b1932fc333cb9ee39936beea9ad96fa10fb4112b901734ddad40bc1878995f8e11aee7d141a2f5d48b7a4e1e7f0b2c04830e69a4fd1378411c2f287edf48c6c4e5c247a19680f7fe41cefbd49b582106e3616cbbe4dfb2344b2ae9519391f3e0fb4922254b1d6d2d19c6d4d537b3a26f3bcc51588b32f3eca0829b6a5ac72578fb814fb43cf80d64a233e3f997a3f02683342f2b33d25b492536b93becb2f5e1a8b82f5b883342729e8ae09d16938841a21a97fb543eea3bbff59f13c1a18449e398701c1ad51648346cbc04c27bb2da3b93a1372ccae548fb53bee476f9e9c91773b1bb19828394d55d3e1a20ed69113a860b6829ffa847224604435070221b257e8dff783615d2cae4803a93aa4334ab482a0afac9c0aeda70b45a481df5dec5df8cc0f423c77a5fd46cd312021d4b438862419a791be03bb4d97c0e59578542531ba466a83baf92cefc151b5cc1611a167893819b63fb8a6b18e86de60290fa72b797b0ce59f3
+# AES wrap tests from RFC3394
+id-aes128-wrap:000102030405060708090A0B0C0D0E0F::00112233445566778899AABBCCDDEEFF:1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5
+id-aes192-wrap:000102030405060708090A0B0C0D0E0F1011121314151617::00112233445566778899AABBCCDDEEFF:96778B25AE6CA435F92B5B97C050AED2468AB8A17AD84E5D
+id-aes256-wrap:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F::00112233445566778899AABBCCDDEEFF:64E8C3F9CE0F5BA263E9777905818A2A93C8191E7D6E8AE7
+id-aes192-wrap:000102030405060708090A0B0C0D0E0F1011121314151617::00112233445566778899AABBCCDDEEFF0001020304050607:031D33264E15D33268F24EC260743EDCE1C6C7DDEE725A936BA814915C6762D2
+id-aes256-wrap:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F::00112233445566778899AABBCCDDEEFF0001020304050607:A8F9BC1612C68B3FF6E6F4FBE30E71E4769C8B80A32CB8958CD5D17D6B254DA1
+id-aes256-wrap:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F::00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F:28C9F404C4B810F4CBCCB35CFB87F8263F5786E2D80ED326CBC7F0E71A99F43BFB988B9B7A02DD21