added aes and (t)des in dma mode + test suite crypto

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@10993 35acf78f-673a-0410-8e92-d51de3d6d3f4

28 files changed, 6039 insertions, 158 deletions

diff --git a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c
index 563269d42..f8d9124db 100644
--- a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c
+++ b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_aes_lld.c
@@ -16,10 +16,6 @@
 #include "hal.h"

 #include "sama_crypto_lld.h"

 

-

-

-

-

 void sama_aes_lld_write_key(const uint32_t * key, const uint32_t * vectors,

 		uint32_t len) {

 

@@ -160,6 +156,8 @@ cryerror_t sama_aes_lld_process_polling(CRYDriver *cryp, aesparams *params,
 cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp,  aesparams *params,

 		const uint8_t *in, uint8_t *out, size_t indata_len) {

 

+	cryerror_t ret;

+

 	osalDbgAssert(cryp->thread == NULL, "already waiting");

 

 	//set chunk size

@@ -168,7 +166,7 @@ cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp,  aesparams *params,
 	if ((cryp->config->cfbs != AES_CFBS_128))

 		cryp->dmachunksize = DMA_CHUNK_SIZE_1;

 

-	//set dma with

+	//set dma width

 	cryp->dmawith = DMA_DATA_WIDTH_WORD;

 

 	if (cryp->config->cfbs == AES_CFBS_16)

@@ -198,6 +196,9 @@ cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp,  aesparams *params,
 	XDMAC_CC_DAM_FIXED_AM |

 	XDMAC_CC_PERID(PERID_AES_TX);

 

+	dmaChannelSetMode(cryp->dmarx, cryp->rxdmamode);

+	dmaChannelSetMode(cryp->dmatx, cryp->txdmamode);

+

 	/* Writing channel */

 	dmaChannelSetSource(cryp->dmatx, in);

 	dmaChannelSetDestination(cryp->dmatx, AES->AES_IDATAR);

@@ -209,16 +210,33 @@ cryerror_t sama_aes_lld_process_dma(CRYDriver *cryp,  aesparams *params,
 	dmaChannelSetDestination(cryp->dmarx, out);

 	dmaChannelSetTransactionSize(cryp->dmarx,  ( indata_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith)));

 

-	if (params->encrypt)

-		AES->AES_MR |= AES_MR_CIPHER;

-	else

-		AES->AES_MR &= ~AES_MR_CIPHER;

+	//AES soft reset

+		AES->AES_CR = AES_CR_SWRST;

+

+	//AES set op mode

+		AES->AES_MR |= ((AES_MR_OPMOD_Msk & (params->mode)) | AES_MR_CKEY_PASSWD);

+

+	//AES set key size

+	ret = sama_aes_lld_set_key_size(cryp->key0_size);

+

+	if (ret == CRY_NOERROR) {

 

-	AES->AES_MR |= (((AES_MR_SMOD_Msk & (AES_MR_SMOD_IDATAR0_START)))

-			| AES_MR_CKEY_PASSWD);

+		AES->AES_MR |= (AES_MR_CFBS(cryp->config->cfbs) | AES_MR_CKEY_PASSWD);

+

+		sama_aes_lld_write_key(key0_buffer,( const uint32_t *) params->iv, cryp->key0_size);

 

-	//Enable aes interrupt

-	AES->AES_IER = AES_IER_DATRDY;

+		if (params->encrypt)

+			AES->AES_MR |= AES_MR_CIPHER;

+		else

+			AES->AES_MR &= ~AES_MR_CIPHER;

+

+		AES->AES_MR |= (((AES_MR_SMOD_Msk & (AES_MR_SMOD_IDATAR0_START)))

+				| AES_MR_CKEY_PASSWD);

+

+		//Enable aes interrupt

+		AES->AES_IER = AES_IER_DATRDY;

+

+	}

 

 	osalSysLock();

 

diff --git a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c
index 2e804cf8e..c6de6fca7 100644
--- a/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c
+++ b/os/hal/ports/SAMA/LLD/CRYPTOv1/sama_tdes_lld.c
@@ -1,18 +1,18 @@
 /*

-    ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio

+ ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio

 

-    Licensed under the Apache License, Version 2.0 (the "License");

-    you may not use this file except in compliance with the License.

-    You may obtain a copy of the License at

+ Licensed under the Apache License, Version 2.0 (the "License");

+ you may not use this file except in compliance with the License.

+ You may obtain a copy of the License at

 

-        http://www.apache.org/licenses/LICENSE-2.0

+ http://www.apache.org/licenses/LICENSE-2.0

 

-    Unless required by applicable law or agreed to in writing, software

-    distributed under the License is distributed on an "AS IS" BASIS,

-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

-    See the License for the specific language governing permissions and

-    limitations under the License.

-*/

+ Unless required by applicable law or agreed to in writing, software

+ distributed under the License is distributed on an "AS IS" BASIS,

+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ See the License for the specific language governing permissions and

+ limitations under the License.

+ */

 #include "hal.h"

 #include "sama_crypto_lld.h"

 #include "sama_tdes_lld.h"

@@ -135,115 +135,122 @@ cryerror_t sama_tdes_lld_dma(CRYDriver *cryp, tdes_config_t *params,
 		bool encrypt, const uint8_t *data, size_t data_len, uint8_t * out,

 		const uint8_t *iv) {

 

-

 	uint32_t mode = 0;

 	uint32_t *vectors = (uint32_t *) iv;

 

 	cryp->dmachunksize = DMA_CHUNK_SIZE_1;

-	cryp->dmawith = 4;

+

+	cryp->dmawith = DMA_DATA_WIDTH_WORD;

+

 	if ((params->mode == TDES_MODE_CFB)) {

-			if (cryp->config->cfbs == TDES_CFBS_16)

-				cryp->dmawith  = DMA_DATA_WIDTH_HALF_WORD;

-			if (cryp->config->cfbs == TDES_CFBS_8)

-				cryp->dmawith  = DMA_DATA_WIDTH_BYTE;

+		if (cryp->config->cfbs == TDES_CFBS_16)

+			cryp->dmawith = DMA_DATA_WIDTH_HALF_WORD;

+		if (cryp->config->cfbs == TDES_CFBS_8)

+			cryp->dmawith = DMA_DATA_WIDTH_BYTE;

+	}

+

+	cryp->rxdmamode = XDMAC_CC_TYPE_PER_TRAN |

+	XDMAC_CC_PROT_SEC |

+	XDMAC_CC_MBSIZE_SINGLE |

+	XDMAC_CC_DSYNC_PER2MEM | XDMAC_CC_CSIZE(cryp->dmachunksize) |

+	XDMAC_CC_DWIDTH(cryp->dmawith) |

+	XDMAC_CC_SIF_AHB_IF1 |

+	XDMAC_CC_DIF_AHB_IF0 |

+	XDMAC_CC_SAM_FIXED_AM |

+	XDMAC_CC_DAM_INCREMENTED_AM |

+	XDMAC_CC_PERID(PERID_TDES_RX);

+

+	cryp->txdmamode = XDMAC_CC_TYPE_PER_TRAN |

+	XDMAC_CC_PROT_SEC |

+	XDMAC_CC_MBSIZE_SINGLE |

+	XDMAC_CC_DSYNC_MEM2PER | XDMAC_CC_CSIZE(cryp->dmachunksize) |

+	XDMAC_CC_DWIDTH(cryp->dmawith) |

+	XDMAC_CC_SIF_AHB_IF0 |

+	XDMAC_CC_DIF_AHB_IF1 |

+	XDMAC_CC_SAM_INCREMENTED_AM |

+	XDMAC_CC_DAM_FIXED_AM |

+	XDMAC_CC_PERID(PERID_TDES_TX);

+

+	dmaChannelSetMode(cryp->dmarx, cryp->rxdmamode);

+	dmaChannelSetMode(cryp->dmatx, cryp->txdmamode);

+

+	/* Writing channel */

+	dmaChannelSetSource(cryp->dmatx, data);

+	dmaChannelSetDestination(cryp->dmatx, TDES->TDES_IDATAR);

+	dmaChannelSetTransactionSize(cryp->dmatx,

+			(data_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith)));

+

+	//  ( data_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith))

+

+	/* Reading channel */

+	dmaChannelSetSource(cryp->dmarx, TDES->TDES_ODATAR);

+	dmaChannelSetDestination(cryp->dmarx, out);

+	dmaChannelSetTransactionSize(cryp->dmarx,

+			(data_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith)));

+

+	//soft reset

+	TDES->TDES_CR = TDES_CR_SWRST;

+

+	//configure

+	if (encrypt)

+		mode |= TDES_MR_CIPHER_ENCRYPT;

+	else

+		mode |= TDES_MR_CIPHER_DECRYPT;

+

+	if (cryp->key0_size == 16)

+		mode |= (TDES_KEY_TWO << 4);

+	else

+		mode |= (TDES_KEY_THREE << 4);

+

+	mode |= TDES_MR_TDESMOD(params->algo);

+

+	mode |= TDES_MR_SMOD_IDATAR0_START;

+

+	mode |= TDES_MR_OPMOD(params->mode);

+

+	if (cryp->config != NULL) {

+		mode |= TDES_MR_CFBS(cryp->config->cfbs);

 	}

-	cryp->rxdmamode =

-		XDMAC_CC_DSYNC_PER2MEM |

-		XDMAC_CC_CSIZE(cryp->dmachunksize) |

-		XDMAC_CC_DWIDTH(cryp->dmawith) |

-		XDMAC_CC_SIF_AHB_IF1 |

-		XDMAC_CC_DIF_AHB_IF0 |

-		XDMAC_CC_SAM_FIXED_AM |

-		XDMAC_CC_DAM_INCREMENTED_AM |

-		XDMAC_CC_PERID(PERID_TDES_RX);

-

-		cryp->txdmamode =

-		XDMAC_CC_DSYNC_MEM2PER |

-		XDMAC_CC_CSIZE(cryp->dmachunksize) |

-		XDMAC_CC_DWIDTH(cryp->dmawith) |

-		XDMAC_CC_SIF_AHB_IF0 |

-		XDMAC_CC_DIF_AHB_IF1 |

-		XDMAC_CC_SAM_INCREMENTED_AM |

-		XDMAC_CC_DAM_FIXED_AM |

-		XDMAC_CC_PERID(PERID_TDES_TX);

-

-		  dmaChannelSetMode(cryp->dmarx, cryp->rxdmamode);

-		  dmaChannelSetMode(cryp->dmatx, cryp->txdmamode);

-

-		/* Writing channel */

-		dmaChannelSetSource(cryp->dmatx, data);

-		dmaChannelSetDestination(cryp->dmatx, TDES->TDES_IDATAR);

-		dmaChannelSetTransactionSize(cryp->dmatx, ( data_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith)) );

-

-		//  ( data_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith))

-

-		/* Reading channel */

-		dmaChannelSetSource(cryp->dmarx, TDES->TDES_ODATAR);

-		dmaChannelSetDestination(cryp->dmarx, out);

-		dmaChannelSetTransactionSize(cryp->dmarx, ( data_len / DMA_DATA_WIDTH_TO_BYTE(cryp->dmawith))  );

-

-

-		//soft reset

-			TDES->TDES_CR = TDES_CR_SWRST;

-			//configure

-			if (encrypt)

-				mode |= TDES_MR_CIPHER_ENCRYPT;

-			else

-				mode |= TDES_MR_CIPHER_DECRYPT;

-

-			if (cryp->key0_size == 16)

-				mode |= (TDES_KEY_TWO << 4);

-			else

-				mode |= (TDES_KEY_THREE << 4);

-

-			mode |= TDES_MR_TDESMOD(params->algo);

-

-			mode |= TDES_MR_SMOD(2);

-

-			mode |= TDES_MR_OPMOD(params->mode);

-

-			TDES->TDES_MR = mode;

-

-				//write keys

-				/* Write the 64-bit key(s) in the different Key Word Registers,

-				 * depending on whether one, two or three keys are required. */

-

-				TDES->TDES_KEY1WR[0] = key0_buffer[0];

-				TDES->TDES_KEY1WR[1] = key0_buffer[1];

-

-				if (cryp->key0_size > 8) {

-					TDES->TDES_KEY2WR[0] = key0_buffer[2];

-					TDES->TDES_KEY2WR[1] = key0_buffer[3];

-				} else {

-					TDES->TDES_KEY2WR[0] = 0x0;

-					TDES->TDES_KEY2WR[1] = 0x0;

-				}

-				if (cryp->key0_size > 16) {

-					TDES->TDES_KEY3WR[0] = key0_buffer[4];

-					TDES->TDES_KEY3WR[1] = key0_buffer[5];

-				} else {

-					TDES->TDES_KEY3WR[0] = 0x0;

-					TDES->TDES_KEY3WR[1] = 0x0;

-				}

-				/* The Initialization Vector Registers apply to all modes except ECB. */

-				if (params->mode != TDES_MODE_ECB && vectors != NULL) {

-					TDES->TDES_IVR[0] = vectors[0];

-					TDES->TDES_IVR[1] = vectors[1];

-				}

-				if (params->algo == TDES_ALGO_XTEA) {

-					TDES->TDES_XTEA_RNDR = TDES_XTEA_RNDR_XTEA_RNDS(32);

-				}

-

-

-		osalSysLock();

-

-		dmaChannelEnable(cryp->dmarx);

-		dmaChannelEnable(cryp->dmatx);

-

-

-		osalThreadSuspendS(&cryp->thread);

-		osalSysUnlock();

 

+	TDES->TDES_MR = mode;

+

+	//write keys

+	TDES->TDES_KEY1WR[0] = key0_buffer[0];

+	TDES->TDES_KEY1WR[1] = key0_buffer[1];

+

+	if (cryp->key0_size > 8) {

+		TDES->TDES_KEY2WR[0] = key0_buffer[2];

+		TDES->TDES_KEY2WR[1] = key0_buffer[3];

+	} else {

+		TDES->TDES_KEY2WR[0] = 0x0;

+		TDES->TDES_KEY2WR[1] = 0x0;

+	}

+	if (cryp->key0_size > 16) {

+		TDES->TDES_KEY3WR[0] = key0_buffer[4];

+		TDES->TDES_KEY3WR[1] = key0_buffer[5];

+	} else {

+		TDES->TDES_KEY3WR[0] = 0x0;

+		TDES->TDES_KEY3WR[1] = 0x0;

+	}

+	/* The Initialization Vector Registers apply to all modes except ECB. */

+	if (params->mode != TDES_MODE_ECB && vectors != NULL) {

+		TDES->TDES_IVR[0] = vectors[0];

+		TDES->TDES_IVR[1] = vectors[1];

+	}

+	if (params->algo == TDES_ALGO_XTEA) {

+		TDES->TDES_XTEA_RNDR = TDES_XTEA_RNDR_XTEA_RNDS(32);

+	}

+

+//enable interrutps

+	TDES->TDES_IER = TDES_IER_DATRDY;

+

+	osalSysLock();

+

+	dmaChannelEnable(cryp->dmarx);

+	dmaChannelEnable(cryp->dmatx);

+

+	osalThreadSuspendS(&cryp->thread);

+	osalSysUnlock();

 

 	return CRY_NOERROR;

 }

diff --git a/os/hal/ports/SAMA/SAMA5D2x/hal_crypto_lld.c b/os/hal/ports/SAMA/SAMA5D2x/hal_crypto_lld.c
index 7665f9204..8d8a92009 100644
--- a/os/hal/ports/SAMA/SAMA5D2x/hal_crypto_lld.c
+++ b/os/hal/ports/SAMA/SAMA5D2x/hal_crypto_lld.c
@@ -817,26 +817,24 @@ cryerror_t cry_lld_encrypt_DES(CRYDriver *cryp, crykey_t key_id,
 

 	cryerror_t ret = CRY_NOERROR;

 

-	if(key_id != 0 )

+	if (key_id != 0)

 		return CRY_ERR_INV_KEY_ID;

 

-	if (  ( cryp->config->tdes_algo == TDES_ALGO_SINGLE && cryp->key0_size != 8 ) ||

-		 ( cryp->config->tdes_algo == TDES_ALGO_TRIPLE && cryp->key0_size != 24 ) )

-		 return CRY_ERR_INV_KEY_SIZE;

+	if ((cryp->config->tdes_algo == TDES_ALGO_SINGLE && cryp->key0_size != 8)

+			|| (cryp->config->tdes_algo == TDES_ALGO_TRIPLE

+					&& !(cryp->key0_size == 16 || cryp->key0_size == 24)))

+		return CRY_ERR_INV_KEY_SIZE;

 

-	tdes_config_t params = {		cryp->config->tdes_algo,

-									0

-							};

+	tdes_config_t params = { cryp->config->tdes_algo, 0 };

 

-		if (!(cryp->enabledPer & TDES_PER)) {

-			cryp->enabledPer |= TDES_PER;

-			pmcEnableDES();

-		}

+	if (!(cryp->enabledPer & TDES_PER)) {

+		cryp->enabledPer |= TDES_PER;

+		pmcEnableDES();

+	}

 

-		ret = sama_tdes_lld_polling(cryp,&params, true, in,

-				8, out,NULL);

+	ret = sama_tdes_lld_polling(cryp, &params, true, in, 8, out, NULL);

 

-			return ret;

+	return ret;

 }

 

 /**

@@ -865,21 +863,23 @@ cryerror_t cry_lld_decrypt_DES(CRYDriver *cryp, crykey_t key_id,
 		const uint8_t *in, uint8_t *out) {

 

 	cryerror_t ret = CRY_NOERROR;

-		tdes_config_t params = {		cryp->config->tdes_algo,

-										0

-										};

-		if(key_id != 0 )

-						  return CRY_ERR_INV_KEY_ID;

-		if (!(cryp->enabledPer & TDES_PER)) {

-			cryp->enabledPer |= TDES_PER;

-			pmcEnableDES();

-		}

+	tdes_config_t params = { cryp->config->tdes_algo, 0 };

+	if (key_id != 0)

+		return CRY_ERR_INV_KEY_ID;

 

-		ret = sama_tdes_lld_polling(cryp,&params, false, in,

-				8, out,NULL);

+	if ((cryp->config->tdes_algo == TDES_ALGO_SINGLE && cryp->key0_size != 8)

+			|| (cryp->config->tdes_algo == TDES_ALGO_TRIPLE

+					&& !(cryp->key0_size == 16 || cryp->key0_size == 24)))

+		return CRY_ERR_INV_KEY_SIZE;

+

+	if (!(cryp->enabledPer & TDES_PER)) {

+		cryp->enabledPer |= TDES_PER;

+		pmcEnableDES();

+	}

 

+	ret = sama_tdes_lld_polling(cryp, &params, false, in, 8, out, NULL);

 

-			return ret;

+	return ret;

 }

 

 /**

@@ -911,17 +911,20 @@ cryerror_t cry_lld_encrypt_DES_ECB(CRYDriver *cryp, crykey_t key_id,
 

 	cryerror_t ret = CRY_NOERROR;

 	tdes_config_t params = { cryp->config->tdes_algo, TDES_MODE_ECB };

+

 	if (key_id != 0)

 		return CRY_ERR_INV_KEY_ID;

 

-	if (cryp->key0_size != 16 && cryp->key0_size != 24) {

+	if (cryp->config->tdes_algo == TDES_ALGO_SINGLE && cryp->key0_size != 8) {

+			return CRY_ERR_INV_KEY_SIZE;

+	}

+	if (cryp->config->tdes_algo == TDES_ALGO_TRIPLE && !(cryp->key0_size == 16 || cryp->key0_size == 24) ) {

 		return CRY_ERR_INV_KEY_SIZE;

 	}

 

 	if (!(cryp->enabledPer & TDES_PER)) {

 		cryp->enabledPer |= TDES_PER;

-		pmcEnableDES()

-		;

+		pmcEnableDES();

 	}

 	if (cryp->config->transfer_mode == TRANSFER_POLLING)

 		ret = sama_tdes_lld_polling(cryp, &params, true, in, size, out, NULL);

@@ -963,9 +966,12 @@ cryerror_t cry_lld_decrypt_DES_ECB(CRYDriver *cryp, crykey_t key_id,
 	if (key_id != 0)

 		return CRY_ERR_INV_KEY_ID;

 

-	if (cryp->key0_size != 16 && cryp->key0_size != 24) {

-		return CRY_ERR_INV_KEY_SIZE;

-	}

+	if (cryp->config->tdes_algo == TDES_ALGO_SINGLE && cryp->key0_size != 8) {

+				return CRY_ERR_INV_KEY_SIZE;

+		}

+		if (cryp->config->tdes_algo == TDES_ALGO_TRIPLE && !(cryp->key0_size == 16 || cryp->key0_size == 24) ) {

+			return CRY_ERR_INV_KEY_SIZE;

+		}

 	if (!(cryp->enabledPer & TDES_PER)) {

 		cryp->enabledPer |= TDES_PER;

 		pmcEnableDES()

@@ -1011,9 +1017,13 @@ cryerror_t cry_lld_encrypt_DES_CBC(CRYDriver *cryp, crykey_t key_id,
 

 	cryerror_t ret = CRY_NOERROR;

 	tdes_config_t params = { cryp->config->tdes_algo, TDES_MODE_CBC };

+

 	if (key_id != 0)

 		return CRY_ERR_INV_KEY_ID;

 

+	if (cryp->config->tdes_algo == TDES_ALGO_SINGLE)

+			return CRY_ERR_INV_ALGO;

+

 	if (cryp->key0_size != 16 && cryp->key0_size != 24) {

 		return CRY_ERR_INV_KEY_SIZE;

 	}

@@ -1061,9 +1071,13 @@ cryerror_t cry_lld_decrypt_DES_CBC(CRYDriver *cryp, crykey_t key_id,
 

 	cryerror_t ret = CRY_NOERROR;

 	tdes_config_t params = { cryp->config->tdes_algo, TDES_MODE_CBC };

+

 	if (key_id != 0)

 		return CRY_ERR_INV_KEY_ID;

 

+	if (cryp->config->tdes_algo == TDES_ALGO_SINGLE)

+		return CRY_ERR_INV_ALGO;

+

 	if (cryp->key0_size != 16 && cryp->key0_size != 24) {

 		return CRY_ERR_INV_KEY_SIZE;

 	}

diff --git a/test/crypto/config.fmpp b/test/crypto/config.fmpp
new file mode 100644
index 000000000..62a3641e2
--- /dev/null
+++ b/test/crypto/config.fmpp
@@ -0,0 +1,15 @@
+sourceRoot: ../../tools/ftl/processors/unittest
+outputRoot: source
+dataRoot: .
+
+freemarkerLinks: {
+    ftllibs: ../../tools/ftl/libs
+}
+
+data : {
+  xml:xml (
+    configuration.xml
+    {
+    }
+  )
+}
diff --git a/test/crypto/configuration.xml b/test/crypto/configuration.xml
new file mode 100644
index 000000000..958839811
--- /dev/null
+++ b/test/crypto/configuration.xml
@@ -0,0 +1,2295 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<SPC5-Config version="1.0.0">
+  <application name="Crypto Test Suite" version="1.0.0" standalone="true" locked="false">
+    <description>Test Specification for Hal Crypto </description>
+    <component id="org.chibios.spc5.components.portable.generic_startup">
+      <component id="org.chibios.spc5.components.portable.chibios_unitary_tests_engine" />
+    </component>
+    <instances>
+      <instance locked="false" id="org.chibios.spc5.components.portable.generic_startup" />
+      <instance locked="false" id="org.chibios.spc5.components.portable.chibios_unitary_tests_engine">
+        <description>
+          <brief>
+            <value>Chibios Hal Crypto Test Suite.</value>
+          </brief>
+          <copyright>
+            <value><![CDATA[/*
+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/]]></value>
+          </copyright>
+          <introduction>
+            <value>Test suite for ChibiOS Crypto Hal. The purpose of this suite is to perform unit tests on the Hal Crypto and to converge to 100% code coverage through successive improvements.</value>
+          </introduction>
+        </description>
+        <global_data_and_code>
+          <code_prefix>
+            <value>cry_</value>
+          </code_prefix>
+          <global_definitions>
+            <value><![CDATA[
+extern void cryptoTest_setStream(BaseSequentialStream * s);
+extern void cryptoTest_printArray32(bool isLE,const uint32_t *a,size_t len);
+#ifdef LOG_CRYPTO_DATA
+#define SHOW_ENCRYPDATA(w) 	cryptoTest_printArray32(true,msg_encrypted,w)
+#define SHOW_DECRYPDATA(w)	cryptoTest_printArray32(true,msg_decrypted,w)
+#else
+#define SHOW_ENCRYPDATA(w)
+#define SHOW_DECRYPDATA(w)
+#endif
+
+#define TEST_DATA_BYTE_LEN 	640
+#define TEST_DATA_WORD_LEN		(TEST_DATA_BYTE_LEN / 4)
+
+
+#define TEST_MSG_DATA_BYTE_LEN		640
+#define TEST_MSG_DATA_WORD_LEN		(TEST_MSG_DATA_BYTE_LEN / 4)
+
+extern const char test_plain_data[TEST_DATA_BYTE_LEN];
+extern uint32_t msg_clear[TEST_MSG_DATA_WORD_LEN];
+extern uint32_t msg_encrypted[TEST_MSG_DATA_WORD_LEN];
+extern uint32_t msg_decrypted[TEST_MSG_DATA_WORD_LEN];
+extern const uint32_t test_keys[8];
+extern const uint32_t test_vectors[4];
+
+]]></value>
+          </global_definitions>
+          <global_code>
+            <value><![CDATA[
+
+#if CRYPTO_LOG_LEVEL == 1
+#include "chprintf.h"
+#endif
+
+
+
+const uint32_t test_keys[8]=
+{
+    0x01234567,       //KEY 1 low part
+    0x89ABCDEF,       //KEY 1 hi part
+    0x76543210,       //KEY 2 low part
+    0xFEDCBA98,       //KEY 2 hi part
+
+    0x55AA55AA,
+    0xAA55AA55,
+    0x0000FFFF,
+    0xFFFF0000
+
+};
+
+const uint32_t test_vectors[4]=
+{
+    0x11223344,   //VECTOR 1 low part
+    0x55667788,   //VECTOR 1 hi part
+    0x11112222,
+    0x33334444
+
+};
+
+const char test_plain_data[TEST_DATA_BYTE_LEN] ="\
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesen\
+t et pellentesque risus. Sed id gravida elit. Proin eget accumsa\
+n mi. Aliquam vitae dui porta, euismod velit viverra, elementum \
+lacus. Nunc turpis orci, venenatis vel vulputate nec, luctus sit\
+amet urna. Ut et nunc purus. Aliquam erat volutpat. Vestibulum n\
+ulla dolor, cursus vitae cursus eget, dapibus eget sapien. Integ\
+er justo eros, commodo ut massa eu, bibendum elementum tellus. N\
+am quis dolor in libero placerat congue. Sed sodales urna sceler\
+isque dui faucibus, vitae malesuada dui fermentum. Proin ultrici\
+es sit amet justo at ornare. Suspendisse efficitur purus nullam.";
+
+ALIGNED_VAR(4) uint32_t msg_clear[TEST_MSG_DATA_WORD_LEN];
+ALIGNED_VAR(4) uint32_t msg_encrypted[TEST_MSG_DATA_WORD_LEN];
+ALIGNED_VAR(4) uint32_t msg_decrypted[TEST_MSG_DATA_WORD_LEN];
+BaseSequentialStream * ts;
+
+#if CRYPTO_LOG_LEVEL == 1
+static uint32_t toBigEndian(uint32_t v)
+{
+  return (v & 0x000000ff) << 24u |
+  ( (v & 0x0000ff00) << 8u ) |
+  ( (v & 0x00ff0000) >> 8u ) |
+  ( (v & 0xff000000) >> 24u );
+}
+#endif
+
+void cryptoTest_setStream(BaseSequentialStream * s)
+{
+	ts = s;
+}
+
+void cryptoTest_printArray(const uint8_t *a,size_t len)
+{
+#if CRYPTO_LOG_LEVEL == 1
+	for(size_t i=0;i<len;i++)
+	{
+		chprintf(ts,"%02X",a[i]);
+	}
+	chprintf(ts,"\r\n");
+#else
+	(void)a;
+	(void)len;
+#endif
+}
+
+void cryptoTest_printArray32(bool isLE,const uint32_t *a,size_t len)
+{
+#if CRYPTO_LOG_LEVEL == 1
+	uint32_t data;
+
+	for(size_t i=0;i<len;i++)
+	{
+		if (isLE)
+			data = toBigEndian(a[i]);
+		else
+			data = a[i];
+
+		chprintf(ts,"%08X ",data);
+
+	}
+	chprintf(ts,"\r\n");
+#else
+	(void)isLE;
+	(void)a;
+	(void)len;
+#endif
+}
+
+            	]]></value>
+          </global_code>
+        </global_data_and_code>
+
+        <sequences>
+<sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>AES ECB</value>
+            </brief>
+            <description>
+              <value>AES ECB</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[
+#include <string.h>
+#include "ref_aes.h"
+static const CRYConfig config_Polling = {
+    TRANSFER_POLLING,
+    AES_CFBS_128,       //cfbs
+    0
+};
+
+static const CRYConfig config_DMA = {
+    TRANSFER_DMA,
+    AES_CFBS_128,       //cfbs
+    0
+};
+                ]]></value>
+            </shared_code>
+            <cases>
+              <case>
+                <brief>
+                  <value>AES ECB Polling</value>
+                </brief>
+                <description>
+                  <value>testing AES ECB with various Keys</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &config_Polling);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_128)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_192)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 32 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_256)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+               <case>
+                <brief>
+                  <value>AES ECB DMA</value>
+                </brief>
+                <description>
+                  <value>testing AES ECB with various Keys</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &config_DMA);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_128)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_192)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 32 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_256)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+            </cases>
+          </sequence>
+
+
+<sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>AES CFB</value>
+            </brief>
+            <description>
+              <value>AES CFB</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[
+#include <string.h>
+#include "ref_aes.h"
+static const CRYConfig config_Polling = {
+    TRANSFER_POLLING,
+    AES_CFBS_128,       //cfbs
+    0
+};
+
+static const CRYConfig config_DMA = {
+    TRANSFER_DMA,
+    AES_CFBS_128,       //cfbs
+    0
+};
+                ]]></value>
+            </shared_code>
+            <cases>
+              <case>
+                <brief>
+                  <value>AES CFB Polling</value>
+                </brief>
+                <description>
+                  <value>testing AES CFB with various Keys</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &config_Polling);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_128)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_192)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 32 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_256)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+               <case>
+                <brief>
+                  <value>AES CFB DMA</value>
+                </brief>
+                <description>
+                  <value>testing AES CFB with various Keys</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &config_DMA);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_128)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_192)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 32 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_256)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+            </cases>
+          </sequence>
+
+
+<sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>AES CBC</value>
+            </brief>
+            <description>
+              <value>AES CBC</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[
+#include <string.h>
+#include "ref_aes.h"
+static const CRYConfig config_Polling = {
+    TRANSFER_POLLING,
+    AES_CFBS_128,       //cfbs
+    0
+};
+
+static const CRYConfig config_DMA = {
+    TRANSFER_DMA,
+    AES_CFBS_128,       //cfbs
+    0
+};
+                ]]></value>
+            </shared_code>
+            <cases>
+              <case>
+                <brief>
+                  <value>AES CBC Polling</value>
+                </brief>
+                <description>
+                  <value>testing AES CBC with various Keys</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &config_Polling);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_128)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_192)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 32 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_256)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+               <case>
+                <brief>
+                  <value>AES CBC DMA</value>
+                </brief>
+                <description>
+                  <value>testing AES CBC with various Keys</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &config_DMA);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_128)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_192)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 32 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_256)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                </steps>
+              </case>
+            </cases>
+          </sequence>
+
+		  
+<sequence>
+            <type index="0">
+              <value>Internal Tests</value>
+            </type>
+            <brief>
+              <value>(T)DES</value>
+            </brief>
+            <description>
+              <value>(T)DES testing</value>
+            </description>
+            <condition>
+              <value />
+            </condition>
+            <shared_code>
+              <value><![CDATA[
+#include <string.h>
+#include "ref_des.h"
+static const CRYConfig configDES_Polling=
+{
+		TRANSFER_POLLING,
+		0,
+		TDES_ALGO_SINGLE
+};
+static const CRYConfig configTDES_Polling=
+{
+		TRANSFER_POLLING,
+		0,
+		TDES_ALGO_TRIPLE
+};
+
+static const CRYConfig configTDES_DMA=
+{
+		TRANSFER_DMA,
+		0,
+		TDES_ALGO_TRIPLE
+};
+
+                ]]></value>
+            </shared_code>
+            <cases>
+			 <case>
+                <brief>
+                  <value>DES Polling</value>
+                </brief>
+                <description>
+                  <value>testing DES in polled mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &configDES_Polling);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 8 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,8, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES(&CRYD1, 0, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(2);
+
+for (int i = 0; i < 2; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refDES_ECB_8)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES(&CRYD1, 0, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(2);
+
+for (int i = 0; i < 2; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  
+                
+
+                 
+ 
+                </steps>
+              </case>
+              
+              <case>
+                <brief>
+                  <value>TDES CBC Polling</value>
+                </brief>
+                <description>
+                  <value>testing TDES CBC in polled mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &configTDES_Polling);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_16)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_24)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                 
+                 
+
+                </steps>
+              </case>
+               <case>
+                <brief>
+                  <value>TDES ECB Polling</value>
+                </brief>
+                <description>
+                  <value>testing TDES ECB in polling mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &configTDES_Polling);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_16)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_24)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+
+
+
+                </steps>
+              </case>
+            
+			
+              
+              <case>
+                <brief>
+                  <value>TDES CBC DMA</value>
+                </brief>
+                <description>
+                  <value>testing TDES CBC in polled mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &configTDES_DMA);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_16)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_24)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                 
+                 
+
+                </steps>
+              </case>
+               <case>
+                <brief>
+                  <value>TDES ECB DMA</value>
+                </brief>
+                <description>
+                  <value>testing TDES ECB in DMA mode</value>
+                </description>
+                <condition>
+                  <value />
+                </condition>
+                <various_code>
+                  <setup_code>
+                    <value><![CDATA[
+memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);
+memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);
+cryStart(&CRYD1, &configTDES_DMA);
+
+                      ]]></value>
+                  </setup_code>
+                  <teardown_code>
+                    <value><![CDATA[cryStop(&CRYD1);]]></value>
+                  </teardown_code>
+                  <local_variables>
+                    <value><![CDATA[
+  cryerror_t ret;
+]]></value>
+                  </local_variables>
+                </various_code>
+                <steps>
+                  <step>
+                    <description>
+                      <value>loading the key with 16 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_16)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>loading the key with 24 byte size</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);
+
+test_assert(ret == CRY_NOERROR, "failed load transient key");
+]]></value>
+                    </code>
+                  </step>
+                  <step>
+                    <description>
+                      <value>Encrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);
+
+test_assert(ret == CRY_NOERROR, "encrypt failed");
+
+SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_24)[i], "encrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+                   <step>
+                    <description>
+                      <value>Decrypt</value>
+                    </description>
+                    <tags>
+                      <value />
+                    </tags>
+                    <code>
+                      <value><![CDATA[
+ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);
+
+test_assert(ret == CRY_NOERROR, "decrypt failed");
+
+SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);
+
+for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {
+  test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");
+}
+
+]]></value>
+                    </code>
+                  </step>
+
+
+
+                </steps>
+              </case>
+           
+
+			</cases>
+          </sequence>
+
+        </sequences>
+      </instance>
+    </instances>
+    <exportedFeatures />
+  </application>
+</SPC5-Config>
diff --git a/test/crypto/crypto_test.mk b/test/crypto/crypto_test.mk
new file mode 100644
index 000000000..039cff349
--- /dev/null
+++ b/test/crypto/crypto_test.mk
@@ -0,0 +1,15 @@
+# List of all the ChibiOS OS Library test files.

+TESTSRC += 	 ${CHIBIOS}/test/crypto/source/test/cry_test_root.c \

+			 ${CHIBIOS}/test/crypto/source/testref/ref_aes.c \

+			 ${CHIBIOS}/test/crypto/source/testref/ref_des.c \

+           	 ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_001.c		\

+           	 ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_002.c		\

+           	 ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_003.c		\

+           	 ${CHIBIOS}/test/crypto/source/test/cry_test_sequence_004.c

+# Required include directories

+TESTINC +=  ${CHIBIOS}/test/crypto/source/testref	\

+			${CHIBIOS}/test/crypto/source/test

+

+include $(CHIBIOS)/os/hal/lib/streams/streams.mk

+

+

diff --git a/test/crypto/ref/README.txt b/test/crypto/ref/README.txt
new file mode 100644
index 000000000..6df947b08
--- /dev/null
+++ b/test/crypto/ref/README.txt
@@ -0,0 +1,2 @@
+set path of python and openssl in setpath.bat

+launch gen_testref.bat
\ No newline at end of file
diff --git a/test/crypto/ref/aes_ref.bat b/test/crypto/ref/aes_ref.bat
new file mode 100644
index 000000000..05c132c08
--- /dev/null
+++ b/test/crypto/ref/aes_ref.bat
@@ -0,0 +1,17 @@
+

+

+%OPENSSL%\openssl enc -aes-128-ecb -nosalt -nopad -K %K16% -in plaintext -out aes_ecb_128.enc

+%OPENSSL%\openssl enc -aes-192-ecb -nopad -nosalt -K %K24% -in plaintext -out aes_ecb_192.enc

+%OPENSSL%\openssl enc -aes-256-ecb -nopad -nosalt -K %K32% -in plaintext -out aes_ecb_256.enc

+

+%OPENSSL%\openssl enc -aes-128-cbc -nopad -nosalt -K %K16% -iv %IV% -in plaintext -out aes_cbc_128.enc

+%OPENSSL%\openssl enc -aes-192-cbc -nopad -nosalt -K %K24% -iv %IV% -in plaintext -out aes_cbc_192.enc

+%OPENSSL%\openssl enc -aes-256-cbc -nopad -nosalt -K %K32% -iv %IV% -in plaintext -out aes_cbc_256.enc

+

+%OPENSSL%\openssl enc -aes-128-ctr -nopad -nosalt -K %K16% -iv %IV% -in plaintext -out aes_ctr_128.enc

+%OPENSSL%\openssl enc -aes-192-ctr -nopad -nosalt -K %K24% -iv %IV% -in plaintext -out aes_ctr_192.enc

+%OPENSSL%\openssl enc -aes-256-ctr -nopad -nosalt -K %K32% -iv %IV% -in plaintext -out aes_ctr_256.enc

+

+%OPENSSL%\openssl enc -aes-128-cfb -nopad -nosalt -K %K16% -iv %IV% -in plaintext -out aes_cfb_128.enc

+%OPENSSL%\openssl enc -aes-192-cfb -nopad -nosalt -K %K24% -iv %IV% -in plaintext -out aes_cfb_192.enc

+%OPENSSL%\openssl enc -aes-256-cfb -nopad -nosalt -K %K32% -iv %IV% -in plaintext -out aes_cfb_256.enc

diff --git a/test/crypto/ref/des_ref.bat b/test/crypto/ref/des_ref.bat
new file mode 100644
index 000000000..62d031391
--- /dev/null
+++ b/test/crypto/ref/des_ref.bat
@@ -0,0 +1,8 @@
+

+call %OPENSSL%\openssl enc -des-ecb -nopad -nosalt -K %K8% -e -in plaintext -out des_ecb_8.enc

+

+REM TDES

+call %OPENSSL%\openssl enc -des-ede-ecb -nopad -nosalt -K %K16% -e -in plaintext -out tdes_ecb_16.enc

+call %OPENSSL%\openssl enc -des-ede3-ecb -nopad -nosalt -K %K24% -e -in plaintext -out tdes_ecb_24.enc

+call %OPENSSL%\openssl enc -des-ede-cbc -nopad -nosalt -K %K16% -iv %DES_IV% -e -in plaintext -out tdes_cbc_16.enc

+call %OPENSSL%\openssl enc -des-ede3-cbc -nopad -nosalt -K %K24% -iv %DES_IV% -e -in plaintext -out tdes_cbc_24.enc 
\ No newline at end of file
diff --git a/test/crypto/ref/gen_cfiles.bat b/test/crypto/ref/gen_cfiles.bat
new file mode 100644
index 000000000..d0bc19ff9
--- /dev/null
+++ b/test/crypto/ref/gen_cfiles.bat
@@ -0,0 +1,4 @@
+%PYTHON%\python genfile.py -f aes_ecb_128,aes_ecb_192,aes_ecb_256,aes_cbc_128,aes_cbc_192,aes_cbc_256,aes_ctr_128,aes_ctr_192,aes_ctr_256,aes_cfb_128,aes_cfb_192,aes_cfb_256 -o ref_aes -p ../source/testref

+

+%PYTHON%\python genfile.py -f des_ecb_8,tdes_ecb_16,tdes_ecb_24,tdes_cbc_16,tdes_cbc_24 -o ref_des -p ../source/testref

+

diff --git a/test/crypto/ref/gen_testref.bat b/test/crypto/ref/gen_testref.bat
new file mode 100644
index 000000000..311376773
--- /dev/null
+++ b/test/crypto/ref/gen_testref.bat
@@ -0,0 +1,12 @@
+call setpath.bat

+

+call ref_data.bat

+

+del *.enc

+

+%PYTHON%\python -c "print 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent et pellentesque risus. Sed id gravida elit. Proin eget accumsan mi. Aliquam vitae dui porta, euismod velit viverra, elementum lacus. Nunc turpis orci, venenatis vel vulputate nec, luctus sitamet urna. Ut et nunc purus. Aliquam erat volutpat. Vestibulum nulla dolor, cursus vitae cursus eget, dapibus eget sapien. Integer justo eros, commodo ut massa eu, bibendum elementum tellus. Nam quis dolor in libero placerat congue. Sed sodales urna scelerisque dui faucibus, vitae malesuada dui fermentum. Proin ultricies sit amet justo at ornare. Suspendisse efficitur purus nullam.'.decode('ascii')" > plaintext

+

+call aes_ref.bat

+call des_ref.bat

+

+call gen_cfiles.bat
\ No newline at end of file
diff --git a/test/crypto/ref/genfile.py b/test/crypto/ref/genfile.py
new file mode 100644
index 000000000..4bfac9e12
--- /dev/null
+++ b/test/crypto/ref/genfile.py
@@ -0,0 +1,68 @@
+import sys,getopt,string

+

+filenames = None

+fileOut = None

+filePath = None

+blocksize = 1024

+i = 0

+

+license ='/*\n'\

+'    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio\n'\

+'\n'\

+'    Licensed under the Apache License, Version 2.0 (the "License");\n'\

+'    you may not use this file except in compliance with the License.\n'\

+'    You may obtain a copy of the License at\n'\

+'\n'\

+'        http://www.apache.org/licenses/LICENSE-2.0\n'\

+'\n'\

+'    Unless required by applicable law or agreed to in writing, software\n'\

+'    distributed under the License is distributed on an "AS IS" BASIS,\n'\

+'    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n'\

+'    See the License for the specific language governing permissions and\n'\

+'    limitations under the License.\n'\

+'*/\n'

+

+opts,args = getopt.getopt(sys.argv[1:],'f:o:p:')

+for o,a in opts:

+	if o == '-f':

+		filenames = a

+	if o == '-o':

+		fileOut = a

+	if o == '-p':

+		filePath = a

+	

+

+filenames = filenames.split(",")

+

+fc = open (filePath+"/"+fileOut+".c","w")

+fh = open (filePath+"/"+fileOut+".h","w")

+fc.write(license)

+fc.write("\n#include \"hal.h\"\n\n")

+fh.write(license)

+fh.write("#ifndef TEST_"+fileOut.upper()+"_H_\n")

+fh.write("#define TEST_"+fileOut.upper()+"_H_\n\n")

+	

+for fn in filenames:

+	print "opening ",fn

+	i = 0

+	f = open(fn+".enc","rb")

+	block = f.read(blocksize)

+	d = fn.split("_")

+

+

+	

+	fc.write("const uint8_t ref"+d[0].upper()+"_"+d[1].upper()+"_"+d[2].upper()+"[]={\n")

+	fh.write("extern const uint8_t ref"+d[0].upper()+"_"+d[1].upper()+"_"+d[2].upper()+"[];\n")

+	str = ""

+	for ch in block:

+		i   += 1

+		str += "0x"+format(ord(ch), '02X')+","

+		if i == 10:

+			str += "\n"

+			i = 0

+	fc.write(str)

+	fc.write("\n};\n")

+fh.write("#endif //TEST_"+fileOut.upper()+"_H_\n")

+	

+	

+

diff --git a/test/crypto/ref/ref_data.bat b/test/crypto/ref/ref_data.bat
new file mode 100644
index 000000000..9a9ccd362
--- /dev/null
+++ b/test/crypto/ref/ref_data.bat
@@ -0,0 +1,7 @@
+set K8=67452301EFCDAB89

+set K16=67452301EFCDAB891032547698BADCFE

+set K24=67452301EFCDAB891032547698BADCFEAA55AA5555AA55AA

+set K32=67452301EFCDAB891032547698BADCFEAA55AA5555AA55AAFFFF00000000FFFF

+set IV=44332211887766552222111144443333

+set DES_IV=4433221188776655

+

diff --git a/test/crypto/ref/setpath.bat b/test/crypto/ref/setpath.bat
new file mode 100644
index 000000000..196545e16
--- /dev/null
+++ b/test/crypto/ref/setpath.bat
@@ -0,0 +1,2 @@
+set PYTHON=E:\python\Python27

+set OPENSSL=E:\dev\OpenSSL-Win64\bin
\ No newline at end of file
diff --git a/test/crypto/source/test/cry_test_root.c b/test/crypto/source/test/cry_test_root.c
new file mode 100644
index 000000000..e80e1d3fb
--- /dev/null
+++ b/test/crypto/source/test/cry_test_root.c
@@ -0,0 +1,169 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+/**

+ * @mainpage Test Suite Specification

+ * Test suite for ChibiOS Crypto Hal. The purpose of this suite is to

+ * perform unit tests on the Hal Crypto and to converge to 100% code

+ * coverage through successive improvements.

+ *

+ * <h2>Test Sequences</h2>

+ * - @subpage cry_test_sequence_001

+ * - @subpage cry_test_sequence_002

+ * - @subpage cry_test_sequence_003

+ * - @subpage cry_test_sequence_004

+ * .

+ */

+

+/**

+ * @file    cry_test_root.c

+ * @brief   Test Suite root structures code.

+ */

+

+#include "hal.h"

+#include "cry_test_root.h"

+

+#if !defined(__DOXYGEN__)

+

+/*===========================================================================*/

+/* Module exported variables.                                                */

+/*===========================================================================*/

+

+/**

+ * @brief   Array of test sequences.

+ */

+const testsequence_t * const cry_test_suite_array[] = {

+  &cry_test_sequence_001,

+  &cry_test_sequence_002,

+  &cry_test_sequence_003,

+  &cry_test_sequence_004,

+  NULL

+};

+

+/**

+ * @brief   Test suite root structure.

+ */

+const testsuite_t cry_test_suite = {

+  "Chibios Hal Crypto Test Suite",

+  cry_test_suite_array

+};

+

+/*===========================================================================*/

+/* Shared code.                                                              */

+/*===========================================================================*/

+

+

+#if CRYPTO_LOG_LEVEL == 1

+#include "chprintf.h"

+#endif

+

+

+

+const uint32_t test_keys[8]=

+{

+    0x01234567,       //KEY 1 low part

+    0x89ABCDEF,       //KEY 1 hi part

+    0x76543210,       //KEY 2 low part

+    0xFEDCBA98,       //KEY 2 hi part

+

+    0x55AA55AA,

+    0xAA55AA55,

+    0x0000FFFF,

+    0xFFFF0000

+

+};

+

+const uint32_t test_vectors[4]=

+{

+    0x11223344,   //VECTOR 1 low part

+    0x55667788,   //VECTOR 1 hi part

+    0x11112222,

+    0x33334444

+

+};

+

+const char test_plain_data[TEST_DATA_BYTE_LEN] ="\

+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesen\

+t et pellentesque risus. Sed id gravida elit. Proin eget accumsa\

+n mi. Aliquam vitae dui porta, euismod velit viverra, elementum \

+lacus. Nunc turpis orci, venenatis vel vulputate nec, luctus sit\

+amet urna. Ut et nunc purus. Aliquam erat volutpat. Vestibulum n\

+ulla dolor, cursus vitae cursus eget, dapibus eget sapien. Integ\

+er justo eros, commodo ut massa eu, bibendum elementum tellus. N\

+am quis dolor in libero placerat congue. Sed sodales urna sceler\

+isque dui faucibus, vitae malesuada dui fermentum. Proin ultrici\

+es sit amet justo at ornare. Suspendisse efficitur purus nullam.";

+

+ALIGNED_VAR(4) uint32_t msg_clear[TEST_MSG_DATA_WORD_LEN];

+ALIGNED_VAR(4) uint32_t msg_encrypted[TEST_MSG_DATA_WORD_LEN];

+ALIGNED_VAR(4) uint32_t msg_decrypted[TEST_MSG_DATA_WORD_LEN];

+BaseSequentialStream * ts;

+

+#if CRYPTO_LOG_LEVEL == 1

+static uint32_t toBigEndian(uint32_t v)

+{

+  return (v & 0x000000ff) << 24u |

+  ( (v & 0x0000ff00) << 8u ) |

+  ( (v & 0x00ff0000) >> 8u ) |

+  ( (v & 0xff000000) >> 24u );

+}

+#endif

+

+void cryptoTest_setStream(BaseSequentialStream * s)

+{

+	ts = s;

+}

+

+void cryptoTest_printArray(const uint8_t *a,size_t len)

+{

+#if CRYPTO_LOG_LEVEL == 1

+	for(size_t i=0;i<len;i++)

+	{

+		chprintf(ts,"%02X",a[i]);

+	}

+	chprintf(ts,"\r\n");

+#else

+	(void)a;

+	(void)len;

+#endif

+}

+

+void cryptoTest_printArray32(bool isLE,const uint32_t *a,size_t len)

+{

+#if CRYPTO_LOG_LEVEL == 1

+	uint32_t data;

+

+	for(size_t i=0;i<len;i++)

+	{

+		if (isLE)

+			data = toBigEndian(a[i]);

+		else

+			data = a[i];

+

+		chprintf(ts,"%08X ",data);

+

+	}

+	chprintf(ts,"\r\n");

+#else

+	(void)isLE;

+	(void)a;

+	(void)len;

+#endif

+}

+

+

+

+#endif /* !defined(__DOXYGEN__) */

diff --git a/test/crypto/source/test/cry_test_root.h b/test/crypto/source/test/cry_test_root.h
new file mode 100644
index 000000000..2bb5ab029
--- /dev/null
+++ b/test/crypto/source/test/cry_test_root.h
@@ -0,0 +1,78 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+/**

+ * @file    cry_test_root.h

+ * @brief   Test Suite root structures header.

+ */

+

+#ifndef CRY_TEST_ROOT_H

+#define CRY_TEST_ROOT_H

+

+#include "ch_test.h"

+

+#include "cry_test_sequence_001.h"

+#include "cry_test_sequence_002.h"

+#include "cry_test_sequence_003.h"

+#include "cry_test_sequence_004.h"

+

+#if !defined(__DOXYGEN__)

+

+/*===========================================================================*/

+/* External declarations.                                                    */

+/*===========================================================================*/

+

+extern const testsuite_t cry_test_suite;

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+#ifdef __cplusplus

+}

+#endif

+

+/*===========================================================================*/

+/* Shared definitions.                                                       */

+/*===========================================================================*/

+

+extern void cryptoTest_setStream(BaseSequentialStream * s);

+extern void cryptoTest_printArray32(bool isLE,const uint32_t *a,size_t len);

+#ifdef LOG_CRYPTO_DATA

+#define SHOW_ENCRYPDATA(w) 	cryptoTest_printArray32(true,msg_encrypted,w)

+#define SHOW_DECRYPDATA(w)	cryptoTest_printArray32(true,msg_decrypted,w)

+#else

+#define SHOW_ENCRYPDATA(w)

+#define SHOW_DECRYPDATA(w)

+#endif

+

+#define TEST_DATA_BYTE_LEN 	640

+#define TEST_DATA_WORD_LEN		(TEST_DATA_BYTE_LEN / 4)

+

+

+#define TEST_MSG_DATA_BYTE_LEN		640

+#define TEST_MSG_DATA_WORD_LEN		(TEST_MSG_DATA_BYTE_LEN / 4)

+

+extern const char test_plain_data[TEST_DATA_BYTE_LEN];

+extern uint32_t msg_clear[TEST_MSG_DATA_WORD_LEN];

+extern uint32_t msg_encrypted[TEST_MSG_DATA_WORD_LEN];

+extern uint32_t msg_decrypted[TEST_MSG_DATA_WORD_LEN];

+extern const uint32_t test_keys[8];

+extern const uint32_t test_vectors[4];

+

+

+#endif /* !defined(__DOXYGEN__) */

+

+#endif /* CRY_TEST_ROOT_H */

diff --git a/test/crypto/source/test/cry_test_sequence_001.c b/test/crypto/source/test/cry_test_sequence_001.c
new file mode 100644
index 000000000..3a45c786a
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_001.c
@@ -0,0 +1,393 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+#include "hal.h"

+#include "cry_test_root.h"

+

+/**

+ * @file    cry_test_sequence_001.c

+ * @brief   Test Sequence 001 code.

+ *

+ * @page cry_test_sequence_001 [1] AES ECB

+ *

+ * File: @ref cry_test_sequence_001.c

+ *

+ * <h2>Description</h2>

+ * AES ECB.

+ *

+ * <h2>Test Cases</h2>

+ * - @subpage cry_test_001_001

+ * - @subpage cry_test_001_002

+ * .

+ */

+

+/****************************************************************************

+ * Shared code.

+ ****************************************************************************/

+

+#include <string.h>

+#include "ref_aes.h"

+static const CRYConfig config_Polling = {

+    TRANSFER_POLLING,

+    AES_CFBS_128,       //cfbs

+    0

+};

+

+static const CRYConfig config_DMA = {

+    TRANSFER_DMA,

+    AES_CFBS_128,       //cfbs

+    0

+};

+

+

+/****************************************************************************

+ * Test cases.

+ ****************************************************************************/

+

+/**

+ * @page cry_test_001_001 [1.1] AES ECB Polling

+ *

+ * <h2>Description</h2>

+ * testing AES ECB with various Keys.

+ *

+ * <h2>Test Steps</h2>

+ * - [1.1.1] loading the key with 16 byte size.

+ * - [1.1.2] Encrypt.

+ * - [1.1.3] Decrypt.

+ * - [1.1.4] loading the key with 24 byte size.

+ * - [1.1.5] Encrypt.

+ * - [1.1.6] Decrypt.

+ * - [1.1.7] loading the key with 32 byte size.

+ * - [1.1.8] Encrypt.

+ * - [1.1.9] Decrypt.

+ * .

+ */

+

+static void cry_test_001_001_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &config_Polling);

+

+

+}

+

+static void cry_test_001_001_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_001_001_execute(void) {

+    cryerror_t ret;

+

+  /* [1.1.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [1.1.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_128)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [1.1.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [1.1.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [1.1.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_192)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [1.1.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [1.1.7] loading the key with 32 byte size.*/

+  test_set_step(7);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [1.1.8] Encrypt.*/

+  test_set_step(8);

+  {

+    ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_256)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [1.1.9] Decrypt.*/

+  test_set_step(9);

+  {

+    ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_001_001 = {

+  "AES ECB Polling",

+  cry_test_001_001_setup,

+  cry_test_001_001_teardown,

+  cry_test_001_001_execute

+};

+

+/**

+ * @page cry_test_001_002 [1.2] AES ECB DMA

+ *

+ * <h2>Description</h2>

+ * testing AES ECB with various Keys.

+ *

+ * <h2>Test Steps</h2>

+ * - [1.2.1] loading the key with 16 byte size.

+ * - [1.2.2] Encrypt.

+ * - [1.2.3] Decrypt.

+ * - [1.2.4] loading the key with 24 byte size.

+ * - [1.2.5] Encrypt.

+ * - [1.2.6] Decrypt.

+ * - [1.2.7] loading the key with 32 byte size.

+ * - [1.2.8] Encrypt.

+ * - [1.2.9] Decrypt.

+ * .

+ */

+

+static void cry_test_001_002_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &config_DMA);

+

+

+}

+

+static void cry_test_001_002_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_001_002_execute(void) {

+    cryerror_t ret;

+

+  /* [1.2.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [1.2.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_128)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [1.2.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [1.2.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [1.2.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_192)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [1.2.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [1.2.7] loading the key with 32 byte size.*/

+  test_set_step(7);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [1.2.8] Encrypt.*/

+  test_set_step(8);

+  {

+    ret = cryEncryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_ECB_256)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [1.2.9] Decrypt.*/

+  test_set_step(9);

+  {

+    ret = cryDecryptAES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_001_002 = {

+  "AES ECB DMA",

+  cry_test_001_002_setup,

+  cry_test_001_002_teardown,

+  cry_test_001_002_execute

+};

+

+/****************************************************************************

+ * Exported data.

+ ****************************************************************************/

+

+/**

+ * @brief   Array of test cases.

+ */

+const testcase_t * const cry_test_sequence_001_array[] = {

+  &cry_test_001_001,

+  &cry_test_001_002,

+  NULL

+};

+

+/**

+ * @brief   AES ECB.

+ */

+const testsequence_t cry_test_sequence_001 = {

+  "AES ECB",

+  cry_test_sequence_001_array

+};

diff --git a/test/crypto/source/test/cry_test_sequence_001.h b/test/crypto/source/test/cry_test_sequence_001.h
new file mode 100644
index 000000000..ca55338ea
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_001.h
@@ -0,0 +1,27 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+/**

+ * @file    cry_test_sequence_001.h

+ * @brief   Test Sequence 001 header.

+ */

+

+#ifndef CRY_TEST_SEQUENCE_001_H

+#define CRY_TEST_SEQUENCE_001_H

+

+extern const testsequence_t cry_test_sequence_001;

+

+#endif /* CRY_TEST_SEQUENCE_001_H */

diff --git a/test/crypto/source/test/cry_test_sequence_002.c b/test/crypto/source/test/cry_test_sequence_002.c
new file mode 100644
index 000000000..f8fdb739e
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_002.c
@@ -0,0 +1,393 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+#include "hal.h"

+#include "cry_test_root.h"

+

+/**

+ * @file    cry_test_sequence_002.c

+ * @brief   Test Sequence 002 code.

+ *

+ * @page cry_test_sequence_002 [2] AES CFB

+ *

+ * File: @ref cry_test_sequence_002.c

+ *

+ * <h2>Description</h2>

+ * AES CFB.

+ *

+ * <h2>Test Cases</h2>

+ * - @subpage cry_test_002_001

+ * - @subpage cry_test_002_002

+ * .

+ */

+

+/****************************************************************************

+ * Shared code.

+ ****************************************************************************/

+

+#include <string.h>

+#include "ref_aes.h"

+static const CRYConfig config_Polling = {

+    TRANSFER_POLLING,

+    AES_CFBS_128,       //cfbs

+    0

+};

+

+static const CRYConfig config_DMA = {

+    TRANSFER_DMA,

+    AES_CFBS_128,       //cfbs

+    0

+};

+

+

+/****************************************************************************

+ * Test cases.

+ ****************************************************************************/

+

+/**

+ * @page cry_test_002_001 [2.1] AES CFB Polling

+ *

+ * <h2>Description</h2>

+ * testing AES CFB with various Keys.

+ *

+ * <h2>Test Steps</h2>

+ * - [2.1.1] loading the key with 16 byte size.

+ * - [2.1.2] Encrypt.

+ * - [2.1.3] Decrypt.

+ * - [2.1.4] loading the key with 24 byte size.

+ * - [2.1.5] Encrypt.

+ * - [2.1.6] Decrypt.

+ * - [2.1.7] loading the key with 32 byte size.

+ * - [2.1.8] Encrypt.

+ * - [2.1.9] Decrypt.

+ * .

+ */

+

+static void cry_test_002_001_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &config_Polling);

+

+

+}

+

+static void cry_test_002_001_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_002_001_execute(void) {

+    cryerror_t ret;

+

+  /* [2.1.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [2.1.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_128)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [2.1.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [2.1.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [2.1.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_192)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [2.1.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [2.1.7] loading the key with 32 byte size.*/

+  test_set_step(7);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [2.1.8] Encrypt.*/

+  test_set_step(8);

+  {

+    ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_256)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [2.1.9] Decrypt.*/

+  test_set_step(9);

+  {

+    ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_002_001 = {

+  "AES CFB Polling",

+  cry_test_002_001_setup,

+  cry_test_002_001_teardown,

+  cry_test_002_001_execute

+};

+

+/**

+ * @page cry_test_002_002 [2.2] AES CFB DMA

+ *

+ * <h2>Description</h2>

+ * testing AES CFB with various Keys.

+ *

+ * <h2>Test Steps</h2>

+ * - [2.2.1] loading the key with 16 byte size.

+ * - [2.2.2] Encrypt.

+ * - [2.2.3] Decrypt.

+ * - [2.2.4] loading the key with 24 byte size.

+ * - [2.2.5] Encrypt.

+ * - [2.2.6] Decrypt.

+ * - [2.2.7] loading the key with 32 byte size.

+ * - [2.2.8] Encrypt.

+ * - [2.2.9] Decrypt.

+ * .

+ */

+

+static void cry_test_002_002_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &config_DMA);

+

+

+}

+

+static void cry_test_002_002_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_002_002_execute(void) {

+    cryerror_t ret;

+

+  /* [2.2.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [2.2.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_128)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [2.2.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [2.2.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [2.2.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_192)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [2.2.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [2.2.7] loading the key with 32 byte size.*/

+  test_set_step(7);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [2.2.8] Encrypt.*/

+  test_set_step(8);

+  {

+    ret = cryEncryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CFB_256)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [2.2.9] Decrypt.*/

+  test_set_step(9);

+  {

+    ret = cryDecryptAES_CFB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_002_002 = {

+  "AES CFB DMA",

+  cry_test_002_002_setup,

+  cry_test_002_002_teardown,

+  cry_test_002_002_execute

+};

+

+/****************************************************************************

+ * Exported data.

+ ****************************************************************************/

+

+/**

+ * @brief   Array of test cases.

+ */

+const testcase_t * const cry_test_sequence_002_array[] = {

+  &cry_test_002_001,

+  &cry_test_002_002,

+  NULL

+};

+

+/**

+ * @brief   AES CFB.

+ */

+const testsequence_t cry_test_sequence_002 = {

+  "AES CFB",

+  cry_test_sequence_002_array

+};

diff --git a/test/crypto/source/test/cry_test_sequence_002.h b/test/crypto/source/test/cry_test_sequence_002.h
new file mode 100644
index 000000000..eb5966111
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_002.h
@@ -0,0 +1,27 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+/**

+ * @file    cry_test_sequence_002.h

+ * @brief   Test Sequence 002 header.

+ */

+

+#ifndef CRY_TEST_SEQUENCE_002_H

+#define CRY_TEST_SEQUENCE_002_H

+

+extern const testsequence_t cry_test_sequence_002;

+

+#endif /* CRY_TEST_SEQUENCE_002_H */

diff --git a/test/crypto/source/test/cry_test_sequence_003.c b/test/crypto/source/test/cry_test_sequence_003.c
new file mode 100644
index 000000000..7ef920ef2
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_003.c
@@ -0,0 +1,393 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+#include "hal.h"

+#include "cry_test_root.h"

+

+/**

+ * @file    cry_test_sequence_003.c

+ * @brief   Test Sequence 003 code.

+ *

+ * @page cry_test_sequence_003 [3] AES CBC

+ *

+ * File: @ref cry_test_sequence_003.c

+ *

+ * <h2>Description</h2>

+ * AES CBC.

+ *

+ * <h2>Test Cases</h2>

+ * - @subpage cry_test_003_001

+ * - @subpage cry_test_003_002

+ * .

+ */

+

+/****************************************************************************

+ * Shared code.

+ ****************************************************************************/

+

+#include <string.h>

+#include "ref_aes.h"

+static const CRYConfig config_Polling = {

+    TRANSFER_POLLING,

+    AES_CFBS_128,       //cfbs

+    0

+};

+

+static const CRYConfig config_DMA = {

+    TRANSFER_DMA,

+    AES_CFBS_128,       //cfbs

+    0

+};

+

+

+/****************************************************************************

+ * Test cases.

+ ****************************************************************************/

+

+/**

+ * @page cry_test_003_001 [3.1] AES CBC Polling

+ *

+ * <h2>Description</h2>

+ * testing AES CBC with various Keys.

+ *

+ * <h2>Test Steps</h2>

+ * - [3.1.1] loading the key with 16 byte size.

+ * - [3.1.2] Encrypt.

+ * - [3.1.3] Decrypt.

+ * - [3.1.4] loading the key with 24 byte size.

+ * - [3.1.5] Encrypt.

+ * - [3.1.6] Decrypt.

+ * - [3.1.7] loading the key with 32 byte size.

+ * - [3.1.8] Encrypt.

+ * - [3.1.9] Decrypt.

+ * .

+ */

+

+static void cry_test_003_001_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &config_Polling);

+

+

+}

+

+static void cry_test_003_001_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_003_001_execute(void) {

+    cryerror_t ret;

+

+  /* [3.1.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [3.1.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_128)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [3.1.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [3.1.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [3.1.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_192)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [3.1.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [3.1.7] loading the key with 32 byte size.*/

+  test_set_step(7);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [3.1.8] Encrypt.*/

+  test_set_step(8);

+  {

+    ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_256)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [3.1.9] Decrypt.*/

+  test_set_step(9);

+  {

+    ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_003_001 = {

+  "AES CBC Polling",

+  cry_test_003_001_setup,

+  cry_test_003_001_teardown,

+  cry_test_003_001_execute

+};

+

+/**

+ * @page cry_test_003_002 [3.2] AES CBC DMA

+ *

+ * <h2>Description</h2>

+ * testing AES CBC with various Keys.

+ *

+ * <h2>Test Steps</h2>

+ * - [3.2.1] loading the key with 16 byte size.

+ * - [3.2.2] Encrypt.

+ * - [3.2.3] Decrypt.

+ * - [3.2.4] loading the key with 24 byte size.

+ * - [3.2.5] Encrypt.

+ * - [3.2.6] Decrypt.

+ * - [3.2.7] loading the key with 32 byte size.

+ * - [3.2.8] Encrypt.

+ * - [3.2.9] Decrypt.

+ * .

+ */

+

+static void cry_test_003_002_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &config_DMA);

+

+

+}

+

+static void cry_test_003_002_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_003_002_execute(void) {

+    cryerror_t ret;

+

+  /* [3.2.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [3.2.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_128)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [3.2.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [3.2.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [3.2.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_192)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [3.2.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [3.2.7] loading the key with 32 byte size.*/

+  test_set_step(7);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,32, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [3.2.8] Encrypt.*/

+  test_set_step(8);

+  {

+    ret = cryEncryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refAES_CBC_256)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [3.2.9] Decrypt.*/

+  test_set_step(9);

+  {

+    ret = cryDecryptAES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_003_002 = {

+  "AES CBC DMA",

+  cry_test_003_002_setup,

+  cry_test_003_002_teardown,

+  cry_test_003_002_execute

+};

+

+/****************************************************************************

+ * Exported data.

+ ****************************************************************************/

+

+/**

+ * @brief   Array of test cases.

+ */

+const testcase_t * const cry_test_sequence_003_array[] = {

+  &cry_test_003_001,

+  &cry_test_003_002,

+  NULL

+};

+

+/**

+ * @brief   AES CBC.

+ */

+const testsequence_t cry_test_sequence_003 = {

+  "AES CBC",

+  cry_test_sequence_003_array

+};

diff --git a/test/crypto/source/test/cry_test_sequence_003.h b/test/crypto/source/test/cry_test_sequence_003.h
new file mode 100644
index 000000000..46bb52fc9
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_003.h
@@ -0,0 +1,27 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+/**

+ * @file    cry_test_sequence_003.h

+ * @brief   Test Sequence 003 header.

+ */

+

+#ifndef CRY_TEST_SEQUENCE_003_H

+#define CRY_TEST_SEQUENCE_003_H

+

+extern const testsequence_t cry_test_sequence_003;

+

+#endif /* CRY_TEST_SEQUENCE_003_H */

diff --git a/test/crypto/source/test/cry_test_sequence_004.c b/test/crypto/source/test/cry_test_sequence_004.c
new file mode 100644
index 000000000..2b41f2b91
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_004.c
@@ -0,0 +1,633 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+#include "hal.h"

+#include "cry_test_root.h"

+

+/**

+ * @file    cry_test_sequence_004.c

+ * @brief   Test Sequence 004 code.

+ *

+ * @page cry_test_sequence_004 [4] (T)DES

+ *

+ * File: @ref cry_test_sequence_004.c

+ *

+ * <h2>Description</h2>

+ * (T)DES testing.

+ *

+ * <h2>Test Cases</h2>

+ * - @subpage cry_test_004_001

+ * - @subpage cry_test_004_002

+ * - @subpage cry_test_004_003

+ * - @subpage cry_test_004_004

+ * - @subpage cry_test_004_005

+ * .

+ */

+

+/****************************************************************************

+ * Shared code.

+ ****************************************************************************/

+

+#include <string.h>

+#include "ref_des.h"

+static const CRYConfig configDES_Polling=

+{

+		TRANSFER_POLLING,

+		0,

+		TDES_ALGO_SINGLE

+};

+static const CRYConfig configTDES_Polling=

+{

+		TRANSFER_POLLING,

+		0,

+		TDES_ALGO_TRIPLE

+};

+

+static const CRYConfig configTDES_DMA=

+{

+		TRANSFER_DMA,

+		0,

+		TDES_ALGO_TRIPLE

+};

+

+

+

+/****************************************************************************

+ * Test cases.

+ ****************************************************************************/

+

+/**

+ * @page cry_test_004_001 [4.1] DES Polling

+ *

+ * <h2>Description</h2>

+ * testing DES in polled mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [4.1.1] loading the key with 8 byte size.

+ * - [4.1.2] Encrypt.

+ * - [4.1.3] Decrypt.

+ * .

+ */

+

+static void cry_test_004_001_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &configDES_Polling);

+

+

+}

+

+static void cry_test_004_001_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_004_001_execute(void) {

+    cryerror_t ret;

+

+  /* [4.1.1] loading the key with 8 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,8, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.1.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptDES(&CRYD1, 0, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(2);

+

+    for (int i = 0; i < 2; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refDES_ECB_8)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.1.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptDES(&CRYD1, 0, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(2);

+

+    for (int i = 0; i < 2; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_004_001 = {

+  "DES Polling",

+  cry_test_004_001_setup,

+  cry_test_004_001_teardown,

+  cry_test_004_001_execute

+};

+

+/**

+ * @page cry_test_004_002 [4.2] TDES CBC Polling

+ *

+ * <h2>Description</h2>

+ * testing TDES CBC in polled mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [4.2.1] loading the key with 16 byte size.

+ * - [4.2.2] Encrypt.

+ * - [4.2.3] Decrypt.

+ * - [4.2.4] loading the key with 24 byte size.

+ * - [4.2.5] Encrypt.

+ * - [4.2.6] Decrypt.

+ * .

+ */

+

+static void cry_test_004_002_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &configTDES_Polling);

+

+

+}

+

+static void cry_test_004_002_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_004_002_execute(void) {

+    cryerror_t ret;

+

+  /* [4.2.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.2.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_16)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.2.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [4.2.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.2.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_24)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.2.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_004_002 = {

+  "TDES CBC Polling",

+  cry_test_004_002_setup,

+  cry_test_004_002_teardown,

+  cry_test_004_002_execute

+};

+

+/**

+ * @page cry_test_004_003 [4.3] TDES ECB Polling

+ *

+ * <h2>Description</h2>

+ * testing TDES ECB in polling mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [4.3.1] loading the key with 16 byte size.

+ * - [4.3.2] Encrypt.

+ * - [4.3.3] Decrypt.

+ * - [4.3.4] loading the key with 24 byte size.

+ * - [4.3.5] Encrypt.

+ * - [4.3.6] Decrypt.

+ * .

+ */

+

+static void cry_test_004_003_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &configTDES_Polling);

+

+

+}

+

+static void cry_test_004_003_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_004_003_execute(void) {

+    cryerror_t ret;

+

+  /* [4.3.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.3.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_16)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.3.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [4.3.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.3.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_24)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.3.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_004_003 = {

+  "TDES ECB Polling",

+  cry_test_004_003_setup,

+  cry_test_004_003_teardown,

+  cry_test_004_003_execute

+};

+

+/**

+ * @page cry_test_004_004 [4.4] TDES CBC DMA

+ *

+ * <h2>Description</h2>

+ * testing TDES CBC in polled mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [4.4.1] loading the key with 16 byte size.

+ * - [4.4.2] Encrypt.

+ * - [4.4.3] Decrypt.

+ * - [4.4.4] loading the key with 24 byte size.

+ * - [4.4.5] Encrypt.

+ * - [4.4.6] Decrypt.

+ * .

+ */

+

+static void cry_test_004_004_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &configTDES_DMA);

+

+

+}

+

+static void cry_test_004_004_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_004_004_execute(void) {

+    cryerror_t ret;

+

+  /* [4.4.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.4.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_16)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.4.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [4.4.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.4.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_CBC_24)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.4.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptDES_CBC(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted,(uint8_t*)test_vectors);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_004_004 = {

+  "TDES CBC DMA",

+  cry_test_004_004_setup,

+  cry_test_004_004_teardown,

+  cry_test_004_004_execute

+};

+

+/**

+ * @page cry_test_004_005 [4.5] TDES ECB DMA

+ *

+ * <h2>Description</h2>

+ * testing TDES ECB in DMA mode.

+ *

+ * <h2>Test Steps</h2>

+ * - [4.5.1] loading the key with 16 byte size.

+ * - [4.5.2] Encrypt.

+ * - [4.5.3] Decrypt.

+ * - [4.5.4] loading the key with 24 byte size.

+ * - [4.5.5] Encrypt.

+ * - [4.5.6] Decrypt.

+ * .

+ */

+

+static void cry_test_004_005_setup(void) {

+  memcpy((char*) msg_clear, test_plain_data, TEST_DATA_BYTE_LEN);

+  memset(msg_encrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  memset(msg_decrypted, 0xff, TEST_MSG_DATA_BYTE_LEN);

+  cryStart(&CRYD1, &configTDES_DMA);

+

+

+}

+

+static void cry_test_004_005_teardown(void) {

+  cryStop(&CRYD1);

+}

+

+static void cry_test_004_005_execute(void) {

+    cryerror_t ret;

+

+  /* [4.5.1] loading the key with 16 byte size.*/

+  test_set_step(1);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,16, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.5.2] Encrypt.*/

+  test_set_step(2);

+  {

+    ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_16)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.5.3] Decrypt.*/

+  test_set_step(3);

+  {

+    ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+

+  /* [4.5.4] loading the key with 24 byte size.*/

+  test_set_step(4);

+  {

+    ret = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_des,24, (uint8_t *) test_keys);

+

+    test_assert(ret == CRY_NOERROR, "failed load transient key");

+  }

+

+  /* [4.5.5] Encrypt.*/

+  test_set_step(5);

+  {

+    ret = cryEncryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_clear, (uint8_t*) msg_encrypted);

+

+    test_assert(ret == CRY_NOERROR, "encrypt failed");

+

+    SHOW_ENCRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_encrypted[i] == ((uint32_t*) refTDES_ECB_24)[i], "encrypt mismatch");

+    }

+

+  }

+

+  /* [4.5.6] Decrypt.*/

+  test_set_step(6);

+  {

+    ret = cryDecryptDES_ECB(&CRYD1, 0,TEST_DATA_BYTE_LEN, (uint8_t*) msg_encrypted, (uint8_t*) msg_decrypted);

+

+    test_assert(ret == CRY_NOERROR, "decrypt failed");

+

+    SHOW_DECRYPDATA(TEST_DATA_WORD_LEN);

+

+    for (int i = 0; i < TEST_DATA_WORD_LEN; i++) {

+      test_assert(msg_decrypted[i] == msg_clear[i], "decrypt mismatch");

+    }

+

+  }

+}

+

+static const testcase_t cry_test_004_005 = {

+  "TDES ECB DMA",

+  cry_test_004_005_setup,

+  cry_test_004_005_teardown,

+  cry_test_004_005_execute

+};

+

+/****************************************************************************

+ * Exported data.

+ ****************************************************************************/

+

+/**

+ * @brief   Array of test cases.

+ */

+const testcase_t * const cry_test_sequence_004_array[] = {

+  &cry_test_004_001,

+  &cry_test_004_002,

+  &cry_test_004_003,

+  &cry_test_004_004,

+  &cry_test_004_005,

+  NULL

+};

+

+/**

+ * @brief   (T)DES.

+ */

+const testsequence_t cry_test_sequence_004 = {

+  "(T)DES",

+  cry_test_sequence_004_array

+};

diff --git a/test/crypto/source/test/cry_test_sequence_004.h b/test/crypto/source/test/cry_test_sequence_004.h
new file mode 100644
index 000000000..b351fd35d
--- /dev/null
+++ b/test/crypto/source/test/cry_test_sequence_004.h
@@ -0,0 +1,27 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+/**

+ * @file    cry_test_sequence_004.h

+ * @brief   Test Sequence 004 header.

+ */

+

+#ifndef CRY_TEST_SEQUENCE_004_H

+#define CRY_TEST_SEQUENCE_004_H

+

+extern const testsequence_t cry_test_sequence_004;

+

+#endif /* CRY_TEST_SEQUENCE_004_H */

diff --git a/test/crypto/source/testref/ref_aes.c b/test/crypto/source/testref/ref_aes.c
new file mode 100644
index 000000000..11c6ef480
--- /dev/null
+++ b/test/crypto/source/testref/ref_aes.c
@@ -0,0 +1,822 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+#include "hal.h"

+

+const uint8_t refAES_ECB_128[]={

+0x65,0x86,0x9F,0x20,0x63,0x89,0x1C,0x2F,0x20,0x5D,

+0x94,0x7F,0x55,0x67,0x58,0xFF,0xE9,0xFE,0x4F,0xD7,

+0x93,0x03,0x43,0xDD,0xD0,0x7E,0xA3,0x37,0x58,0x83,

+0x22,0xA2,0x2D,0x61,0xA0,0x41,0x57,0x31,0x65,0x0F,

+0x7A,0x08,0x8F,0xD8,0x9C,0xA3,0xAB,0xC3,0x8E,0x6E,

+0x16,0x11,0xED,0x0C,0xE4,0xA8,0x6C,0x86,0xBB,0x99,

+0x3F,0x79,0x0A,0xAC,0x9F,0xD6,0xFC,0xCC,0xD9,0x71,

+0x36,0x46,0x6F,0xFA,0xD7,0x61,0xCE,0x1F,0xF0,0x9C,

+0xE8,0xE8,0x18,0x39,0x47,0x74,0x2C,0xCA,0x5A,0xDA,

+0x5A,0x60,0xD3,0xD7,0x22,0xD5,0x3E,0x6A,0xD7,0x28,

+0x59,0xF6,0x1C,0x3D,0x6E,0x02,0x06,0x28,0xE0,0x17,

+0x7B,0x1F,0xC2,0xFD,0xE5,0x7C,0x11,0xE7,0x3D,0xC2,

+0x82,0xC9,0xBB,0x62,0xA8,0xCB,0xF0,0x9A,0x9A,0x9E,

+0x75,0x54,0x49,0xEE,0x97,0x66,0x66,0x00,0x79,0xEC,

+0x9E,0xBF,0x91,0x47,0xCE,0x10,0xC3,0x78,0x2B,0x3C,

+0xDA,0xFD,0x3D,0xBA,0xBE,0x51,0x60,0x46,0x6E,0xE3,

+0x87,0x70,0x9D,0x9F,0x9E,0x4C,0x12,0xC3,0xA2,0x91,

+0xEF,0xF5,0xAC,0xDE,0x8E,0x6C,0x5A,0x81,0xE3,0x42,

+0x87,0x83,0xFC,0x22,0x32,0xED,0x85,0x39,0xB0,0x32,

+0x49,0x77,0x49,0x9E,0xA1,0x8E,0x81,0x0B,0x2A,0x66,

+0xD8,0x68,0x57,0x2D,0xDC,0x71,0x0C,0x41,0xBE,0x19,

+0x2F,0x16,0x07,0x69,0x53,0xFF,0x63,0xE0,0xBB,0x2B,

+0x98,0xD8,0xA5,0x58,0xB0,0xFA,0x98,0xBB,0xB4,0x98,

+0x57,0x60,0xE1,0xD2,0x28,0x92,0x26,0xDD,0x81,0xC2,

+0xEE,0xD9,0xD5,0x2F,0x54,0x75,0xAA,0x58,0x7D,0x9D,

+0x7E,0x74,0x66,0xC1,0x43,0xD9,0x00,0x53,0xA4,0x8D,

+0xFD,0xF0,0xEC,0x07,0xFB,0xAA,0x2C,0x9B,0x7B,0x09,

+0x99,0x06,0x51,0xE2,0x68,0xAB,0xDF,0x8D,0x46,0x2D,

+0x7D,0xCB,0x87,0x2A,0x3F,0x62,0x82,0x6D,0xAF,0xE6,

+0xBB,0xAE,0x28,0x56,0x58,0x46,0x45,0xC4,0x51,0x61,

+0x2E,0x52,0x21,0x20,0x7B,0xEF,0x8D,0x4A,0x7B,0xF9,

+0x72,0xE7,0x3C,0x88,0x72,0x88,0xD4,0x87,0x90,0xE1,

+0xD8,0xB0,0x33,0x6C,0x57,0xB7,0xD5,0x6E,0x2B,0x37,

+0xCC,0x42,0xB0,0xAC,0xBB,0xED,0xB3,0x3D,0xD0,0xF5,

+0xF4,0xF3,0x5E,0x17,0x66,0xE6,0x2D,0xF2,0x0D,0x89,

+0x48,0xA1,0x10,0x3E,0xD2,0x92,0x0D,0x3C,0xAE,0x4E,

+0x78,0xDD,0x6E,0x38,0x6E,0x8B,0x2A,0x80,0x5B,0x5A,

+0x53,0x74,0x2B,0x55,0xD8,0x62,0xE9,0x00,0x98,0x60,

+0x61,0x70,0x0E,0x2F,0x41,0x92,0xD5,0x5D,0xBD,0x94,

+0x16,0x16,0x37,0x3C,0xE1,0x30,0x19,0xAF,0x4A,0xDD,

+0x05,0xD7,0x67,0x96,0x24,0xE7,0x8E,0xBD,0x11,0x73,

+0x85,0x42,0xD4,0x79,0xB2,0xA9,0xD3,0x4A,0x42,0x53,

+0x76,0x1D,0x77,0xDB,0x35,0xE0,0x24,0xEA,0x8D,0xAA,

+0x17,0x8F,0x4D,0xC7,0x34,0xF9,0xA5,0x8D,0x7A,0xF3,

+0x94,0x67,0xC7,0xF0,0x2B,0x76,0x20,0xFA,0xAD,0xF2,

+0x20,0x4C,0xAC,0xEC,0x74,0x6C,0xE1,0x06,0x2D,0x95,

+0xAC,0xD5,0x16,0xEE,0x4E,0x32,0xF2,0x3E,0x5B,0x1C,

+0x1B,0x2D,0xF6,0x6F,0x16,0x1E,0xAA,0x86,0x95,0xA4,

+0x7B,0xA4,0xC1,0xDC,0xD6,0xF4,0x4F,0xDB,0xCB,0x9F,

+0xC6,0x25,0x52,0xBA,0x64,0xCE,0x4E,0x18,0xB0,0xE3,

+0x26,0xCE,0x56,0x0A,0x18,0x49,0x50,0x77,0xB1,0x54,

+0xC9,0xA0,0x4E,0x96,0xBA,0x8E,0x0D,0xBC,0x60,0x27,

+0x0F,0xD9,0x45,0x34,0x94,0x40,0x3C,0x11,0xB1,0x62,

+0x40,0x7A,0xDF,0x94,0x6E,0x8A,0xD9,0x52,0xE1,0x01,

+0x1D,0x05,0xF8,0xB0,0xE0,0x5D,0x8A,0xD7,0x4C,0x8D,

+0x27,0x8E,0xDB,0xB3,0x55,0x68,0x35,0x8D,0xF0,0xD5,

+0x2B,0x0B,0xEC,0x04,0x8E,0xAF,0x98,0x4A,0xD4,0xCA,

+0x88,0xF9,0xB5,0x1D,0xF3,0x20,0xB2,0x71,0x80,0x3F,

+0xDB,0x5D,0x0E,0x2A,0xA2,0xB2,0x75,0x21,0x33,0x74,

+0x72,0x2E,0xA6,0x2F,0xC8,0xB0,0x68,0x99,0xB9,0xA6,

+0x3E,0xA5,0x13,0xF7,0x3F,0xED,0xC5,0x0B,0xD1,0xCB,

+0xAC,0x8B,0x83,0xFF,0x50,0x5E,0xBD,0x60,0x09,0x40,

+0xA5,0xE0,0x99,0x1D,0xC8,0x9B,0x2F,0x6F,0x1A,0x5A,

+0x9D,0x90,0x62,0xBB,0x61,0xBD,0x6E,0x3B,0xD9,0x13,

+

+};

+const uint8_t refAES_ECB_192[]={

+0x28,0xEA,0xD0,0xAB,0xC6,0x9F,0x53,0xAF,0xF1,0xB3,

+0xC4,0x7C,0xAD,0x1F,0x12,0x35,0x05,0x23,0x89,0x52,

+0x06,0xA3,0x4C,0x0A,0xCC,0x3E,0x0D,0xE3,0xCD,0x93,

+0xC7,0x2D,0xFD,0x79,0x4B,0x5F,0xAC,0x7E,0xD5,0x9F,

+0xE7,0x6D,0x74,0x35,0x43,0xD7,0xB0,0x28,0x69,0x3E,

+0xF6,0xA0,0xCE,0xA8,0x66,0xBA,0x5A,0xDE,0x86,0xCE,

+0x72,0x88,0x85,0xA8,0x01,0xB4,0x9E,0xC3,0xCA,0xCA,

+0xEA,0xD8,0x60,0x8E,0x0A,0x46,0x63,0x8E,0x59,0xFA,

+0xAE,0xE0,0xC7,0xCC,0x8C,0xB3,0x63,0x26,0xB5,0xFC,

+0xF5,0xF9,0x06,0x93,0x91,0xF4,0x4E,0x25,0xB6,0x0E,

+0xA4,0x82,0xC2,0xED,0x86,0xBB,0xB5,0x96,0x85,0x6B,

+0xFA,0xA9,0xF0,0xFF,0x85,0x16,0xA9,0x48,0x83,0x9E,

+0x4F,0x8E,0x74,0x6B,0x57,0x3D,0x67,0x3E,0xDE,0xC8,

+0x4F,0x45,0xD0,0xBA,0x58,0x81,0x4C,0xAA,0x59,0x76,

+0xA8,0xC7,0xF1,0x9B,0x9A,0x7A,0x4C,0xBE,0xC2,0x82,

+0x63,0xFB,0xDA,0x57,0x4D,0x6A,0x79,0x94,0x3C,0x00,

+0xE2,0xA9,0xE0,0x2D,0x9F,0x73,0x9F,0xFE,0x09,0x3B,

+0x08,0xFC,0xFE,0x1E,0x4F,0x5F,0xD6,0x11,0x6C,0xAD,

+0xF8,0x78,0x3E,0x2C,0xB6,0x80,0xD9,0x6D,0x91,0xC1,

+0x92,0xAB,0xA2,0x63,0xBF,0x0F,0x19,0xC0,0xBF,0x9B,

+0xF0,0x73,0xB2,0x19,0x3C,0xF1,0x06,0x1A,0x26,0x3C,

+0x36,0xC0,0x2D,0x86,0x08,0x3A,0x5F,0xD7,0x81,0xD3,

+0xCD,0xA1,0xF6,0x33,0xD4,0x65,0xD2,0xDC,0x18,0x80,

+0x89,0xAC,0x4C,0xAA,0x7C,0x0D,0x16,0xCF,0xE9,0xDA,

+0x4D,0xCF,0x20,0x6D,0x1D,0x6A,0x71,0x62,0xB8,0x74,

+0x08,0x5D,0x77,0xBE,0x25,0x5F,0x91,0x51,0xA7,0x99,

+0xB6,0xE9,0x3C,0x53,0xCD,0x21,0x61,0xE0,0x8B,0xC6,

+0xCF,0xB6,0x33,0xEB,0xF4,0x45,0xBC,0x18,0x04,0x02,

+0x00,0xC8,0x86,0xE7,0x30,0x3C,0xC6,0xBA,0x4D,0xE0,

+0x5A,0x3D,0xB5,0xD8,0x9A,0x97,0xF4,0xA7,0x4F,0x07,

+0x4A,0x2C,0x00,0x01,0xEB,0x58,0x91,0x8D,0x71,0xB3,

+0x68,0xEC,0xEA,0xD0,0x59,0xBE,0x4F,0x99,0xD7,0x36,

+0x2E,0x60,0xE4,0x9F,0x14,0x71,0x74,0x94,0x00,0x34,

+0xCC,0xD0,0x3F,0x4D,0xDC,0xC7,0xCD,0xF5,0x95,0x94,

+0xA2,0x6B,0x71,0x7F,0x3E,0xB5,0xC9,0x70,0x0D,0x33,

+0x98,0x8D,0x7B,0x62,0x21,0xB5,0xA3,0xC3,0xD5,0xF6,

+0x90,0x50,0x6B,0x55,0xB7,0x8B,0x78,0x4B,0x1C,0x27,

+0xE3,0x37,0x96,0x82,0x7B,0xCE,0xF9,0x2B,0xF2,0xC2,

+0x6E,0x89,0xE8,0x21,0x24,0xCB,0x58,0x53,0xAD,0x99,

+0xCA,0x21,0x0A,0x80,0xE8,0xDD,0x28,0xE4,0x08,0x50,

+0x06,0xCF,0xFF,0x59,0x28,0x7F,0xE6,0x53,0x4C,0x74,

+0xA1,0xE0,0x92,0xA2,0x58,0x83,0x05,0xEA,0xBD,0x8B,

+0x90,0xEC,0xBE,0x6F,0xFF,0xAF,0x74,0x60,0x0D,0x18,

+0xBF,0xB5,0x68,0x18,0xDA,0xD5,0x20,0x85,0xDC,0xCB,

+0xD0,0xC4,0x42,0x16,0xFE,0xE8,0x37,0x38,0x26,0xE4,

+0x28,0xD5,0x64,0x2C,0xDC,0x88,0x2D,0x0D,0x20,0x7E,

+0x82,0x48,0xB8,0x6B,0xD1,0x69,0xC5,0x2A,0xAB,0x3F,

+0xBA,0x3E,0xEC,0xDF,0xCC,0xB9,0x89,0x84,0x80,0x9E,

+0xC7,0xF6,0x36,0x06,0xD8,0xEA,0x8A,0x65,0x7E,0xFB,

+0x91,0xD5,0x13,0x90,0xB1,0x21,0x70,0x15,0x39,0xDF,

+0x1C,0x9C,0xEB,0x98,0x3D,0x01,0xA8,0x7B,0x28,0x7C,

+0x6A,0x9E,0x40,0xB7,0xFA,0xE2,0xBE,0xEC,0x0D,0x9F,

+0x53,0x10,0xAB,0x60,0x10,0x6F,0xC1,0x54,0x7A,0xAC,

+0x0A,0x6A,0x91,0xE5,0xB6,0x6E,0x2D,0xF2,0x99,0x2B,

+0xB5,0xA1,0xE3,0x2D,0x89,0x28,0x6E,0xC3,0xE7,0x0C,

+0x28,0x6C,0xEF,0x42,0x8F,0xBC,0xAC,0xFA,0xA5,0x7C,

+0xEB,0x4B,0x14,0xD9,0xF6,0x0F,0x9C,0x1E,0x21,0xB4,

+0x82,0x9A,0x3E,0x98,0x0C,0xE2,0xCC,0xCB,0xE9,0xF0,

+0xF4,0x45,0x0D,0xDD,0x50,0x16,0x91,0xDB,0xBD,0xA7,

+0xE3,0x81,0x47,0x33,0x63,0x30,0xB5,0x4B,0xD8,0xB1,

+0xF6,0x54,0xE0,0xB5,0x43,0x06,0xAB,0x34,0x1E,0x12,

+0xCC,0x68,0xFF,0xAF,0x59,0xDF,0x65,0xB1,0x7F,0x59,

+0x5D,0x74,0xAE,0x93,0xB3,0x79,0xE6,0xA0,0xD6,0xE6,

+0x67,0x7E,0x6D,0x44,0x87,0x8B,0xB1,0x12,0xA1,0x0F,

+

+};

+const uint8_t refAES_ECB_256[]={

+0xC5,0x1C,0x71,0x03,0xC3,0x2E,0x0A,0xF7,0xB7,0xF9,

+0xEC,0xF2,0x47,0xA8,0xE5,0xE2,0xA0,0x43,0x78,0xF4,

+0xB7,0x56,0xD8,0x14,0x13,0x60,0x30,0xFC,0xB2,0xF0,

+0x22,0x4C,0xB6,0x5B,0x7E,0xB2,0x20,0x28,0x4E,0x46,

+0x26,0x8D,0xD9,0x86,0x38,0x0C,0x71,0x8F,0x4E,0xAD,

+0xC9,0xC9,0x70,0x74,0x5B,0xA9,0x10,0xBC,0xA8,0xBC,

+0x09,0xEF,0xBA,0x65,0x2A,0xAC,0xFB,0x60,0xD1,0xA1,

+0x65,0x0D,0x91,0xD0,0x43,0x73,0xD8,0xF9,0x73,0x6E,

+0x2E,0x0F,0x7D,0x93,0xB2,0x34,0x74,0x31,0x27,0x02,

+0x6B,0x61,0xE7,0x8F,0xD8,0x6B,0x13,0xC9,0xC8,0x9D,

+0xF7,0x88,0xBC,0x88,0x79,0x51,0x5E,0x92,0x43,0x83,

+0xE6,0x3C,0x55,0x8E,0xB2,0x70,0x42,0x36,0x78,0xBF,

+0x61,0x6D,0xB7,0x96,0xFC,0xEA,0x55,0xEB,0x66,0x0F,

+0xFB,0xAC,0x24,0xB7,0x14,0x2D,0x56,0x6D,0xE6,0x88,

+0x1F,0x9F,0xF7,0xAF,0x7D,0x57,0x0A,0x00,0x54,0x0E,

+0x5B,0xA8,0x0D,0xC3,0x9E,0xFC,0x21,0x8E,0x6E,0xDD,

+0x19,0xA3,0xAA,0xBC,0x92,0xAB,0x10,0xA5,0x0E,0x9D,

+0xC7,0x31,0x66,0xDE,0xA9,0xDC,0x35,0xEF,0x34,0x23,

+0x03,0x3C,0xBB,0x44,0xD4,0x14,0x0D,0xD3,0x0C,0xCE,

+0x4F,0x91,0xAE,0x46,0x13,0x0D,0x55,0xF2,0x2E,0xBC,

+0xDD,0xAC,0x83,0xB2,0x8A,0x19,0xE1,0x3E,0xC0,0x8E,

+0x9F,0x50,0x92,0x8A,0x6C,0xE6,0x4A,0x79,0xBB,0x80,

+0xCA,0x2D,0x01,0x48,0x30,0x95,0xE2,0xFA,0x2B,0x2B,

+0x67,0x60,0x2B,0x13,0x03,0xF5,0x1E,0x74,0x76,0xA9,

+0x9C,0x04,0x56,0x2B,0xEF,0xFC,0xFD,0xEC,0xD5,0x8A,

+0xE1,0x3D,0x3D,0x70,0x2A,0x08,0x77,0x0B,0x3D,0xD2,

+0x33,0x1D,0xE7,0xF8,0x8C,0x41,0xB0,0x62,0x6D,0x01,

+0xC0,0xD3,0xA8,0x4E,0x8C,0xAA,0xA0,0xDC,0x91,0xAC,

+0x33,0xE2,0x55,0x6C,0xC4,0xE2,0x4E,0xCF,0xE4,0x53,

+0xCA,0xA6,0x18,0x8B,0xA6,0x3A,0xAE,0x7A,0xAE,0x73,

+0xA5,0x98,0x9A,0x85,0xD6,0x89,0xA6,0x34,0x1C,0x9A,

+0x69,0xE2,0x89,0x64,0x9D,0xEE,0x13,0xE3,0x9D,0x59,

+0x91,0xFE,0x3C,0x97,0xE6,0xE9,0x1A,0xF4,0x2E,0xAC,

+0xE1,0x3D,0xC7,0xC4,0x68,0xED,0xF4,0xDB,0x6D,0xFC,

+0xD0,0xB1,0x4D,0x76,0xA4,0x13,0x68,0x9E,0x0E,0x51,

+0x8A,0x71,0x61,0xF9,0x8C,0x39,0xEF,0x0E,0x1F,0x19,

+0xA4,0x20,0xBC,0xCC,0x19,0xAF,0x80,0x6F,0x88,0x93,

+0x2A,0xF7,0x50,0x37,0xF1,0x83,0x90,0xEE,0xC6,0x63,

+0x31,0x1A,0x1B,0xD2,0x53,0x85,0x77,0x22,0x44,0xB7,

+0x75,0x55,0x57,0xBB,0xA7,0xF4,0xC9,0x8B,0x0E,0xC8,

+0xCB,0xB9,0x62,0x87,0xCF,0x1E,0x60,0x5E,0x53,0x64,

+0x29,0xC9,0x7D,0xA1,0x4A,0x9E,0xDD,0x38,0xD9,0xB6,

+0xE3,0xF7,0x9B,0xC6,0xF7,0x4C,0xDB,0xE9,0x92,0x08,

+0x3E,0xE2,0x45,0xB9,0xF3,0x14,0x44,0xD7,0x78,0xA0,

+0x78,0x56,0x2A,0xC8,0x83,0x64,0xAF,0xF1,0xD0,0x53,

+0x0B,0xFA,0x2C,0xDA,0x0B,0xE5,0xE0,0xD2,0x70,0xA2,

+0x5A,0x12,0x48,0xF1,0xD7,0xF3,0x00,0x4E,0xBD,0x16,

+0xB3,0x1F,0x9A,0x2C,0x2A,0xF2,0xF7,0xAB,0x84,0x2C,

+0x96,0x00,0x8F,0x0D,0x9A,0x5F,0xFA,0x56,0x5D,0x7A,

+0x0B,0xBC,0xC1,0xFE,0x14,0x2F,0xF4,0x9A,0xEB,0xAF,

+0x78,0x29,0x34,0x16,0x93,0xE7,0x57,0xCA,0x05,0xF2,

+0x46,0x77,0x03,0x90,0x46,0xF0,0x65,0x05,0x9E,0xCF,

+0xD0,0xCE,0xC5,0xE0,0x43,0xE0,0x9F,0x8B,0xA0,0x9F,

+0x44,0x0B,0x5F,0xD5,0x19,0x1E,0x5A,0xCF,0x26,0xD4,

+0x2D,0x67,0xC2,0x8F,0x6F,0xE5,0x29,0xDA,0xF1,0x26,

+0x5B,0x87,0xA0,0x4C,0xA1,0xB6,0x27,0x7A,0x70,0x07,

+0xBE,0x8E,0xCD,0x8F,0x4E,0x0E,0xBE,0xCB,0xF3,0x43,

+0x79,0xB8,0xFB,0x06,0x41,0x96,0xA0,0xE9,0xDC,0x78,

+0x23,0x26,0x79,0x71,0x26,0x4E,0x08,0x03,0x16,0x25,

+0xEE,0xF6,0xF9,0x61,0xDF,0x73,0x13,0xA5,0xF6,0x04,

+0x5E,0x17,0x52,0x6D,0x17,0x3A,0x4A,0x88,0x95,0x7D,

+0x8F,0x44,0x38,0x38,0x06,0xD1,0xF8,0x8E,0x72,0x55,

+0x7A,0xB5,0x3B,0xAA,0xBB,0x00,0x2D,0x6F,0xFA,0x6B,

+0x1D,0x90,0x2B,0x02,0xF4,0xBB,0xDE,0x6C,0xC7,0x9F,

+

+};

+const uint8_t refAES_CBC_128[]={

+0x9E,0xB2,0x93,0xCF,0xA3,0xF3,0x9F,0x22,0xAB,0x7D,

+0xBB,0x11,0xF8,0xD5,0xD0,0xE7,0x76,0x6F,0xCD,0xF5,

+0x24,0xF2,0xEB,0x75,0x01,0x33,0x66,0xD0,0x8B,0x38,

+0xB1,0x06,0xDA,0xD7,0xFA,0x4D,0x99,0x19,0x9F,0x8F,

+0xE7,0xDE,0x06,0xC8,0xE3,0x0E,0x52,0x42,0x37,0xCE,

+0x85,0x51,0xBA,0x01,0x6F,0x3F,0xB5,0x33,0xF5,0xF6,

+0x2A,0x87,0x04,0xB1,0x2C,0xB7,0x0A,0x0E,0x42,0x9F,

+0xCE,0xCA,0x09,0x21,0xB0,0xBD,0x09,0x82,0xEF,0x37,

+0xAF,0x93,0xE0,0xF4,0x4B,0x15,0x35,0xB5,0x80,0x52,

+0x0B,0xCA,0xA7,0x0C,0x66,0x85,0x6C,0x32,0xAF,0x2E,

+0x82,0xED,0x44,0xC0,0x0D,0xE1,0x73,0xE2,0xD4,0xEB,

+0xD9,0x08,0x64,0x09,0x55,0x00,0xB0,0xD8,0x5E,0x9E,

+0x72,0xCC,0x44,0xA7,0xBA,0x31,0xCB,0xC2,0xCA,0xB0,

+0x32,0x7C,0xEF,0xC1,0xE2,0x1A,0x68,0xC4,0x0C,0x5B,

+0x1C,0x63,0xBC,0xFF,0x47,0xC4,0x01,0xA8,0x7B,0x16,

+0x41,0xA0,0x43,0x87,0x06,0x0B,0x19,0x0C,0x72,0x4B,

+0xED,0xEA,0x5A,0x5E,0x0A,0x14,0xC9,0xB4,0xDF,0xEC,

+0x57,0x01,0x37,0x3D,0xCC,0x97,0x07,0x4C,0x48,0x64,

+0x78,0xAB,0x5B,0x23,0xBF,0xE4,0x5C,0xC2,0xB4,0x06,

+0xEC,0x75,0x18,0x56,0x70,0x6C,0xCF,0xC2,0x86,0x7F,

+0xD5,0xBB,0x32,0x8F,0x9E,0x63,0x45,0x7B,0xD8,0x87,

+0x1C,0x08,0xA4,0x51,0x6F,0x34,0x49,0x64,0xEB,0x16,

+0x0B,0x95,0xB6,0xCB,0x75,0x27,0x4B,0xE3,0x15,0x2D,

+0x9E,0x49,0xF1,0x09,0xAC,0xE0,0x70,0x34,0x59,0x6B,

+0xE8,0x01,0x13,0x65,0xA5,0x43,0x7E,0xD6,0xBD,0xE7,

+0x59,0x68,0x83,0x7F,0x85,0x56,0xAF,0x91,0x69,0xDE,

+0x2E,0x79,0x3F,0xA7,0x82,0x5B,0x91,0xA2,0x81,0x26,

+0xAC,0xEC,0xBF,0x25,0x8E,0x03,0x03,0x3E,0x38,0xC4,

+0xC6,0x7B,0x74,0xFD,0x9B,0x56,0x92,0xA1,0x01,0x8A,

+0xBE,0xB0,0xEE,0x76,0x80,0xC8,0x72,0xBF,0xCE,0xCE,

+0xE2,0xF6,0xF7,0xC6,0xE2,0x68,0x3E,0xA6,0x06,0x7A,

+0x7F,0xE8,0xF8,0xCA,0x15,0xA5,0xCA,0xC0,0x41,0x15,

+0x87,0xF8,0xC9,0xFE,0xBB,0x64,0xDC,0xF7,0x36,0x18,

+0x16,0xC6,0x30,0xCA,0xAA,0x47,0x9A,0xD0,0x0D,0x19,

+0xF6,0x95,0xE1,0x55,0x15,0x0A,0xCA,0xED,0xBF,0x01,

+0x22,0xEA,0x3F,0xF1,0x95,0x0F,0x21,0x18,0x3F,0xA6,

+0x6E,0xB2,0x3D,0x01,0x8F,0x3B,0x3B,0x5E,0x4E,0xFA,

+0xE1,0x76,0x50,0x3A,0x29,0xAE,0xB1,0x92,0x65,0x51,

+0x5E,0xA7,0x1B,0x08,0x06,0x6E,0x06,0x5F,0xFD,0x87,

+0xF8,0x23,0xE9,0xED,0x6E,0x38,0x6F,0x30,0x78,0x6E,

+0x8D,0xB6,0x7A,0x8F,0x40,0x37,0x18,0x0F,0xD1,0x7E,

+0xB7,0xF3,0x4E,0xFE,0x8F,0x0B,0x5A,0xC0,0x47,0xF7,

+0xB9,0xB7,0xAD,0xEC,0x87,0x3D,0xB1,0xE9,0x7F,0x11,

+0xCD,0x8F,0x08,0xE8,0x2A,0x9A,0x08,0xC4,0xE3,0xB2,

+0x9A,0xCB,0x9C,0xA9,0xCD,0x14,0xC6,0x9C,0xF1,0x92,

+0x49,0xC6,0xF2,0xC9,0xC0,0x43,0xF5,0xCE,0x38,0x82,

+0xD5,0x41,0x31,0x96,0xB7,0x27,0xC6,0x5C,0x15,0x0E,

+0x78,0x5E,0xEB,0xE1,0x89,0x1A,0x5C,0xC4,0xEE,0xF0,

+0x53,0xD6,0x60,0x90,0xC8,0xB3,0xE5,0x5D,0x5F,0xD0,

+0x52,0xCD,0xCA,0xC8,0xB9,0xA3,0x43,0x4E,0x6A,0xED,

+0xEE,0x03,0xC8,0x22,0xE0,0x11,0x15,0x53,0xB8,0x62,

+0x6B,0x0A,0x9F,0x90,0x4F,0xF6,0x6C,0x24,0xED,0xFB,

+0x0E,0xF0,0x1F,0x1F,0xAB,0x72,0xBD,0x54,0xCC,0xDF,

+0x8B,0x86,0x5C,0xC9,0xEF,0x41,0x1B,0xC6,0x67,0x57,

+0xA7,0xDD,0xF2,0x0D,0x1D,0x02,0xD7,0xF1,0x90,0xE3,

+0x3E,0xE4,0x9F,0xEA,0x6D,0x21,0x4D,0xCA,0x33,0xE0,

+0x09,0xB6,0xEB,0xC5,0xE8,0xF2,0x87,0x0D,0x40,0x7A,

+0xDC,0x98,0x28,0x0B,0xFF,0xD2,0x62,0x76,0xF0,0xDB,

+0x40,0x27,0xB0,0x60,0x05,0x27,0x27,0xF5,0xE5,0xD2,

+0xE0,0x4B,0x2D,0x1F,0x7B,0x79,0x8B,0xE4,0x4F,0xFD,

+0xC0,0x69,0xEB,0x87,0x8B,0xCB,0xCB,0xB8,0x8E,0x17,

+0x8B,0xF0,0x31,0x6B,0x5B,0x92,0x41,0xB5,0xA5,0x98,

+0xCF,0x2B,0x4C,0xC2,0x26,0x4D,0x90,0xE4,0x9B,0xD2,

+0xAB,0x5C,0x06,0x1F,0x38,0x36,0x35,0xB5,0x2F,0x9D,

+

+};

+const uint8_t refAES_CBC_192[]={

+0x62,0xD5,0x8D,0x83,0xA0,0xF5,0x6D,0x48,0xF5,0xD2,

+0x46,0x3C,0x31,0x96,0x88,0xFB,0x17,0x77,0x4B,0x59,

+0xBE,0x56,0xBE,0x27,0xB4,0x54,0x09,0xA0,0xF3,0x22,

+0x0C,0xAD,0x98,0x6E,0xB9,0xE5,0x73,0xDB,0x02,0xD1,

+0x9C,0x2B,0x24,0x1F,0x16,0x31,0xED,0xED,0x11,0xB4,

+0x7C,0x1E,0x5D,0xBA,0xFC,0xA8,0xC3,0xCC,0x22,0x0F,

+0xDF,0x3E,0x86,0xB3,0x98,0x40,0x82,0x80,0x84,0xFD,

+0xAB,0x84,0xF8,0x53,0x86,0x31,0x7E,0x85,0x2E,0x3F,

+0xE1,0xB7,0xAD,0x5D,0x7A,0x48,0x0D,0xF5,0x4F,0xDA,

+0x0A,0x52,0x1A,0x8D,0x9E,0x63,0xD2,0xA7,0xDA,0x0D,

+0x95,0xD7,0x85,0x00,0x11,0xDC,0xAA,0x07,0xBF,0x02,

+0x29,0xCB,0x96,0x8F,0x24,0x02,0x74,0x0E,0x6A,0xA6,

+0xDA,0x5C,0x8D,0xD0,0x4E,0x92,0xE5,0x63,0x84,0x1B,

+0x00,0xA5,0x54,0xE6,0x50,0x4C,0x6D,0x0E,0x10,0x93,

+0x75,0x31,0x26,0x64,0xD7,0x91,0x3E,0xE1,0xF1,0xA0,

+0xA5,0x3C,0xCD,0x1F,0x6A,0x9B,0x51,0xE2,0xA7,0xA1,

+0xFC,0x01,0xD9,0xA1,0xF0,0xE0,0xA6,0x38,0x79,0x74,

+0xC8,0x51,0xCE,0x6A,0xEC,0x7C,0xA8,0xC1,0xBA,0x2C,

+0x1F,0x94,0x32,0xF0,0x9A,0xBB,0x60,0x54,0xCE,0xEE,

+0xC2,0x95,0xA6,0x6C,0x99,0xE2,0xB7,0xCB,0xCA,0x43,

+0x23,0x5A,0xA3,0x16,0x9A,0xBA,0x33,0xBE,0x09,0x72,

+0xE5,0x7A,0x7F,0x57,0xB1,0xC5,0xC8,0xB6,0x83,0x37,

+0xEC,0x94,0xBB,0x39,0x12,0x5B,0x5E,0x36,0xA6,0xC5,

+0x9C,0x2B,0x32,0xE3,0x2B,0xCB,0x72,0x64,0x11,0x88,

+0x05,0x97,0x59,0x20,0xCB,0x34,0xC2,0x55,0x7B,0xE2,

+0x63,0x4C,0x05,0xCF,0x68,0x82,0x34,0x18,0x5A,0x1A,

+0x35,0xAC,0x3C,0xE7,0x43,0x06,0x68,0x9B,0xE9,0x4D,

+0x4C,0x8A,0xD9,0xCF,0xDD,0x76,0x68,0x12,0x52,0x97,

+0xE0,0x6A,0x27,0x51,0x5D,0x84,0x3F,0x61,0x56,0x12,

+0xE7,0x20,0xC0,0x80,0x61,0xD5,0x50,0x19,0x55,0x21,

+0x7B,0x71,0x4C,0xC1,0x27,0x5A,0x3C,0x05,0xCA,0xBF,

+0xFE,0xD8,0x84,0x70,0x63,0x71,0x59,0x8C,0xDC,0x01,

+0x8C,0x8D,0x16,0xB5,0x85,0xF6,0x7B,0xA9,0x26,0x9F,

+0xEA,0xAC,0xD6,0x3E,0x83,0xE9,0xE0,0x8C,0x06,0x00,

+0x7E,0x36,0x49,0x85,0xBE,0x82,0xDD,0x68,0x98,0x90,

+0x68,0xE4,0xDA,0x28,0x40,0xA9,0x71,0x83,0xEC,0xCC,

+0x10,0x4A,0xC3,0x51,0x99,0x16,0xC8,0x63,0xF1,0x45,

+0xF6,0xAD,0x8E,0xE9,0x2D,0xC0,0x20,0xA3,0x5F,0x9A,

+0xCD,0xD7,0xB2,0x2D,0xC5,0xF5,0x67,0x53,0xB0,0xE5,

+0xFB,0x51,0x8A,0x5D,0x75,0xE5,0x40,0xF4,0x5E,0xA5,

+0xA5,0x98,0x69,0x26,0xC5,0xFF,0x05,0xE7,0x3A,0x3D,

+0xB3,0x01,0xF6,0xF6,0xA8,0x21,0x9F,0xA4,0x67,0xB1,

+0xA2,0x4A,0x45,0x74,0x18,0xC5,0x5B,0x31,0xA4,0x9D,

+0x57,0x69,0xEF,0xCD,0xD7,0x81,0x4A,0xF8,0x3A,0xFF,

+0xBD,0x9E,0x5D,0xBC,0x08,0x84,0x50,0x8C,0x21,0x80,

+0x65,0x15,0xF4,0x50,0x94,0x65,0x8E,0xE9,0x6A,0xEE,

+0x63,0xF8,0x56,0x4C,0x89,0x16,0x3F,0x70,0x4C,0x57,

+0xF2,0x64,0xCB,0x86,0x5A,0x3E,0x84,0x52,0x7F,0xEA,

+0x67,0xE7,0x96,0xCB,0x3F,0x9F,0xFF,0xDB,0x59,0xE7,

+0x33,0xE9,0xCB,0x73,0xAB,0x80,0x90,0x4C,0xD8,0xCF,

+0x3C,0xE2,0xA1,0xCF,0xEA,0xBE,0x60,0xD7,0xA6,0x4C,

+0x9A,0x08,0x64,0x22,0x85,0xC4,0x06,0x8E,0x6B,0x44,

+0x10,0x8F,0xC2,0x9B,0xEE,0x4C,0x30,0xFB,0xC2,0x71,

+0x63,0x06,0x76,0xF0,0x79,0xE8,0xF0,0x70,0xDE,0x48,

+0xB8,0x8A,0x5D,0x41,0x2B,0x4A,0x0C,0x7F,0x8E,0xBF,

+0xAF,0x5F,0xB3,0x28,0xFD,0x01,0xCF,0xCE,0xBA,0xA7,

+0x1B,0x9A,0xBC,0xD0,0x62,0x5F,0xB6,0x63,0x5A,0xC6,

+0x74,0xE0,0xE4,0x20,0xCE,0x9B,0xC6,0xAA,0x0F,0x60,

+0xB1,0xD3,0x54,0x39,0x2E,0x42,0x68,0x46,0x6F,0xBE,

+0x1D,0x68,0xF4,0x28,0x66,0xDE,0xC3,0x81,0x03,0x81,

+0x18,0x77,0xAD,0xD2,0xEC,0x0D,0x91,0xD0,0x0F,0x35,

+0x29,0x79,0xA4,0xDE,0xD8,0xC5,0xBD,0x4D,0xEA,0xFC,

+0xAF,0x5D,0xA1,0x31,0x90,0xBA,0x92,0x1A,0x8F,0x93,

+0x94,0xFE,0x6E,0xC3,0xEB,0xEC,0x37,0x77,0x35,0x59,

+

+};

+const uint8_t refAES_CBC_256[]={

+0x0E,0x02,0x38,0x69,0x61,0x5C,0x16,0x1F,0xA8,0xE5,

+0x12,0x40,0x87,0xF7,0xAE,0xB2,0xCC,0xE5,0x54,0x0E,

+0xCC,0x12,0xCF,0x94,0x3E,0x92,0xE7,0x6C,0x9A,0x11,

+0x9E,0x76,0x71,0xC5,0xC0,0xE5,0x34,0xBB,0x6C,0x95,

+0xA7,0x63,0xD1,0x95,0x19,0x44,0xCB,0x85,0x17,0x92,

+0xB4,0x23,0x22,0x54,0xAB,0x76,0x1F,0xE4,0xB1,0x8E,

+0x1D,0xF2,0x19,0x21,0xA6,0x65,0xAA,0x14,0x60,0xAF,

+0xD9,0x11,0x6F,0x79,0xD1,0xCE,0x5E,0xAF,0x7D,0xE0,

+0x49,0x00,0x2C,0x17,0x97,0xA5,0x73,0x4E,0x21,0xB1,

+0xBB,0xF5,0x82,0xC9,0xF7,0xAA,0x19,0x4B,0x83,0xE3,

+0xA3,0xEF,0x31,0x4A,0xE6,0xB2,0x98,0x8F,0x8D,0xD3,

+0x01,0x56,0x4D,0x90,0x10,0x90,0x6B,0xBD,0x35,0x06,

+0x25,0x6D,0x03,0x9B,0xED,0xBC,0x78,0xA1,0x6E,0x73,

+0x79,0x25,0xAD,0x8A,0x56,0x2C,0x93,0xAC,0x1F,0x15,

+0xA0,0x70,0xD3,0xFA,0xA6,0x1D,0xE0,0x41,0x88,0x97,

+0xE2,0xBA,0x76,0x98,0x6A,0xBA,0x86,0xFE,0x1A,0x71,

+0x52,0x61,0xBB,0x80,0x7A,0x77,0xE2,0x7E,0x64,0xD5,

+0xEE,0xFC,0x33,0x9B,0x3E,0x53,0xB2,0x22,0xF8,0xD3,

+0x5A,0x65,0xC8,0x6F,0x3A,0xC0,0xFB,0xAF,0xD4,0xD9,

+0x29,0x92,0x30,0x3E,0xB1,0x35,0x7D,0x27,0x77,0xA4,

+0xF1,0x17,0x48,0xE6,0x5C,0x55,0x48,0xE6,0x2B,0x83,

+0x57,0x0E,0xDE,0xBA,0xCA,0x39,0x1C,0x6A,0x7C,0xBA,

+0x01,0x82,0xE1,0x2E,0xC7,0xB0,0xD1,0xBF,0xF1,0x1B,

+0xB8,0x3C,0x6E,0x02,0xA7,0xFF,0xC0,0x3E,0xEA,0xF9,

+0x50,0xA7,0xF9,0x1A,0xF7,0xDA,0x65,0x26,0xFF,0x37,

+0xCA,0x50,0x59,0x7A,0xA5,0x75,0x8E,0x79,0xFD,0xE6,

+0xA1,0x53,0x44,0x49,0xA9,0x5C,0x81,0x6A,0x7D,0x07,

+0x17,0xE5,0x12,0x3B,0xE3,0x80,0x95,0x76,0x6D,0x35,

+0xDD,0x42,0xBF,0xE7,0xD5,0xFF,0xB6,0x7F,0xEA,0x25,

+0x3E,0xCF,0x64,0x9E,0xA2,0x48,0xE8,0x65,0x4B,0x65,

+0x57,0xE4,0xD7,0x2A,0xC3,0x7B,0x48,0xA1,0xBE,0xFB,

+0x33,0x54,0xD8,0xA4,0x0D,0x16,0x08,0xCC,0xB3,0xC7,

+0x21,0xA8,0xD8,0xAE,0x60,0x29,0x2E,0xF5,0x8C,0xBD,

+0x6C,0x0F,0x04,0xDE,0x9D,0x52,0xA8,0xCD,0x90,0xF9,

+0x9D,0xC5,0xDE,0x63,0x1C,0xF7,0x25,0xF5,0xFA,0x3E,

+0xC8,0xFA,0x4D,0x5A,0x72,0x84,0xF7,0x86,0xF3,0xBA,

+0x4E,0x52,0x22,0x8B,0x3D,0x85,0xB3,0x04,0xEF,0x49,

+0x7E,0xB7,0x42,0x25,0x48,0xC9,0xF0,0x26,0xB7,0x87,

+0x57,0x84,0xFC,0x7C,0xA8,0xC1,0x08,0xC5,0xBD,0x0F,

+0x5B,0x59,0x62,0xCD,0xDC,0x48,0x4A,0x1D,0xFB,0x78,

+0x05,0x40,0x16,0x9C,0x7B,0xCF,0x50,0xF1,0xE5,0x16,

+0x24,0xD4,0xA2,0xBF,0xAC,0x6A,0x0F,0x45,0x22,0xDB,

+0x51,0x3A,0x65,0xA3,0x7C,0x2B,0x1C,0xAF,0x6F,0x85,

+0x8F,0xA3,0xD3,0xE4,0x80,0x6C,0x73,0xA5,0xDC,0xC9,

+0x9C,0x74,0x68,0xE6,0x17,0x1E,0x57,0x42,0xA9,0x57,

+0xE1,0xE0,0x03,0xF4,0xD3,0x10,0xC6,0xBF,0x4F,0x89,

+0xD1,0x6E,0xB2,0xBF,0xFB,0x43,0xCB,0x6B,0x96,0x80,

+0x44,0xF5,0x70,0x26,0xD1,0xFF,0x1C,0x74,0x04,0x4D,

+0x48,0x17,0xFB,0x37,0xA8,0x97,0x96,0x15,0xD0,0xC8,

+0x88,0xA6,0x5D,0x1B,0x34,0xCE,0xE9,0xA0,0xAD,0x34,

+0xE9,0x9A,0xF4,0xA2,0x24,0x71,0x06,0x52,0xA1,0xC8,

+0x16,0xCE,0xB2,0xE2,0xEC,0xAC,0x31,0x5F,0x93,0x64,

+0x8C,0x3E,0xF4,0xC5,0xED,0x62,0xD3,0xDD,0xB8,0xB6,

+0x2C,0x97,0xFC,0x11,0x19,0x91,0xBB,0xE5,0xB7,0xE7,

+0xE5,0xD2,0xDA,0x39,0xE1,0x5A,0x63,0x16,0xA0,0x46,

+0x1A,0xE5,0x79,0x78,0x78,0xAE,0x2E,0xB2,0xB3,0x97,

+0xF0,0xC6,0x87,0x0F,0x2F,0x39,0x46,0x2D,0x45,0xFE,

+0x34,0xD4,0xA9,0x9F,0x51,0xDA,0x95,0xD7,0x6E,0xCA,

+0x0C,0x25,0xD6,0x3D,0x50,0x6A,0x40,0x3E,0x48,0x40,

+0xC9,0xAD,0x80,0x47,0x93,0x33,0x32,0x8E,0xE6,0xD4,

+0xAF,0xAA,0xF4,0xBD,0x9F,0xA7,0xDE,0xBA,0x95,0x30,

+0x2B,0xE2,0xF0,0xFE,0xE4,0x90,0xB3,0x98,0x89,0x7E,

+0x68,0xA0,0x94,0x44,0x27,0xBF,0x08,0xC4,0x80,0x7D,

+0xB3,0xB3,0x64,0x30,0xE7,0x59,0x9D,0x98,0x3C,0xDC,

+

+};

+const uint8_t refAES_CTR_128[]={

+0xFF,0x50,0x83,0x66,0x68,0x80,0x52,0xE8,0xAE,0x43,

+0xC1,0xCC,0x8D,0x60,0x9C,0xF9,0x11,0xA6,0x1F,0x82,

+0xF1,0xD9,0xFF,0x23,0xAF,0x47,0xF1,0xCE,0x99,0xA1,

+0xDD,0xD2,0x82,0xAD,0x44,0x96,0x73,0xA1,0xB2,0x0B,

+0x2E,0x30,0x37,0x89,0x4C,0xEC,0x20,0x73,0x29,0xE0,

+0x5D,0xCD,0xAE,0x32,0x25,0xF3,0x14,0xB8,0xB3,0x98,

+0x55,0x44,0xE5,0x12,0x47,0xD1,0x82,0x37,0xDB,0x9A,

+0x1B,0x82,0x0A,0xF7,0x66,0xCA,0x4F,0xC0,0xB7,0xC9,

+0xC8,0xD6,0xC9,0x0E,0xAE,0xC3,0x69,0xDB,0x3D,0x56,

+0xC1,0x0E,0x74,0x54,0x1A,0xA1,0x79,0x90,0x1F,0xC4,

+0x10,0xA8,0xFA,0x0E,0x4C,0xD8,0xD1,0x15,0x0C,0x9D,

+0x88,0x1C,0xDE,0x6C,0x4D,0x31,0x1C,0xCA,0x06,0xFC,

+0xC4,0x0B,0x40,0xC7,0xEF,0x0F,0x7C,0x21,0x90,0xAE,

+0xB1,0x8F,0x1B,0xC9,0x7B,0xA6,0xF7,0xB9,0x66,0xFE,

+0xED,0x5C,0x6C,0x2B,0xD1,0x9A,0x76,0x89,0xEC,0xC5,

+0xE2,0x97,0x71,0x32,0x8D,0xE3,0xAE,0xF4,0x8B,0x4C,

+0x8E,0x6A,0xCC,0xB6,0xC9,0xAD,0xE2,0x59,0x82,0xEB,

+0x31,0xB2,0xA3,0xF7,0x61,0xC6,0xA9,0x00,0x82,0xA4,

+0x9E,0xF2,0x51,0xB0,0xDE,0x5A,0xF9,0x79,0x3D,0x17,

+0xFD,0xE1,0xA0,0xAD,0x22,0x72,0x41,0xC3,0xB6,0xD0,

+0xDC,0xE3,0xD5,0xDB,0xAA,0x83,0x77,0x80,0xD0,0x8B,

+0x14,0x3C,0xE4,0x66,0x7B,0xC4,0x15,0x80,0x19,0x9D,

+0x22,0x13,0xE6,0x82,0x14,0xDC,0x73,0xC4,0x1D,0xBC,

+0x79,0x7A,0x84,0x07,0xCD,0x46,0x96,0x0C,0x42,0xFA,

+0xB7,0xD2,0x5B,0xA3,0x0A,0x86,0xDD,0xAD,0x07,0xCE,

+0x11,0xE8,0xC6,0xAC,0xF3,0xDF,0xCB,0x80,0x7C,0x54,

+0x2B,0xE2,0x12,0xCC,0xFF,0xC0,0x20,0xFF,0x47,0x1F,

+0x6A,0x46,0x4A,0x3F,0xDD,0x65,0x15,0x5D,0xC8,0x3A,

+0xDD,0x39,0x8C,0xAB,0x2E,0x34,0x5D,0x17,0xF9,0x4C,

+0x92,0x6D,0xA7,0x8A,0x32,0x2B,0xD7,0xCF,0x17,0xDC,

+0x48,0xE5,0xAA,0x31,0x3E,0x8C,0xCC,0x29,0x7A,0x5A,

+0x60,0x92,0xC8,0x71,0x16,0x92,0xAE,0x1C,0x70,0x82,

+0xAA,0x04,0x42,0xAE,0x84,0x8B,0x88,0x15,0x10,0x80,

+0x14,0xFD,0xAD,0xBB,0x12,0x56,0x2E,0x8A,0xDF,0x9C,

+0xC0,0x99,0x94,0xE1,0xB4,0xA2,0x04,0x90,0xAE,0xDD,

+0xF9,0xE5,0xEF,0x5E,0x94,0x0B,0xAC,0x17,0x7C,0x59,

+0x4A,0x55,0xC4,0x67,0xCE,0xFB,0x59,0xB2,0xAA,0x5B,

+0xEE,0x07,0x59,0xC1,0xAB,0xB9,0xDE,0xB2,0xDE,0xFC,

+0x75,0xAF,0xC0,0x93,0xAF,0x6D,0xC2,0x5B,0x16,0xE5,

+0xAF,0x6B,0x27,0x91,0x9C,0x63,0x87,0x2D,0x3F,0xAD,

+0x3F,0x19,0x17,0xDF,0xE3,0x71,0x65,0x84,0xDA,0xFD,

+0x08,0x48,0x80,0x3F,0x9D,0x1E,0x4E,0x94,0xB4,0xA6,

+0xFE,0xEE,0x47,0x6F,0x94,0x8F,0xF6,0x45,0x0A,0x33,

+0x12,0xB2,0x76,0x86,0xBE,0x06,0xBA,0x78,0x0F,0x17,

+0xEB,0x3E,0xAB,0xAE,0x7A,0xB0,0x6E,0x5D,0xAB,0x84,

+0x67,0x9C,0x5E,0xDD,0xA9,0xDA,0x96,0x90,0x6E,0x84,

+0x06,0x14,0x5C,0xC4,0x26,0xD3,0x38,0xE7,0x2D,0xFE,

+0x1C,0xD2,0x9B,0x3C,0x34,0xA0,0xF5,0x24,0x2D,0x84,

+0x92,0x4C,0x10,0x2C,0xCD,0xDA,0xDC,0x80,0xC9,0x04,

+0x34,0xFD,0x3F,0x20,0x53,0xD0,0xE0,0xE6,0x33,0xD2,

+0x17,0x82,0xB1,0x6A,0x48,0xC0,0xA9,0xDC,0x55,0x18,

+0x68,0xBE,0xE5,0x3C,0x91,0xAD,0x28,0x76,0xAA,0xEB,

+0x85,0xE1,0x71,0xD3,0x69,0x25,0xA0,0xE4,0x75,0xDA,

+0x28,0x0B,0x60,0x26,0x4A,0x81,0x2E,0x50,0x3C,0x4E,

+0xD9,0xBB,0xD8,0xF9,0x11,0x3A,0xC0,0xBB,0xDA,0x41,

+0xDF,0xAC,0x1B,0x07,0x22,0xAC,0x54,0x05,0x99,0x4D,

+0xCC,0xF9,0xDE,0x66,0xE9,0x57,0xE3,0xE3,0x4C,0x6A,

+0x91,0xEB,0xE6,0xED,0x76,0x4A,0xE9,0xCD,0x04,0x8E,

+0x51,0x32,0x43,0x5D,0x10,0x35,0x81,0x7F,0xEE,0x31,

+0xB0,0x0B,0x8A,0xE5,0xE0,0x30,0x38,0xBA,0xAA,0x48,

+0x43,0xC0,0xF9,0x60,0x79,0x6B,0x27,0xCD,0xF0,0x6E,

+0x61,0x2C,0x0F,0x0A,0xB0,0xD5,0xA6,0x0A,0x50,0x51,

+0x6C,0xD8,0x9F,0x3E,0x47,0x2F,0x39,0x42,0x61,0x5E,

+0x68,0x1C,0xE6,0x56,0x8F,0x88,0x1D,0x46,0xBB,0x41,

+0xD6,0x4D,

+};

+const uint8_t refAES_CTR_192[]={

+0x7F,0x90,0x5A,0x78,0x3E,0x20,0x82,0xB7,0xBA,0xCE,

+0xF7,0x14,0x40,0x93,0xF3,0x4C,0x80,0x03,0x13,0x1F,

+0x76,0xEA,0xC2,0xA9,0xD2,0x45,0x88,0x60,0x98,0xC0,

+0xD4,0xDB,0x01,0x9A,0x8D,0x88,0x55,0x85,0x01,0x03,

+0x9E,0x20,0x0C,0xFA,0xE1,0xA8,0x11,0x1F,0x47,0xF5,

+0x9A,0x58,0x47,0xB0,0x0A,0x54,0x80,0x81,0x9A,0x20,

+0x7C,0x1A,0xBA,0x2B,0xDD,0xFA,0xFA,0x9A,0x42,0xA7,

+0x7B,0xCE,0x9D,0x22,0x77,0x1B,0x3C,0xAC,0x39,0x85,

+0xE1,0xCE,0x4D,0x6C,0x89,0x09,0x12,0xBD,0xBA,0x4C,

+0x02,0x07,0x79,0x48,0x3E,0x70,0xC3,0x85,0x19,0xE6,

+0xC0,0xA0,0x52,0x59,0x0E,0x19,0xC0,0xCC,0x88,0x3C,

+0x0C,0xB8,0x37,0xE4,0x06,0x75,0x0C,0x43,0xF4,0xF4,

+0xA4,0xA4,0xA9,0x2B,0xAB,0xC4,0x26,0xA5,0xC4,0x8A,

+0xAC,0x16,0xC1,0x43,0x1D,0xDD,0x0B,0xF1,0xD5,0x4E,

+0xDE,0xF9,0x27,0xE4,0x1B,0x3B,0xC5,0x29,0xC8,0xE5,

+0x64,0xF7,0x0E,0xCE,0x43,0xD6,0x57,0xF7,0x1C,0x81,

+0x81,0x2E,0xEC,0x47,0x8E,0xC1,0x01,0x23,0xAF,0x96,

+0xD6,0x58,0x2B,0x1A,0xE0,0x84,0xA9,0xAF,0xFC,0xCF,

+0xFD,0x42,0x66,0xC4,0x83,0x42,0xF1,0x3B,0x47,0xEB,

+0x8D,0x92,0xCB,0x3C,0x5F,0x25,0xB6,0x29,0x5D,0x19,

+0x0B,0x9A,0x5F,0xD0,0xD7,0xC6,0xBE,0xAE,0xC5,0x3B,

+0xA5,0x07,0xBE,0x8E,0xC8,0xF3,0xAE,0x83,0xB6,0xF7,

+0xA4,0x04,0xFC,0x0C,0x95,0x6C,0x6E,0xEB,0x82,0xB4,

+0xE9,0x3D,0x38,0xAF,0x07,0xEB,0xFE,0x64,0x06,0xA2,

+0x35,0x57,0x90,0x1C,0x0C,0x4F,0x94,0xCF,0x5B,0x54,

+0x7A,0x0B,0x71,0x02,0x39,0x89,0xFA,0x83,0xFC,0x9C,

+0xA4,0x16,0x67,0x44,0x69,0x4D,0x97,0x5A,0xC3,0x49,

+0xE1,0x03,0x13,0xA7,0x44,0x86,0xC2,0x30,0xEF,0xBA,

+0xBA,0xD6,0xCF,0xCC,0xF0,0x12,0x42,0x1E,0x22,0xE3,

+0x9F,0xA2,0xE7,0xCD,0x39,0xCC,0x1C,0xAF,0xB0,0xFC,

+0x2B,0x31,0xFA,0xD7,0x0A,0x23,0x48,0x5C,0x5B,0x53,

+0x18,0x5A,0xC6,0x7F,0x14,0x21,0xF0,0xB3,0x89,0xFA,

+0xEA,0xF3,0x62,0x51,0x75,0x09,0xAA,0x5A,0x7A,0x51,

+0x23,0xA4,0x86,0xAF,0xFB,0xFF,0xDE,0x48,0xE2,0xEA,

+0x13,0xFC,0x81,0x36,0x17,0x36,0xED,0xDF,0x71,0x9E,

+0x58,0x65,0xFF,0x95,0xA4,0x95,0xF3,0x3D,0xEC,0xC7,

+0xFF,0x19,0x73,0x89,0x2A,0x59,0x60,0x71,0x81,0x4F,

+0x6B,0xB1,0xE4,0x35,0xCA,0x55,0x3B,0x47,0x24,0xBA,

+0x14,0x76,0x21,0xEE,0x6D,0x97,0x1B,0x27,0x87,0x98,

+0x39,0x11,0xEC,0x86,0x8F,0x21,0x61,0x87,0xF3,0xF9,

+0xC1,0x85,0x5D,0x38,0xE9,0xC5,0x72,0xA1,0xA1,0x39,

+0x75,0x41,0x39,0x36,0x32,0xDF,0x6D,0x16,0x5D,0x8A,

+0x23,0x79,0x58,0x0B,0x08,0xF8,0x6C,0x75,0x00,0x2B,

+0xE1,0x1D,0x24,0xEB,0x3B,0xD2,0x9E,0x50,0x94,0xC5,

+0xE1,0x34,0xD0,0xE9,0x86,0x8E,0x48,0xD8,0x98,0xA4,

+0xA3,0x47,0x44,0xD7,0xA8,0xDB,0xF9,0x7E,0x31,0x58,

+0x14,0x24,0xFF,0x89,0x26,0x0D,0x08,0x12,0xC0,0x07,

+0x94,0x51,0x0F,0xA8,0xF8,0x92,0xCB,0x85,0x19,0x5A,

+0xDD,0xAD,0x4A,0x56,0xBA,0x5F,0x6E,0xAE,0x59,0x78,

+0x0E,0x25,0x03,0x8A,0xA8,0x37,0xA9,0xB5,0x5F,0x08,

+0x5D,0x1D,0xD9,0xBE,0xCE,0x63,0x91,0x9B,0x13,0x01,

+0x7C,0x17,0xCE,0x8C,0x67,0xA7,0x17,0xBE,0x3B,0x51,

+0x5E,0x01,0xC3,0xA6,0x87,0x2A,0x72,0x32,0x20,0x7C,

+0x40,0x0A,0xA9,0x1D,0xB3,0x9F,0x61,0xF5,0x8B,0x2B,

+0xD2,0xEB,0x28,0x07,0x83,0x9E,0x4E,0x7C,0xF5,0x75,

+0x95,0xB3,0xF4,0x4C,0x1C,0xD5,0x92,0xF2,0x8B,0x04,

+0xEF,0x5B,0x67,0x90,0xD1,0x4E,0x0F,0x7B,0x8D,0x6F,

+0x31,0x64,0xED,0xBA,0x8A,0x47,0xD5,0x92,0x36,0x12,

+0x15,0xD7,0x99,0x2C,0xD2,0x11,0x5B,0xB4,0x74,0x10,

+0xF4,0x55,0xE8,0x7C,0x75,0xC3,0x85,0x01,0x4C,0xD2,

+0x0E,0x62,0xEC,0x41,0xBE,0x45,0xE6,0x97,0xE4,0xE3,

+0x9B,0x2F,0x7B,0x98,0x19,0x4E,0xC3,0xB5,0xD0,0x86,

+0x63,0x61,0xD2,0x3E,0xB3,0x0A,0xAB,0x12,0x2A,0x64,

+0x1E,0x9F,0xFD,0x66,0x66,0x4B,0xB0,0xFB,0xA0,0x36,

+0xFA,0xDF,

+};

+const uint8_t refAES_CTR_256[]={

+0x5F,0xD7,0x96,0x16,0x8E,0x0C,0x4E,0xD1,0x60,0x71,

+0xF0,0xD6,0x8A,0x48,0x9C,0x69,0x7F,0xA7,0xFD,0x4A,

+0x2E,0x6A,0x50,0x09,0xF6,0x51,0xA5,0xA0,0x26,0x04,

+0x52,0xE9,0x4F,0x46,0xB2,0x83,0xB9,0x43,0x0F,0x69,

+0xE9,0x27,0x84,0x8B,0x60,0x1C,0x4C,0xD4,0xC0,0xE5,

+0x96,0x76,0x8D,0xB6,0xC6,0xAE,0x79,0x2F,0xAF,0xDC,

+0x74,0xF5,0x6D,0x3B,0x53,0x6E,0x90,0x12,0x67,0xD0,

+0xAB,0x2E,0xD5,0x1D,0x70,0x26,0x71,0xF9,0xF5,0x9C,

+0xFD,0x80,0x49,0x16,0x96,0xA7,0x3B,0xAF,0xE0,0xB0,

+0xDB,0x8F,0xAE,0x9D,0x7D,0x60,0x4F,0x16,0x3B,0x34,

+0x54,0xA3,0xF6,0xE4,0xE4,0x71,0xCE,0x93,0x3C,0x92,

+0xC5,0x53,0x3E,0x3E,0xC9,0xC5,0x4A,0x9C,0x26,0xC5,

+0x37,0xCD,0x72,0x40,0x83,0xE1,0xC8,0xEE,0x0E,0xCE,

+0x4D,0x37,0xB4,0xDC,0x70,0x5E,0xF0,0xE2,0x06,0xEB,

+0xF0,0x82,0x6B,0x25,0x96,0x8C,0x50,0xBF,0xA3,0x68,

+0x0A,0x5C,0x37,0xA8,0x3C,0x16,0xE6,0x1A,0xC6,0x94,

+0x06,0xCB,0x70,0xBB,0xA6,0x57,0xF0,0x54,0xD2,0xB5,

+0x08,0x05,0x9C,0x3C,0x96,0x47,0x36,0x57,0xC1,0xFC,

+0x67,0x15,0x8F,0x2E,0x7F,0xCA,0xFA,0x59,0x77,0xEB,

+0xD1,0xDC,0x71,0xFD,0x05,0xD0,0x98,0x19,0x83,0x87,

+0xBB,0x48,0xE5,0xB5,0xC5,0xD3,0xEC,0x4B,0xD3,0xD1,

+0xD3,0x13,0xFE,0x52,0xC1,0xD8,0xB0,0x51,0x7B,0x3C,

+0x61,0xC0,0x4D,0xAC,0xAC,0x70,0xFE,0xFC,0xC1,0x17,

+0xC1,0xC7,0x6B,0x54,0x23,0x2E,0x7A,0xA5,0x17,0xEB,

+0x3E,0xC5,0xD7,0xB1,0x86,0x47,0x10,0x91,0x3A,0x58,

+0x12,0xEE,0xAE,0x75,0xD5,0xE4,0x17,0xB5,0xB2,0xCA,

+0xF8,0xE4,0x1C,0x3C,0x42,0xF2,0xDE,0xF3,0x70,0x86,

+0x40,0x10,0xA5,0x14,0x14,0x37,0x51,0x51,0x20,0x4E,

+0xB3,0x83,0xC2,0xB7,0x09,0x9E,0xD9,0x48,0x38,0xD0,

+0x8C,0x99,0xDD,0x2C,0x18,0x87,0x19,0x8C,0xEC,0x65,

+0x58,0x90,0xE1,0x02,0xB9,0x7E,0x46,0x6A,0xF6,0x95,

+0x4B,0xB0,0x1E,0x96,0x11,0x05,0x8F,0x43,0xFB,0x39,

+0xB9,0x47,0x3D,0x67,0x35,0xCA,0x89,0x97,0xFD,0x20,

+0x85,0xDC,0x45,0xDB,0x85,0x4A,0xC8,0x93,0x15,0x07,

+0x34,0x32,0x03,0x63,0xC7,0xDC,0xA5,0x9A,0x48,0x07,

+0x15,0x8D,0xD8,0x85,0xC4,0xA1,0x68,0x37,0xB2,0x48,

+0xB2,0x41,0x3C,0xA1,0x35,0x12,0xD4,0xF0,0x95,0xF7,

+0xCB,0x8B,0x36,0xB2,0x79,0xC9,0x08,0xB3,0x9B,0x76,

+0x6E,0xC2,0x81,0xAB,0x4D,0x55,0x89,0x40,0x5C,0x7E,

+0x7F,0x56,0xFD,0xF0,0x40,0xB9,0xBD,0x83,0x78,0xF9,

+0xF4,0xC3,0x0B,0x59,0x1F,0x92,0xEF,0x80,0x96,0x8F,

+0xB9,0x20,0x53,0x9D,0x4A,0xE4,0x2C,0x55,0xBD,0xF2,

+0xC5,0xE4,0xF4,0x48,0x56,0x46,0x41,0x4F,0x93,0x62,

+0x8F,0xB1,0xC8,0x0A,0xF7,0xFB,0x8D,0x10,0x2D,0x13,

+0xE4,0x2C,0x8F,0x32,0x8B,0xD4,0xD6,0x2E,0xE3,0x86,

+0x3E,0xE4,0xF2,0x0C,0xD2,0x9C,0xD0,0x0C,0xC6,0x94,

+0x29,0x62,0x0F,0x53,0xAF,0xD5,0x3B,0xA6,0x53,0x17,

+0xB5,0x2A,0xDE,0xA0,0xB3,0x37,0x0A,0x13,0xDE,0xAA,

+0x4F,0xB2,0x42,0xD7,0x72,0x35,0x20,0x55,0xBC,0x3B,

+0x20,0x05,0xED,0x93,0x6B,0x40,0xD0,0x42,0xA8,0x1B,

+0xD2,0x23,0xF5,0xBA,0x33,0xC6,0x2F,0x63,0x7D,0x83,

+0x1E,0xAA,0x4B,0x19,0x27,0xC8,0x12,0x1B,0x46,0x77,

+0x9E,0x21,0xC8,0x3B,0xA3,0xFF,0x8B,0x0C,0x0C,0x47,

+0xD9,0xEA,0xA8,0x4F,0x40,0x42,0x5B,0x4A,0xEA,0xF8,

+0x13,0x96,0xAF,0x66,0x90,0xE4,0x8D,0xB8,0x18,0x65,

+0x67,0x21,0x97,0xFA,0xF1,0x67,0x11,0x2E,0x01,0x87,

+0xE1,0x7E,0x18,0x48,0x4F,0x9E,0x84,0xDB,0x50,0xD8,

+0xDB,0x63,0x4B,0x95,0x89,0x42,0x2E,0xE2,0xF6,0xD7,

+0xD6,0xEC,0x92,0x55,0x39,0x25,0x89,0x94,0xE2,0x68,

+0xE3,0x6B,0x76,0x60,0xA0,0xA1,0xA5,0x2F,0xA1,0x92,

+0x8E,0xCE,0xED,0x72,0xA0,0x22,0x66,0x48,0xA2,0x24,

+0xD2,0x1D,0x48,0xF2,0x1C,0xA6,0x2E,0x8E,0x78,0xAB,

+0xDB,0x02,0x10,0x74,0x03,0x9B,0x5E,0x41,0xF0,0xA4,

+0x81,0xF8,0x7B,0xC2,0x87,0x06,0x0F,0xED,0x44,0xAE,

+0xB2,0x44,

+};

+const uint8_t refAES_CFB_128[]={

+0xFF,0x50,0x83,0x66,0x68,0x80,0x52,0xE8,0xAE,0x43,

+0xC1,0xCC,0x8D,0x60,0x9C,0xF9,0x00,0xA8,0x01,0xB3,

+0xCE,0x04,0x10,0xA9,0xFC,0xD8,0x04,0x5E,0x03,0xAF,

+0x4A,0xB6,0xC2,0xE2,0x1E,0xDF,0xFA,0xE0,0x2F,0x90,

+0x8C,0x7A,0xC2,0x99,0xD4,0xA0,0x57,0x10,0xE8,0x03,

+0x53,0x53,0x93,0x1C,0x6F,0x08,0xF0,0x90,0x27,0x1D,

+0xFD,0x31,0xB9,0xD6,0x8C,0x26,0xBA,0x5C,0xD4,0x2A,

+0x9A,0xF6,0x33,0x28,0x23,0xD2,0xC0,0x25,0xD5,0x70,

+0x0F,0x4C,0x0E,0xDA,0xC0,0x2B,0xA6,0xD9,0x73,0xDD,

+0x31,0x1B,0xBE,0xBE,0x2A,0x6D,0x1F,0x21,0xAC,0xE6,

+0x1D,0x0F,0x10,0xC7,0x54,0x3E,0x4E,0x96,0xF3,0x7F,

+0xF4,0x5A,0x6F,0x71,0x77,0x2E,0x23,0xF4,0xE4,0x38,

+0x01,0x9A,0x14,0xF2,0x14,0x0B,0x58,0x73,0x2B,0xF1,

+0x18,0x11,0xCD,0x4A,0x40,0x10,0x7C,0x44,0xE0,0xF6,

+0x8C,0x68,0x41,0x68,0x53,0x5E,0x23,0x2A,0x31,0x08,

+0x09,0xB3,0x73,0xE4,0x77,0x01,0x86,0xDC,0x89,0x00,

+0xA1,0x46,0xF0,0xE8,0xEF,0x91,0xB0,0x21,0x76,0xD5,

+0xBF,0xBF,0x8A,0x7A,0xD6,0xA5,0x2E,0xBF,0xDD,0x92,

+0x2A,0x39,0x62,0x9C,0xA3,0xA9,0x35,0x8F,0x7D,0x85,

+0x28,0x06,0x7F,0xC0,0x8A,0x6E,0xE2,0x1D,0xC8,0x81,

+0x9E,0x14,0x3B,0xA1,0x3A,0xBB,0x14,0x0B,0x43,0x9C,

+0x23,0xC2,0x2E,0x9F,0x45,0x4E,0x1F,0x75,0x3A,0x1F,

+0x20,0x28,0x83,0x47,0x99,0xC2,0xA5,0x2D,0x98,0x98,

+0x4F,0x26,0xEF,0x24,0x39,0xCB,0xD3,0x15,0x65,0x71,

+0x81,0x8E,0xDB,0x4E,0x11,0xEF,0x74,0x2E,0x6E,0xDA,

+0x2A,0xC4,0x42,0xD7,0xC5,0xDC,0xD5,0xA7,0x8A,0x22,

+0x68,0x6A,0xEF,0xF8,0x3A,0xA1,0x5E,0x4D,0xD0,0x3E,

+0x54,0xB5,0xDC,0x91,0xC6,0x00,0x68,0x56,0x73,0x21,

+0x8F,0x36,0x3F,0xEC,0xD0,0xAE,0xD9,0x76,0xFD,0xB7,

+0xD2,0x8E,0xBF,0xF8,0x3A,0x73,0x06,0xA8,0x42,0xBC,

+0x3C,0x30,0xC2,0x7D,0xD5,0x27,0x1B,0x2B,0x09,0x47,

+0x53,0x7C,0xF2,0xCB,0xE3,0xA4,0xC2,0x1C,0xFB,0x5A,

+0x77,0xF6,0x6E,0xA5,0xFB,0x32,0x64,0xBC,0x8E,0x34,

+0x0F,0x75,0xCB,0xD6,0xBF,0x05,0x93,0xBB,0xDC,0x2B,

+0x4C,0x55,0xB5,0x4A,0x9E,0xF3,0x13,0xAC,0x7B,0x41,

+0xE2,0x91,0x8F,0x3A,0x4E,0x6E,0x43,0x2C,0xFB,0xF0,

+0xCB,0x56,0x8A,0xE4,0xF1,0x81,0xBF,0x47,0x2A,0xCF,

+0xAD,0x3F,0xD1,0xEF,0x3C,0x87,0x10,0xA3,0x25,0x90,

+0x7A,0xA7,0x58,0x87,0x45,0xBA,0x0C,0x76,0x9B,0x24,

+0xEC,0x3B,0x63,0xFC,0x9A,0x7F,0xB7,0xEA,0x58,0x5B,

+0x5A,0xAB,0x3F,0x4E,0x96,0xE9,0x8D,0x05,0xBF,0xE3,

+0x59,0x0D,0x56,0x46,0x47,0xAB,0x18,0x3C,0x2E,0x5E,

+0x7A,0x80,0xEA,0x40,0x34,0xBD,0x21,0x59,0x02,0x68,

+0x3F,0xB2,0x58,0x9D,0xC8,0xEE,0xDE,0xA3,0xB0,0x8C,

+0x5D,0x0A,0x8A,0xDC,0x15,0x7A,0xCB,0x72,0xA5,0x71,

+0x07,0x62,0xBC,0xCB,0x1D,0xA7,0x30,0xAD,0x8A,0x41,

+0xE3,0xE7,0xE9,0x42,0xDE,0x00,0x1A,0xD7,0xD5,0x2B,

+0xC4,0x39,0x94,0xEC,0xC9,0x62,0x01,0x4F,0xAA,0x06,

+0x28,0x82,0x6E,0x21,0xBD,0x5C,0x76,0xC7,0xF7,0x30,

+0x1B,0xEF,0x85,0x0E,0x3D,0xED,0x14,0x4C,0x0D,0x14,

+0xA6,0x87,0x52,0xFE,0xDC,0xB1,0x04,0xEC,0x34,0xBB,

+0x92,0x67,0x06,0xBA,0xF4,0x9D,0x52,0xCD,0xF9,0xE1,

+0x37,0xCB,0x7B,0x33,0x51,0x79,0x3E,0x76,0x75,0xDA,

+0xA0,0xC3,0x9A,0xE0,0xA8,0xB2,0x68,0x26,0xD1,0xDC,

+0x26,0xC1,0xB7,0x10,0xEA,0xF9,0x01,0xA9,0x41,0xD8,

+0x0F,0xDE,0xAD,0x98,0x7B,0xE4,0x9C,0xDF,0xB2,0x0F,

+0x11,0xA7,0x11,0xD8,0x61,0x24,0xD1,0x3D,0x7A,0xED,

+0x55,0xC1,0x38,0x22,0x5F,0x03,0x12,0x3E,0x42,0xF0,

+0x46,0x5C,0x8F,0x3A,0x98,0x8A,0x5E,0x88,0xA7,0x7E,

+0x89,0x30,0xFF,0x8A,0xB0,0xF2,0x4C,0x58,0x0A,0x6F,

+0xE1,0x27,0xDD,0x51,0xFA,0xCA,0x8F,0x59,0x77,0x17,

+0xE8,0x3F,0x1F,0xF9,0x1E,0xC4,0xE7,0xC0,0x6C,0xFE,

+0xA4,0xA8,0xEA,0x06,0xF4,0x51,0xB4,0xEA,0xBA,0x4A,

+0x0D,0x9F,0xD0,0xD8,0xF2,0xB1,0x9D,0x34,0x2C,0x56,

+0xE9,0xD5,

+};

+const uint8_t refAES_CFB_192[]={

+0x7F,0x90,0x5A,0x78,0x3E,0x20,0x82,0xB7,0xBA,0xCE,

+0xF7,0x14,0x40,0x93,0xF3,0x4C,0xC4,0x55,0x5B,0xCD,

+0x46,0xA8,0xC9,0x29,0xE9,0xA7,0x86,0x4D,0x53,0xEA,

+0x6C,0x7E,0xFA,0x11,0x5F,0xB3,0xA8,0xB6,0xD8,0x40,

+0xFE,0xBB,0x05,0xB4,0xB0,0x9A,0x3C,0xC4,0x4E,0x01,

+0x66,0xF6,0x27,0x28,0x7B,0x59,0x2A,0x34,0xF3,0x8B,

+0xD9,0x8E,0x2E,0x03,0x38,0x56,0xE9,0xC9,0x5E,0x2B,

+0x1F,0x9B,0x42,0x56,0xDD,0xE0,0x5E,0x7E,0x58,0x14,

+0x9B,0x63,0xB7,0x81,0x31,0xED,0x19,0xC0,0xDE,0x3A,

+0x13,0x22,0x4A,0x2D,0x90,0xAD,0x16,0x89,0xD2,0xAB,

+0xB7,0xCA,0xAD,0x7A,0xF1,0xEB,0xAB,0x57,0x65,0x29,

+0xE1,0x01,0xC3,0x7F,0xE0,0x08,0x28,0x22,0x60,0xBF,

+0x4B,0x5F,0xCD,0xCE,0x81,0xBC,0x69,0x87,0x05,0x1D,

+0x88,0xAB,0x85,0x2A,0x53,0x82,0x9A,0x14,0x20,0xCB,

+0x37,0xEB,0x97,0x57,0xCC,0x92,0xCB,0x45,0xC1,0xC0,

+0xA8,0xEC,0xDB,0x38,0x90,0x9C,0xD4,0xA4,0x49,0xBA,

+0x2D,0xB7,0x90,0x00,0x50,0x7E,0x36,0x84,0x61,0x34,

+0x47,0x8D,0x32,0x45,0x0F,0x2C,0x69,0xB9,0x39,0x05,

+0x07,0xD8,0x20,0x26,0x46,0x7A,0x29,0x6A,0x41,0xC4,

+0xF0,0x0B,0x0C,0x2B,0x22,0x4F,0x18,0x96,0x1E,0x74,

+0x49,0x32,0xB0,0x00,0x82,0x69,0x4B,0xEB,0x27,0x9B,

+0xA1,0x40,0x76,0x27,0x9A,0x59,0xAB,0x64,0x50,0xC3,

+0x5E,0x8A,0x08,0x67,0x03,0x15,0xC3,0x12,0x29,0x10,

+0xAE,0x23,0x33,0xC5,0x67,0xAB,0xA3,0xDE,0xE3,0x13,

+0x0F,0xC9,0xCE,0x22,0xF4,0x83,0x3F,0xDD,0xFA,0xF6,

+0x6E,0xBF,0xA9,0x5C,0xE5,0xE3,0xA1,0x37,0x70,0xFD,

+0x2E,0x2C,0x69,0x2C,0x41,0x5D,0x31,0x31,0xC2,0x2E,

+0xBD,0x48,0xA3,0x1F,0xBE,0x31,0x07,0x0A,0xEF,0x27,

+0x22,0xFE,0x1E,0x36,0xC3,0x36,0xE8,0x1B,0x4F,0x74,

+0x70,0x0E,0xDB,0x73,0x32,0x5E,0x21,0x70,0x92,0x0C,

+0xAF,0x70,0xEA,0xC2,0x63,0x9D,0x67,0xC2,0xFA,0x0F,

+0x50,0x23,0xE1,0x5B,0x13,0x78,0xA3,0xFD,0x37,0x87,

+0x0A,0x23,0xF2,0xB6,0x1A,0x98,0xE2,0xE5,0x4A,0x9F,

+0xC1,0x96,0xFF,0x3C,0x2E,0x8A,0xFF,0x53,0xF4,0x20,

+0x23,0xD1,0x07,0xF0,0xFB,0x76,0x3B,0x6A,0x40,0x56,

+0x2E,0x85,0xD7,0xC4,0xF8,0x4F,0x16,0x6F,0x91,0x34,

+0x17,0x7B,0xF4,0xF7,0x0E,0xCF,0x3E,0x22,0xC3,0x87,

+0x39,0xA6,0xB5,0x60,0x6C,0xE1,0x46,0x6C,0x19,0xF5,

+0xE5,0x68,0x98,0xEB,0xE2,0xD0,0xAA,0xFF,0x2B,0xEC,

+0x39,0x2E,0x23,0x8F,0x8E,0x35,0x5E,0x30,0xD5,0x4F,

+0x5D,0x9B,0xF8,0xA1,0xA9,0xD6,0x1D,0x3F,0xB4,0xB4,

+0xE4,0xE6,0x36,0x66,0x8B,0x1E,0x58,0xC6,0xCC,0x67,

+0x53,0xDA,0x0A,0xC5,0x08,0xEC,0xC8,0xDD,0x35,0x9A,

+0x1B,0xB5,0xC4,0xE4,0x8C,0xBD,0x41,0x85,0x4B,0x30,

+0xE2,0x05,0xD9,0x74,0x63,0xA1,0x60,0xEF,0x8E,0xE4,

+0x1B,0x78,0x89,0x3C,0xC3,0x60,0xC6,0x0F,0x61,0x98,

+0xEB,0x09,0x96,0x23,0xCC,0x34,0x66,0xB0,0x4E,0xE1,

+0x68,0x90,0xBC,0x0D,0x8F,0x30,0xFF,0x53,0x92,0x6C,

+0xF7,0xB3,0x47,0xB2,0x6D,0xE3,0x8E,0x5E,0xC5,0x02,

+0xC9,0x62,0xD5,0x97,0x3E,0x05,0xE0,0x7B,0xBD,0x43,

+0xF5,0xD8,0xDE,0x85,0x25,0xDC,0xDC,0x41,0x76,0x04,

+0x6E,0x03,0x07,0xF1,0xA2,0xBA,0x3B,0x3E,0x16,0x63,

+0x09,0x3B,0x4C,0x60,0xC1,0x13,0x63,0xAC,0x31,0x99,

+0xBD,0xFE,0x2C,0x4D,0x03,0xDF,0xAC,0xF5,0x97,0xFF,

+0x28,0xC4,0x7E,0x0C,0x57,0x20,0x12,0xF3,0x34,0x44,

+0xEE,0x1B,0xC5,0x79,0xC1,0x61,0x06,0x38,0x58,0x65,

+0x89,0xFD,0xAF,0x77,0x69,0x49,0xA7,0x40,0x02,0x3F,

+0xD8,0x0F,0x10,0x20,0x0F,0x35,0x19,0x09,0xF1,0xD6,

+0xB9,0x33,0xAF,0xFE,0x81,0x6A,0x75,0x9E,0x98,0x24,

+0x3F,0x6F,0x8F,0x4E,0xFC,0x72,0x08,0x7C,0xAF,0x56,

+0x19,0x90,0x0D,0x56,0xF0,0x80,0x88,0x77,0xAA,0x16,

+0x65,0x55,0x27,0x5B,0x4C,0x23,0x1C,0x04,0x46,0xB0,

+0xA7,0x5D,0x68,0xD0,0x3D,0x8A,0xEF,0x73,0xEA,0xAF,

+0x15,0x1D,0x2A,0xCC,0x86,0x42,0x64,0x54,0xBF,0x05,

+0x98,0xFF,

+};

+const uint8_t refAES_CFB_256[]={

+0x5F,0xD7,0x96,0x16,0x8E,0x0C,0x4E,0xD1,0x60,0x71,

+0xF0,0xD6,0x8A,0x48,0x9C,0x69,0x70,0xB0,0x34,0x77,

+0x3C,0xF7,0x27,0xFE,0xD2,0x46,0x63,0xE5,0x94,0x1A,

+0xFD,0x2A,0xF9,0x81,0x5D,0xE0,0x67,0xB7,0xA9,0x43,

+0x46,0x4F,0xE3,0x43,0xF6,0xBE,0x30,0xEA,0x54,0x49,

+0xAC,0xC4,0xE1,0x45,0xB4,0x2A,0xDF,0x02,0x52,0x90,

+0x37,0xCF,0x26,0x22,0xA8,0x84,0x98,0x03,0x2C,0xB8,

+0xEA,0xB8,0x5E,0x9A,0xA1,0x50,0xF4,0x89,0xB6,0x78,

+0xCA,0xC6,0xC8,0x6E,0xB8,0x0C,0x69,0xCC,0xC9,0xD5,

+0x75,0xF6,0xB5,0xC5,0x1F,0x26,0xB2,0x97,0x9D,0xF6,

+0x4D,0x68,0x08,0x47,0x76,0x6C,0xAF,0x03,0x5B,0xD7,

+0x0D,0x75,0xAE,0x9D,0x35,0x8A,0x16,0xF0,0xB5,0xAB,

+0x41,0x50,0xD7,0xDB,0x41,0x8F,0xD7,0x58,0x9C,0x5A,

+0x76,0xEC,0xCD,0x7E,0x2E,0x6A,0xE8,0x79,0xBB,0x44,

+0xFA,0x1E,0x17,0xF5,0xA6,0x5F,0xF5,0xF8,0x62,0x70,

+0xF4,0x66,0xE2,0xF0,0x79,0x6A,0xBF,0xB6,0x9D,0xBB,

+0x75,0x0C,0x5D,0x64,0xC3,0xE3,0x14,0xBE,0xE3,0x81,

+0xD8,0x14,0x7C,0x59,0xE3,0xEE,0xEA,0x35,0x33,0xE6,

+0x42,0x1C,0x0C,0x12,0xE1,0x51,0xE8,0xC8,0x24,0xBE,

+0xDB,0x1C,0x00,0xC5,0x60,0x2D,0x5F,0x92,0xE7,0xD4,

+0xD2,0x08,0x72,0xC5,0xC1,0x5C,0xBC,0x1B,0xD8,0x1E,

+0xC3,0x38,0x28,0xDA,0xA3,0x30,0x61,0x5F,0x54,0xEA,

+0x24,0x3B,0x80,0xDE,0x25,0xFE,0x6C,0x04,0x68,0x7B,

+0x9E,0x79,0x1A,0xF2,0x85,0x39,0x5B,0x75,0xC5,0x72,

+0x9B,0xB3,0x40,0xF5,0xA9,0xD8,0x5D,0x9F,0x74,0x66,

+0xE2,0x02,0x58,0x10,0xB3,0x0A,0x34,0xB6,0x5F,0x95,

+0xDF,0xEF,0xDE,0x25,0xCC,0x54,0x6F,0x29,0x57,0x46,

+0xE2,0xE4,0x9C,0x17,0x0F,0x10,0x52,0x49,0x95,0x15,

+0xE3,0xF7,0xA6,0x68,0xE2,0x54,0x47,0xDC,0x54,0xF2,

+0x83,0x2B,0xB1,0x77,0x10,0xC0,0xD1,0x86,0x2D,0xC5,

+0xE6,0x7F,0x72,0xCF,0xBA,0xBE,0x6E,0xA1,0x90,0xDB,

+0xC5,0xC0,0x9C,0xB3,0xD5,0xE3,0xBA,0x85,0x00,0x8A,

+0x5C,0x63,0x34,0xF5,0x66,0x23,0x28,0xD6,0x3A,0x68,

+0x14,0xB3,0x34,0x20,0xA6,0xE8,0x63,0x72,0x00,0x18,

+0xA5,0x69,0x12,0xBA,0x1C,0xA8,0x0E,0xDE,0xD7,0x10,

+0xBE,0x10,0x7F,0x12,0xDC,0x55,0xEF,0x21,0xE2,0x73,

+0x48,0x0D,0x8E,0x59,0x35,0x3A,0x5D,0x63,0x3E,0x7E,

+0xDE,0x1D,0x71,0xF6,0x3B,0xD6,0x08,0xB5,0x64,0x74,

+0xA0,0x82,0x9D,0xF1,0x43,0xDE,0xD9,0x9F,0x5D,0xC0,

+0xBF,0x3E,0x90,0x36,0x60,0x74,0xF0,0xDE,0xBB,0x88,

+0xDF,0xA7,0xD1,0x26,0x50,0xBF,0xA9,0x0C,0xC6,0xE2,

+0xCB,0x8F,0x95,0xB7,0x8B,0xF7,0x1A,0x5E,0x68,0xED,

+0x13,0x5D,0x53,0xED,0xBD,0x34,0xEA,0x37,0x03,0x0D,

+0xCC,0x9F,0x67,0xF1,0xE4,0xED,0xD6,0x0A,0xEA,0x07,

+0xFB,0x43,0x54,0x91,0x57,0xEF,0xFD,0x2B,0xF1,0x48,

+0x82,0x4E,0x2C,0xF0,0x2B,0xB5,0x2F,0x9A,0xEA,0x84,

+0xF1,0x48,0x44,0x9A,0x5E,0x29,0xDA,0xE0,0xAC,0x19,

+0x5A,0xAB,0x67,0x09,0x96,0xE1,0x23,0x29,0xA0,0x31,

+0x0F,0x24,0xE6,0x13,0x97,0x13,0x59,0xEA,0x21,0xA5,

+0xDC,0xE9,0x12,0x1C,0x21,0x14,0xBC,0x3C,0x47,0xF5,

+0xC1,0xCF,0x87,0x3B,0x52,0x01,0xD3,0x5F,0xDA,0xD5,

+0x57,0x15,0xA8,0x56,0x3A,0x86,0xFE,0x63,0x4F,0x34,

+0x85,0xAE,0x32,0x07,0x29,0x15,0xDA,0xCE,0xB5,0x5A,

+0x07,0xD4,0x8C,0xAE,0x16,0x77,0xFF,0xB8,0xCA,0x08,

+0x8F,0x06,0x96,0xC7,0x8A,0x0D,0xD0,0x95,0x38,0x8D,

+0x34,0x0E,0x57,0x35,0x8B,0xEE,0x17,0x23,0x6D,0x91,

+0xD6,0xEB,0x25,0x74,0x0C,0x0A,0x90,0x30,0x81,0x16,

+0xA5,0xBE,0x83,0xF9,0xC4,0xA1,0xE6,0x44,0x5B,0x8F,

+0xCA,0x4D,0x69,0xA6,0x77,0x3A,0x57,0x1E,0x4A,0x0C,

+0xE8,0x9E,0x73,0xF4,0x35,0x09,0x2C,0x04,0xB4,0x24,

+0xDF,0xED,0xB2,0x6F,0x41,0x54,0xC1,0x7D,0xC5,0xFF,

+0xFE,0xD7,0x20,0x02,0x1F,0x60,0xB8,0xD5,0xFB,0xC6,

+0x1F,0xEA,0x1C,0xDA,0xDD,0x5B,0x73,0x41,0x01,0xF6,

+0x4F,0xF4,0xB2,0xE1,0x30,0xC6,0xEE,0x72,0xF0,0x5D,

+0x34,0x2D,

+};

diff --git a/test/crypto/source/testref/ref_aes.h b/test/crypto/source/testref/ref_aes.h
new file mode 100644
index 000000000..a4e6759fc
--- /dev/null
+++ b/test/crypto/source/testref/ref_aes.h
@@ -0,0 +1,31 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+#ifndef TEST_REF_AES_H_

+#define TEST_REF_AES_H_

+

+extern const uint8_t refAES_ECB_128[];

+extern const uint8_t refAES_ECB_192[];

+extern const uint8_t refAES_ECB_256[];

+extern const uint8_t refAES_CBC_128[];

+extern const uint8_t refAES_CBC_192[];

+extern const uint8_t refAES_CBC_256[];

+extern const uint8_t refAES_CTR_128[];

+extern const uint8_t refAES_CTR_192[];

+extern const uint8_t refAES_CTR_256[];

+extern const uint8_t refAES_CFB_128[];

+extern const uint8_t refAES_CFB_192[];

+extern const uint8_t refAES_CFB_256[];

+#endif //TEST_REF_AES_H_

diff --git a/test/crypto/source/testref/ref_des.c b/test/crypto/source/testref/ref_des.c
new file mode 100644
index 000000000..fca75627c
--- /dev/null
+++ b/test/crypto/source/testref/ref_des.c
@@ -0,0 +1,353 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+

+#include "hal.h"

+

+const uint8_t refDES_ECB_8[]={

+0x5A,0x45,0xE3,0x30,0x6B,0x7E,0xF0,0x87,0x27,0xE2,

+0x92,0x19,0x09,0xE1,0x4E,0x68,0x84,0x84,0x01,0x45,

+0xED,0x86,0xB4,0x41,0x4A,0xE9,0x1F,0x1A,0xC0,0xE0,

+0x05,0x90,0x9B,0x8A,0x47,0xD7,0x64,0x5D,0xC5,0x92,

+0xB4,0x23,0x6B,0x0E,0x7E,0x4F,0xB8,0x86,0x23,0x75,

+0x6D,0x35,0xBF,0xE0,0x1F,0x58,0x23,0xAF,0x11,0x95,

+0x64,0xE4,0x4E,0xE1,0xD6,0xBB,0x00,0xCC,0xA9,0xBA,

+0x33,0xA1,0xDD,0xAC,0x79,0xCB,0x05,0xA6,0x5F,0x07,

+0x98,0xF1,0x9F,0xAA,0x9B,0xE2,0x37,0xCB,0xC1,0xA8,

+0x06,0x2C,0x8C,0xD1,0x34,0xE4,0x90,0x72,0x32,0xA8,

+0x5B,0x82,0x03,0x36,0x89,0x34,0x8A,0xD7,0xB0,0x63,

+0x2E,0x84,0x71,0xCB,0x97,0x01,0x9C,0x4D,0x31,0xE3,

+0x00,0x33,0x5C,0x76,0x08,0x52,0x8B,0xE4,0x86,0x5D,

+0xB2,0x5A,0xFF,0xF2,0xB1,0x18,0x66,0xCC,0xCC,0x05,

+0x64,0x4E,0x59,0x83,0x04,0x52,0xD8,0x66,0x4C,0xD0,

+0xA9,0xD1,0xB0,0xC0,0x9A,0x4D,0xA1,0xC6,0x64,0xB4,

+0x4E,0x7F,0xAB,0xD3,0x83,0x74,0x7A,0xCB,0xC2,0x66,

+0x2D,0x83,0xCC,0x25,0x7C,0xEA,0x81,0x95,0x30,0x71,

+0xD3,0x40,0x94,0x57,0xF8,0x09,0x34,0x8C,0xF1,0x0C,

+0xC4,0xEF,0x57,0x8C,0x25,0xB3,0x63,0x4B,0xBB,0x40,

+0x5D,0x65,0xDA,0x9E,0x18,0xBE,0xD4,0x81,0xE3,0x0C,

+0x43,0x4D,0x97,0x24,0x9F,0x88,0x09,0x74,0xA0,0x7A,

+0xA9,0xCC,0xF1,0x56,0xA5,0x83,0xEE,0x98,0x2A,0x8B,

+0x6E,0xA3,0x6A,0x44,0x75,0xC4,0x6F,0x77,0xD6,0xAD,

+0x96,0xE4,0x92,0x4B,0x77,0x1C,0xF4,0x31,0x1C,0x8F,

+0x6A,0x72,0x01,0xDE,0x8F,0x2E,0xA3,0x3E,0xEB,0xC8,

+0xFC,0xA5,0x77,0xC7,0xA2,0x2F,0x7D,0x03,0xA4,0x1B,

+0x83,0xA3,0x78,0x03,0xE3,0x05,0xB5,0x1B,0x53,0x15,

+0xCA,0x8B,0x88,0x12,0xA1,0x31,0x0E,0x7B,0x37,0xEB,

+0xDA,0xCD,0x0E,0x88,0x0E,0xE4,0x3B,0x76,0x6A,0xA0,

+0x89,0x6D,0x69,0x58,0xBA,0x80,0x59,0x72,0x53,0x6F,

+0xEF,0x1A,0xB5,0xE0,0xEF,0x54,0xF2,0xBA,0x09,0x74,

+0xFE,0x22,0x9A,0xF6,0x3C,0xE3,0x59,0x23,0xF2,0x0E,

+0xE0,0xC6,0xD5,0xFD,0xB9,0xA4,0x25,0xE4,0xC6,0xBA,

+0x55,0xBE,0x93,0x60,0x21,0x91,0x22,0xD0,0xEC,0xC4,

+0x93,0x8E,0x58,0x51,0xCA,0x02,0x06,0x68,0x81,0xA2,

+0x90,0xCC,0x13,0x92,0xC7,0x0B,0x95,0x57,0xBB,0x28,

+0xB5,0x8F,0xAB,0x54,0xA0,0x70,0x8D,0xB6,0x8D,0x5C,

+0x3A,0xBC,0xC9,0xD3,0x76,0x5E,0x65,0x12,0x24,0x2E,

+0x0C,0xA4,0x05,0x9B,0xDD,0x3C,0xB3,0x9D,0x7D,0xC3,

+0xEC,0x01,0x05,0xBD,0x34,0x57,0xF7,0xB1,0xE1,0xA3,

+0x83,0x06,0x9D,0x7E,0x6A,0x86,0x00,0xAD,0x1E,0x52,

+0x33,0xC3,0xD5,0x36,0xFD,0x31,0x91,0x0E,0xE0,0xAD,

+0x48,0x16,0x54,0x50,0x0E,0xE5,0x54,0x29,0x4B,0x6C,

+0xD2,0x34,0xCA,0xD8,0x01,0x3C,0x86,0xDE,0x50,0x1C,

+0xEA,0xB7,0xDE,0xBA,0x25,0x3F,0x8A,0x9A,0xF0,0xD9,

+0xA5,0x79,0x06,0x65,0x06,0x11,0xD9,0x71,0x87,0x4C,

+0xEA,0x73,0xA4,0x77,0xA3,0x18,0x87,0xED,0xE7,0x0C,

+0x79,0x22,0x08,0xC9,0x81,0xB7,0xF3,0x4F,0x2E,0x3E,

+0xD2,0x35,0x00,0xAA,0xEC,0x24,0xDF,0x4F,0x53,0x03,

+0x57,0x02,0xB6,0x97,0x22,0x12,0xB4,0xBE,0xC0,0xCF,

+0x8D,0x32,0x8C,0xFF,0x6A,0x91,0xCE,0x1A,0x71,0xBC,

+0x86,0x7F,0x17,0x60,0xB3,0x23,0x79,0x63,0x3C,0x88,

+0x7F,0xA0,0x2B,0x71,0x27,0x31,0xEC,0x9C,0x37,0xBF,

+0xC1,0xEC,0x81,0xD1,0xD4,0x94,0x4F,0x5D,0xC3,0xE1,

+0xC6,0xDA,0xF3,0x6B,0xDF,0x94,0x44,0xB1,0x80,0xC8,

+0x21,0x23,0xF3,0x8C,0xD0,0x4C,0xAA,0x34,0x68,0x4E,

+0xAD,0x3E,0xF6,0xBC,0xB9,0x14,0x4D,0x15,0xD0,0x8B,

+0x31,0xD4,0x04,0x9D,0xFC,0x6A,0x2E,0x6F,0xC8,0x4D,

+0x8F,0x26,0x51,0x9D,0xFF,0x51,0x4E,0xD8,0x9A,0x06,

+0xC0,0x8B,0xE0,0xE6,0x84,0x50,0xD1,0x24,0x9E,0x43,

+0xA3,0xCD,0x3A,0xE7,0x81,0xA7,0x98,0xA9,0x8D,0xAE,

+0x08,0xD7,0x22,0x89,0x50,0x4C,0x7C,0x81,0x2F,0x4D,

+0xB8,0xA6,0xED,0x1D,0xB9,0x9B,0x1B,0xFE,0xC9,0x10,

+

+};

+const uint8_t refTDES_ECB_16[]={

+0x75,0xF8,0x54,0x8A,0xE9,0x66,0xF6,0xCB,0xDA,0x0D,

+0xEA,0xB3,0x89,0x3B,0x68,0xDE,0x9A,0xD4,0xB9,0x92,

+0xCE,0x65,0x24,0x22,0x63,0x5E,0x3A,0xFB,0x90,0x71,

+0xA3,0x89,0x86,0x0A,0xB6,0xA7,0x84,0x27,0x8E,0xAA,

+0xC8,0x8C,0xA6,0xF2,0xB9,0x11,0x28,0x67,0x6F,0xF8,

+0x43,0x1C,0x7D,0x78,0x9B,0xB1,0xF8,0x2E,0xBE,0xF4,

+0xE1,0xB4,0x66,0xA1,0xB5,0xE0,0x52,0x6A,0x66,0xC8,

+0xAA,0xB0,0xEF,0x69,0xB9,0xC5,0xC8,0x62,0x13,0x21,

+0x0B,0xE6,0x66,0x37,0x1A,0x55,0xA1,0xB7,0xF4,0x82,

+0x88,0xDC,0x9D,0x28,0xF1,0x74,0x60,0x9E,0x2F,0xCA,

+0x62,0x03,0xC9,0x6B,0x00,0x89,0x5D,0x58,0x4A,0x5A,

+0x44,0xCD,0xA4,0x77,0x63,0x4A,0xDB,0x44,0xA3,0xBE,

+0x73,0xE7,0xD0,0x6F,0xA5,0xDA,0xC2,0x54,0x8B,0x87,

+0x68,0xE4,0x72,0x4A,0x5E,0x90,0x1E,0x97,0x5F,0xF6,

+0x2F,0xC6,0x99,0x86,0x04,0xB4,0x6E,0x28,0x9A,0x79,

+0x06,0xA9,0xC7,0x6C,0x8B,0x56,0x44,0x71,0x9A,0x7F,

+0xC8,0x02,0x94,0x57,0x45,0xA8,0x9B,0x49,0xAB,0x0A,

+0xAD,0xAB,0x4D,0xB6,0xE0,0x66,0x22,0xF9,0x11,0x1E,

+0xBB,0xBB,0xAD,0x62,0x28,0x01,0x77,0x8E,0xA4,0x90,

+0x41,0xB3,0x4E,0x38,0xC6,0x0B,0x18,0x6C,0xDA,0x77,

+0x0C,0x7D,0xC8,0x70,0xD9,0x75,0xB7,0xDD,0x28,0x7B,

+0x15,0xA7,0x0C,0x8E,0x9C,0xAB,0x38,0x60,0x7D,0x52,

+0x1D,0x72,0x17,0x45,0x17,0x79,0x6A,0x22,0x23,0xC3,

+0x1A,0xD1,0xC6,0x93,0xF2,0x47,0x3D,0x3F,0xC0,0x43,

+0x0A,0x61,0x25,0x39,0x33,0xB4,0x76,0x31,0x6D,0xE5,

+0xC0,0xE8,0x1B,0x8B,0x52,0x69,0x7C,0x39,0x03,0xAF,

+0x60,0x0B,0x29,0x8A,0x5D,0x68,0x96,0x18,0x22,0xB3,

+0x0D,0x6C,0xA1,0x96,0xD2,0x49,0xBA,0x7D,0x65,0xD1,

+0x47,0x5E,0x30,0x7E,0xD3,0xFC,0xA9,0x9C,0x79,0x50,

+0x25,0x29,0x2B,0xCC,0x73,0x55,0x71,0xEE,0xC7,0x47,

+0x01,0x99,0x5D,0x4C,0x40,0x45,0x2C,0x4A,0xE6,0xFE,

+0x74,0xFF,0xB7,0x9F,0x8B,0x4C,0xEC,0x2D,0xDC,0xA3,

+0xA2,0xCD,0x82,0xBE,0xFD,0x0A,0xAB,0xD6,0x13,0x5C,

+0x06,0x9E,0xAA,0x12,0x1C,0x91,0x99,0xC1,0xEF,0x5D,

+0x6F,0x77,0x90,0x7A,0x65,0x4A,0xC3,0x6F,0x2A,0xD0,

+0xD5,0x60,0xE9,0x41,0x25,0x0D,0x60,0x37,0x5F,0x17,

+0xC3,0x1A,0xD2,0x9E,0xA0,0xBB,0xDB,0xC9,0x53,0x28,

+0x8D,0x52,0x74,0x85,0x84,0xBB,0xAC,0x16,0xEA,0x48,

+0xC7,0x7D,0x89,0x72,0x9F,0x3D,0x85,0xF0,0x38,0x44,

+0x3A,0x21,0x09,0xD9,0xA5,0x04,0x40,0x8F,0xAF,0xFA,

+0xDB,0xEC,0xBA,0x5C,0xC2,0xCA,0x7A,0x27,0xB4,0x8E,

+0x71,0x0F,0x66,0xF0,0xC7,0xA3,0x9A,0x5A,0xA4,0x04,

+0x3C,0xAB,0xAA,0x7A,0x92,0x03,0x32,0x5A,0xA5,0xE7,

+0x64,0x9F,0x9A,0x65,0xD0,0xCE,0xCC,0x65,0xF4,0xB0,

+0x79,0xEE,0xE3,0x4F,0x98,0xCA,0x41,0xE4,0x7A,0x97,

+0x89,0xE6,0xBE,0xA0,0xF9,0xA2,0xE3,0xF8,0x46,0xA4,

+0xD8,0x1B,0x2F,0x80,0x1B,0xF6,0xF3,0x01,0xAE,0x4F,

+0xB3,0xAC,0x55,0xF4,0xA3,0x13,0xD7,0xBB,0xA1,0x50,

+0xF7,0x76,0x54,0x5F,0x50,0x22,0xDB,0x19,0xE5,0x45,

+0xF0,0x2C,0x6B,0x14,0x93,0xE6,0xA5,0xCF,0x66,0x9C,

+0x66,0x2D,0x4D,0x9F,0x60,0x50,0x32,0xBC,0xF0,0x90,

+0x7C,0xC9,0xC0,0x51,0x7D,0x1B,0xA4,0x37,0x64,0xC2,

+0xB2,0x75,0x0A,0x13,0x2B,0xE9,0x4A,0x18,0xB2,0x34,

+0xB0,0xD4,0x86,0xBD,0xCE,0x17,0x5B,0xBF,0x5C,0x7B,

+0x94,0x87,0x4E,0x38,0xA9,0x67,0x1A,0x69,0xD9,0x61,

+0x5E,0xD2,0x21,0xB4,0x73,0x22,0x2D,0xF9,0x04,0xFC,

+0x13,0x3B,0x5C,0x8F,0x51,0x19,0x6A,0x2F,0x32,0x97,

+0x7C,0x9F,0x6E,0x39,0x74,0xA3,0x88,0x2B,0x56,0x93,

+0x94,0x57,0xD8,0xFE,0x22,0xD9,0x59,0x6A,0x1F,0x12,

+0xDD,0x33,0x79,0x4D,0x8F,0x7F,0x8E,0x6C,0xFD,0x79,

+0x15,0xB4,0x52,0x20,0x15,0xB5,0xEC,0xDA,0x55,0xB0,

+0xD1,0xE1,0x95,0x6C,0x24,0xB9,0xB2,0x3A,0xCC,0x22,

+0x4A,0xA0,0x57,0xC4,0x6A,0xC5,0x4B,0xB5,0xEF,0x4F,

+0x1F,0x1D,0xA0,0xFD,0x48,0xCF,0x6C,0x0F,0x9E,0x9E,

+

+};

+const uint8_t refTDES_ECB_24[]={

+0xFA,0x2C,0xB2,0x40,0x09,0xB1,0xD7,0x08,0x99,0x68,

+0x9E,0x64,0x98,0x41,0x6C,0x25,0x02,0xA9,0x5B,0x2D,

+0xE8,0xDA,0x49,0x9A,0x9B,0x75,0xAC,0x98,0x7B,0x75,

+0x00,0xB5,0x19,0x81,0x2A,0xA5,0xC4,0x56,0x56,0xA4,

+0x31,0x2B,0x5F,0x11,0xC0,0x9A,0xBD,0x88,0xCC,0x61,

+0xD2,0x88,0xE5,0xAC,0x68,0xBC,0xBC,0xEF,0x5D,0x20,

+0xA5,0xD3,0x9C,0xFC,0xCF,0x84,0xC1,0x0D,0x32,0x0E,

+0xAF,0x71,0x1C,0x02,0xF4,0x2D,0xD4,0xFB,0xEC,0x44,

+0x6F,0xC4,0x8A,0x30,0x02,0x20,0x4D,0x4C,0x56,0x4F,

+0xA4,0x2B,0x2E,0x48,0xDF,0x12,0x46,0x97,0xB0,0x40,

+0x29,0xB6,0xAD,0xFA,0xF6,0x1B,0x32,0xF7,0x4E,0xDD,

+0x13,0xB1,0x72,0x94,0x6F,0x72,0xE4,0x50,0x02,0x5F,

+0xFF,0x71,0x77,0xE4,0x34,0x58,0xEC,0x45,0x49,0xE8,

+0x9E,0x09,0x92,0xBF,0xCE,0x4B,0x5B,0x0B,0x5A,0xF4,

+0xD6,0xA4,0x16,0xF5,0x1E,0x5B,0xA4,0x88,0x15,0x85,

+0xE8,0xA2,0x13,0xAA,0x16,0x47,0x95,0xB5,0xC0,0x94,

+0xA3,0x1B,0xAF,0x65,0x07,0x83,0xFF,0xCA,0xEE,0xBA,

+0xF4,0xA4,0xD5,0x96,0x2B,0x45,0xF4,0x07,0xEB,0x50,

+0xA0,0xD7,0x59,0x2B,0x6E,0x6D,0xD1,0x5D,0x9D,0x3A,

+0xEC,0x43,0x1B,0xEF,0x3C,0xAD,0x8C,0x7A,0x60,0x15,

+0x67,0x9A,0x6E,0x35,0xF1,0x09,0x7F,0xC4,0xBA,0x0A,

+0x54,0xBF,0xCF,0xE7,0x42,0x18,0xB2,0x3D,0xAB,0xF4,

+0x43,0x2F,0xF6,0xCA,0x94,0x4D,0x9A,0x16,0x14,0x90,

+0xFB,0x1D,0x30,0x05,0x37,0x69,0x5A,0xCB,0xB4,0x54,

+0x91,0x5A,0xC9,0x26,0x58,0x2B,0xE5,0x44,0x3F,0x2D,

+0x17,0xEE,0x17,0xDD,0xFD,0x37,0x73,0xFD,0xFB,0x0F,

+0xB7,0x20,0x03,0xA2,0x0F,0x8B,0xBF,0x56,0x7D,0x19,

+0xA9,0x3A,0x02,0x78,0xD2,0xDF,0xC9,0xEA,0x53,0x57,

+0xD7,0x1C,0xCE,0xBA,0x38,0xAB,0x1F,0xC1,0x1E,0x8F,

+0x55,0x27,0x61,0x98,0xA4,0x84,0xAC,0x77,0x34,0xF4,

+0xF0,0x98,0xDF,0x35,0x49,0x1D,0x73,0x9F,0xAF,0x7F,

+0x3B,0x6C,0x90,0xEE,0x6D,0xC9,0xF8,0x04,0xE7,0xFD,

+0x63,0x88,0xAA,0x22,0x84,0xCB,0xB6,0x2B,0xAA,0xD7,

+0x3F,0xBD,0xC9,0xFC,0x6C,0xAD,0x29,0xAD,0x43,0x93,

+0x18,0x99,0xE9,0x3D,0xFE,0x1A,0x6E,0xD0,0x56,0xD3,

+0x81,0x26,0xA7,0x99,0x01,0x09,0xF9,0x07,0xE1,0x3A,

+0xFC,0xEA,0xC5,0x83,0x03,0x60,0x02,0x83,0x1F,0x77,

+0x7D,0x82,0x35,0x4A,0x52,0x76,0xF5,0xE9,0xDF,0x5B,

+0xB8,0xAB,0x53,0x39,0xA7,0x8A,0x64,0xAB,0x1E,0x08,

+0x16,0x14,0x92,0x06,0x29,0xB4,0xBF,0xAA,0xE9,0xE0,

+0xFB,0xE9,0x04,0xAF,0x8A,0xBF,0xEC,0xB2,0x6C,0xBF,

+0x82,0x59,0x37,0x51,0x8D,0xF1,0x97,0x1A,0x85,0x55,

+0x55,0x6A,0xD2,0xD1,0xA9,0x7A,0xF8,0xF4,0x21,0xC9,

+0xF5,0xE1,0x2E,0x6C,0x91,0x28,0x46,0x61,0x4A,0x28,

+0xCE,0xFB,0xB4,0x07,0xA7,0xB7,0xB1,0xF7,0x92,0x5A,

+0x57,0x48,0x8F,0xF3,0x76,0xA2,0xCC,0x9D,0xA7,0x2A,

+0x87,0xB4,0x63,0xFC,0x9E,0x45,0x0A,0x04,0xC6,0x09,

+0xCF,0x1A,0x12,0x19,0xDC,0x33,0x05,0x41,0x9E,0x7F,

+0xDB,0x20,0x65,0x77,0x5B,0xB8,0x17,0x2B,0x01,0x7C,

+0x36,0xB4,0x69,0x94,0xDF,0x63,0x3D,0xFB,0x00,0xA1,

+0xC2,0x55,0xB2,0x77,0x45,0x71,0x90,0xE8,0x18,0x7D,

+0xF3,0x00,0xD5,0xAB,0xDF,0x15,0x7D,0xE9,0x57,0x49,

+0x5A,0x8D,0x7B,0xDA,0x35,0x5E,0x70,0x9F,0xF5,0xA6,

+0xBB,0x6C,0xEC,0xB3,0x82,0x84,0xFF,0xB7,0x52,0x04,

+0xBA,0x0B,0x5A,0x9E,0xE3,0x3D,0x6F,0x3B,0x78,0xC9,

+0xF7,0xB4,0x19,0x73,0xEB,0xDF,0x7A,0xD9,0x18,0xE4,

+0xB4,0x42,0xE8,0x6A,0xB9,0x0B,0xD9,0x26,0x69,0xB8,

+0xC2,0x62,0x59,0x4C,0xD6,0x2F,0xAB,0x08,0x7A,0xBF,

+0xAC,0xAA,0x71,0x8C,0xE9,0x11,0x13,0xB3,0xD3,0xEB,

+0xA5,0xDB,0x57,0x8A,0x45,0xCB,0x50,0x7E,0xE3,0xF0,

+0xEF,0x04,0xC5,0x11,0xF0,0x7F,0x5D,0xA8,0xA6,0x02,

+0x2E,0xCC,0xA6,0xB7,0xE4,0x25,0x96,0x12,0xCF,0x73,

+0xE6,0x69,0x23,0x08,0x62,0x9D,0xE2,0x4D,0x6C,0x46,

+0x0F,0x15,0x15,0x28,0xF0,0x78,0x17,0x2B,0x2C,0x14,

+

+};

+const uint8_t refTDES_CBC_16[]={

+0x0B,0x04,0xBB,0x49,0x87,0xB0,0x7B,0xB0,0xAB,0xBD,

+0x6E,0x9F,0x10,0x42,0x8B,0x3A,0x58,0x0D,0xA7,0x8F,

+0x54,0xEC,0x24,0x5A,0xE2,0xE2,0xB9,0x15,0x34,0x2B,

+0x73,0x53,0x6F,0x4C,0x58,0x3B,0xA8,0x83,0x2D,0x8A,

+0x37,0xC8,0x9A,0x75,0xCA,0xC2,0x36,0xE8,0x02,0x9F,

+0x40,0x9B,0xB1,0x21,0x1A,0x96,0x44,0x46,0x9B,0xCB,

+0xB8,0xF0,0xF5,0x8F,0x4E,0xB4,0xE6,0xD4,0x7E,0xC3,

+0xFE,0x42,0xD6,0x6C,0x08,0x9E,0x27,0xDB,0xE7,0x73,

+0x54,0x17,0x6C,0x64,0x58,0x2F,0x44,0x66,0xC2,0xEC,

+0xFE,0x85,0x46,0xDD,0x19,0xFB,0xD8,0x6C,0x2D,0x86,

+0xB4,0x89,0x1B,0x65,0xD2,0x94,0x2A,0xD5,0x5D,0x79,

+0xC0,0xB0,0x2A,0xA0,0x3B,0xB7,0x7C,0x78,0x27,0x0B,

+0x1A,0xA2,0xAB,0x49,0x16,0x70,0x89,0x38,0xA1,0x3C,

+0xE1,0x2F,0x69,0xEB,0x4B,0x71,0x33,0x26,0xAE,0xC1,

+0x1C,0x8E,0x00,0x93,0x25,0x28,0x6A,0x61,0xC0,0x6C,

+0xFE,0x50,0x90,0x40,0x84,0x7A,0xA6,0x5A,0xF8,0x70,

+0xEB,0x87,0xCF,0xE8,0xD3,0x4A,0x1C,0x30,0x87,0xDC,

+0x4F,0x5A,0xED,0x02,0x4F,0x02,0x16,0xF1,0xF0,0x41,

+0x99,0x4F,0x87,0x77,0x4B,0x1D,0x3C,0x10,0xC2,0x45,

+0x6A,0xB2,0x60,0x22,0x00,0x42,0x83,0x10,0xB0,0x4E,

+0x88,0x7A,0x1C,0x49,0xA4,0x4B,0x2B,0xA0,0xB2,0x18,

+0x19,0xF3,0x46,0x34,0xCD,0xF7,0x48,0xDF,0x97,0x1B,

+0xD5,0xC6,0x5D,0x5E,0x48,0x64,0x3A,0x03,0x80,0x55,

+0xD4,0xF7,0x28,0x47,0xA7,0xED,0xEA,0x56,0xA4,0xA8,

+0x0A,0xF4,0x97,0x05,0xB9,0x90,0x35,0x1E,0xE0,0xC3,

+0xF1,0xFA,0x24,0x5D,0x48,0xF7,0xDC,0xD6,0x7F,0x11,

+0x36,0xD3,0xFA,0x05,0xE8,0xF5,0x2B,0xD9,0x3B,0xFA,

+0x69,0xF9,0x16,0x81,0xEB,0x56,0xE8,0x23,0x44,0x42,

+0xDE,0x4C,0x36,0x88,0xD0,0x5A,0xC0,0xD1,0xF0,0xD4,

+0xA2,0x28,0x2D,0x23,0xA5,0x8A,0xD7,0x84,0xB2,0xD8,

+0x23,0x29,0x8E,0xD1,0x8C,0x3C,0x61,0x29,0x91,0x49,

+0x3F,0x33,0xE5,0xF7,0x19,0xCA,0xE7,0x81,0x97,0x18,

+0xC6,0xD3,0xD3,0xB6,0x79,0x53,0x38,0x76,0xF6,0x15,

+0xD2,0xA6,0xDC,0xBD,0x50,0x47,0x16,0x2D,0x6C,0x31,

+0x53,0x69,0x15,0x06,0x01,0x12,0x71,0xA1,0xC9,0x9D,

+0xEE,0x1A,0x40,0x44,0x61,0x08,0x65,0xA1,0x34,0x1C,

+0x6F,0xAF,0x30,0x4A,0xC0,0xD9,0x4E,0x58,0xFE,0x97,

+0x95,0xA4,0xB5,0xCA,0xCD,0x90,0x67,0xDC,0xBE,0x10,

+0x28,0x67,0xAF,0x67,0x16,0x25,0xD9,0x96,0xDC,0x5E,

+0x26,0xD3,0x55,0x70,0xE2,0xFF,0x88,0x01,0x1E,0x2C,

+0x3C,0x8A,0xD6,0x34,0xE9,0x91,0x4D,0xFD,0xAD,0x6E,

+0xC9,0x15,0xFA,0x92,0xA4,0x0E,0xBF,0x8B,0x9B,0xB5,

+0xB9,0x2E,0xE3,0xA1,0x71,0xA9,0xE6,0xD5,0xC1,0x36,

+0x56,0xF6,0xCB,0xED,0x66,0x61,0x3B,0x00,0x5B,0x44,

+0xEC,0x9F,0xD7,0xF0,0x04,0x34,0xB3,0x1A,0xF5,0x5B,

+0x49,0x6F,0x08,0xBB,0xDD,0xD1,0x02,0x28,0x23,0xB5,

+0x8F,0x19,0x1E,0x01,0x81,0x4E,0x47,0xCC,0x86,0xB4,

+0x03,0x89,0x10,0xF0,0x7F,0xCD,0x21,0x72,0x22,0x0A,

+0x5B,0xBD,0x70,0xC9,0xC9,0x79,0x79,0x1E,0x16,0x66,

+0x3C,0xF4,0x0A,0x9D,0x50,0x9A,0xCC,0x49,0x27,0x8B,

+0x30,0x8C,0x62,0xFF,0x2C,0xF8,0x79,0xBD,0x4F,0x31,

+0x6E,0xBC,0x5A,0x21,0xB5,0xB2,0xEF,0x1D,0x95,0x19,

+0xCE,0x38,0x7E,0x06,0xA5,0xB8,0x71,0xC2,0x72,0x5F,

+0x2B,0x9F,0x04,0x5E,0x94,0x46,0xD3,0x6D,0xFC,0x88,

+0x06,0xDD,0x79,0xB4,0x23,0x52,0x77,0x2F,0x93,0x17,

+0x0C,0x3D,0x24,0xDD,0x77,0x91,0x27,0xA1,0x50,0x4E,

+0x25,0x99,0x6B,0x11,0x06,0x80,0xC3,0x0C,0x47,0xB1,

+0xDB,0x31,0xDE,0x4D,0x05,0xAF,0x2C,0x73,0x94,0xA3,

+0x79,0xBB,0x03,0xB8,0xBF,0x8F,0x53,0x2E,0xBF,0x5F,

+0xA8,0x23,0x8D,0x34,0x3A,0x28,0xB4,0x02,0xD0,0x95,

+0x78,0x07,0x14,0x55,0x2A,0x2C,0xE0,0x9E,0xA9,0x67,

+0x96,0xFE,0xBB,0xE0,0x4D,0xE5,0x30,0xCB,0xA2,0x83,

+0x6A,0xA9,0x0D,0x96,0xA3,0x24,0x78,0xB1,0xD4,0xF7,

+0x07,0x70,0xE0,0xBE,0x16,0xA0,0xE1,0xB4,0x97,0x06,

+

+};

+const uint8_t refTDES_CBC_24[]={

+0x78,0xCA,0xC6,0x02,0x50,0x7C,0x1F,0x56,0xCB,0x91,

+0x27,0x7B,0xEA,0xD3,0x8F,0x9A,0xF8,0xC9,0x61,0xD0,

+0xAC,0x67,0x4C,0xE3,0x54,0xC3,0x4A,0xB0,0xDF,0x67,

+0xE8,0xF9,0x10,0xEC,0x3F,0x78,0x52,0x57,0xE8,0x66,

+0x34,0x43,0x57,0xAC,0xBC,0x31,0x14,0x9D,0x7A,0x6E,

+0x05,0x83,0x74,0xA1,0xC5,0x2D,0x15,0x47,0x3F,0x01,

+0x00,0x8C,0x42,0x6C,0xC2,0x67,0x9B,0xD8,0xFE,0xAF,

+0xA3,0x12,0xCD,0xFD,0x8A,0x51,0xC6,0x3C,0x53,0xDC,

+0xBF,0x75,0xA7,0x03,0x21,0xE6,0xE3,0x60,0xA0,0xD5,

+0x62,0xF5,0x16,0x8B,0x89,0xFE,0x6A,0x18,0x57,0x5A,

+0x01,0xE7,0xFF,0x67,0x75,0xC6,0x3A,0xE7,0xD2,0x38,

+0xBC,0x1F,0x3A,0xD9,0x0A,0x25,0xCD,0x44,0xA5,0x2D,

+0x76,0xBA,0x04,0xF5,0x06,0xEA,0x46,0x2B,0x91,0xFF,

+0xA8,0x70,0xA3,0x71,0xDB,0x22,0x32,0x80,0x82,0xAA,

+0x76,0x0B,0x09,0xB4,0x2E,0x15,0x40,0x05,0x86,0xBA,

+0xE6,0x3A,0x27,0x40,0x8F,0x35,0xBF,0xC6,0xC7,0xA7,

+0xA8,0xC8,0x7A,0x6F,0x0A,0xE5,0x7F,0x06,0x9F,0xCD,

+0x6C,0x25,0x37,0x04,0x77,0xEB,0x55,0x89,0x5F,0x7A,

+0xA7,0x72,0xB6,0x4D,0xEB,0x12,0x0D,0x37,0x15,0xC2,

+0xB0,0x64,0x79,0xB7,0x31,0xBA,0x74,0x2F,0x5B,0x90,

+0x44,0xC5,0x06,0xAF,0xF3,0x3F,0xC4,0x1C,0x29,0x6D,

+0xD5,0x26,0x96,0x0C,0xBB,0x44,0x35,0xC4,0x65,0x5A,

+0x9A,0x3A,0x6B,0x2E,0xDC,0xF3,0xD2,0x58,0xF9,0xE9,

+0xC1,0xEC,0x91,0xF5,0x64,0xC7,0xE2,0x3C,0x68,0x7C,

+0xC5,0xCE,0x69,0xB8,0xDC,0x69,0xE9,0x5C,0x74,0x3F,

+0xF5,0xA3,0x56,0x29,0x7D,0x56,0x04,0x6C,0xEE,0x8C,

+0xB1,0xDE,0x00,0xA5,0x55,0x7C,0x21,0xFC,0x45,0xC7,

+0xE2,0x78,0xE8,0x10,0xE2,0xCE,0x23,0x6B,0xD6,0x44,

+0x56,0x80,0xE7,0x59,0xCE,0x70,0x91,0x62,0xF9,0xCF,

+0xE1,0x62,0xAC,0x72,0x36,0x33,0xC0,0x37,0x89,0xED,

+0xE3,0xA4,0xAE,0xB1,0x4F,0xD5,0x31,0x0F,0x22,0x5E,

+0x75,0x4E,0x34,0x44,0x7F,0xC9,0xF0,0xE7,0xE0,0x06,

+0x2F,0xBB,0xB7,0xB9,0x26,0xFC,0x6E,0xEC,0x21,0x47,

+0xDF,0xF9,0x67,0x1B,0x23,0xA1,0x69,0xBD,0xCE,0x2F,

+0x58,0x59,0xA5,0x31,0x17,0xD5,0x31,0x5F,0x98,0xFC,

+0xBF,0x63,0xEC,0x1B,0x1D,0xD2,0xBE,0x99,0x6E,0x8E,

+0xFC,0xF1,0x0B,0xE8,0x46,0x87,0xDE,0xED,0x58,0xC6,

+0xA2,0xD0,0x50,0x72,0x7B,0x23,0x0F,0xBF,0xFA,0xBA,

+0x3E,0xCD,0x13,0x80,0x90,0xC5,0xFC,0xA7,0x2B,0x73,

+0x06,0x2E,0xA8,0x9B,0x73,0xD5,0xA4,0x4F,0xCB,0x75,

+0x4C,0xB2,0x74,0xC8,0xBF,0x8D,0xBC,0x83,0x0C,0xC9,

+0xEA,0x9D,0x32,0x95,0x62,0x28,0xEB,0x03,0x2D,0xD7,

+0x90,0x14,0xA4,0x31,0x7A,0x6C,0xCD,0xBF,0x2A,0xA9,

+0x9B,0x68,0x74,0x72,0x25,0x87,0x0B,0x99,0xCE,0xA6,

+0xA4,0xFC,0x44,0x17,0x37,0x17,0xE7,0xEA,0x3E,0xEA,

+0xA2,0xA5,0x38,0xB3,0x2C,0xB4,0x1B,0xA6,0xA9,0xC9,

+0x7D,0xB5,0x2E,0xCA,0x13,0x67,0xF7,0x9C,0xF3,0x91,

+0x2D,0xBD,0x2D,0xCE,0x1F,0x22,0xE7,0x2E,0x1E,0xA0,

+0xC7,0x07,0xA6,0x42,0xFF,0xCC,0xC2,0x1A,0x16,0xB6,

+0x7D,0x33,0x93,0x58,0x58,0x17,0xD2,0x59,0xE6,0xD2,

+0x5C,0x5E,0xEF,0x88,0xD1,0x75,0xDA,0x27,0x3E,0xD0,

+0xAF,0xCA,0xDE,0x87,0x93,0x08,0x55,0x5F,0x01,0xC3,

+0x11,0xCB,0xF7,0xD6,0xE1,0x44,0x91,0x96,0x1C,0x8E,

+0xD5,0xFA,0x23,0xE1,0xC0,0xCA,0xA0,0x50,0xCB,0x5E,

+0xCE,0x9D,0xE6,0x7E,0xF5,0x00,0xA5,0x59,0x2D,0x89,

+0x78,0x61,0xAC,0x5B,0xE3,0xC1,0x75,0xB9,0x42,0x29,

+0xE9,0x25,0x1C,0x8B,0x4A,0x08,0xCC,0x06,0xC7,0x5B,

+0x28,0x3C,0xCF,0xF5,0xC3,0x9E,0x56,0x16,0x0C,0x36,

+0x06,0x28,0x3F,0xD3,0x1B,0x86,0xAC,0xF7,0x57,0x7B,

+0xCF,0x3F,0x24,0x3E,0x92,0xB1,0x89,0x8A,0x40,0xDD,

+0x77,0xEA,0x6F,0xE5,0x9C,0x26,0xF9,0xD9,0x75,0x08,

+0x6B,0xD0,0xD1,0xF3,0xDD,0xCB,0x39,0x07,0xCE,0xC0,

+0xAE,0xD1,0xB9,0x4E,0x22,0x21,0xDB,0xC1,0x9D,0xED,

+0x9F,0xE1,0xBA,0x29,0x60,0x18,0xC5,0x7F,0x7B,0x5E,

+

+};

diff --git a/test/crypto/source/testref/ref_des.h b/test/crypto/source/testref/ref_des.h
new file mode 100644
index 000000000..c839084b7
--- /dev/null
+++ b/test/crypto/source/testref/ref_des.h
@@ -0,0 +1,24 @@
+/*

+    ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio

+

+    Licensed under the Apache License, Version 2.0 (the "License");

+    you may not use this file except in compliance with the License.

+    You may obtain a copy of the License at

+

+        http://www.apache.org/licenses/LICENSE-2.0

+

+    Unless required by applicable law or agreed to in writing, software

+    distributed under the License is distributed on an "AS IS" BASIS,

+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+    See the License for the specific language governing permissions and

+    limitations under the License.

+*/

+#ifndef TEST_REF_DES_H_

+#define TEST_REF_DES_H_

+

+extern const uint8_t refDES_ECB_8[];

+extern const uint8_t refTDES_ECB_16[];

+extern const uint8_t refTDES_ECB_24[];

+extern const uint8_t refTDES_CBC_16[];

+extern const uint8_t refTDES_CBC_24[];

+#endif //TEST_REF_DES_H_