mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_crypto.c@161:2cc1468da177, 2017-03-30 (annotated)

Committer:: <>
Date:: Thu Mar 30 13:45:57 2017 +0100
Revision:: 161:2cc1468da177
Parent:: 150:02e0a0aed4ec
Child:: 179:b0033dcd6934

This updates the lib to the mbed lib v139

Who changed what in which revision?

User	Revision	Line number	New contents of line
mbed_official	50:a417edff4437	1	/*************************************************************************//
mbed_official	50:a417edff4437	2	* @file em_crypto.c
mbed_official	50:a417edff4437	3	* @brief Cryptography accelerator peripheral API
<>	161:2cc1468da177	4	* @version 5.1.2
mbed_official	50:a417edff4437	5	*******************************************************************************
mbed_official	50:a417edff4437	6	* @section License
<>	150:02e0a0aed4ec	7	* <b>Copyright 2016 Silicon Laboratories, Inc. http://www.silabs.com</b>
mbed_official	50:a417edff4437	8	*******************************************************************************
mbed_official	50:a417edff4437	9	*
mbed_official	50:a417edff4437	10	* Permission is granted to anyone to use this software for any purpose,
mbed_official	50:a417edff4437	11	* including commercial applications, and to alter it and redistribute it
mbed_official	50:a417edff4437	12	* freely, subject to the following restrictions:
mbed_official	50:a417edff4437	13	*
mbed_official	50:a417edff4437	14	* 1. The origin of this software must not be misrepresented; you must not
mbed_official	50:a417edff4437	15	* claim that you wrote the original software.@n
mbed_official	50:a417edff4437	16	* 2. Altered source versions must be plainly marked as such, and must not be
mbed_official	50:a417edff4437	17	* misrepresented as being the original software.@n
mbed_official	50:a417edff4437	18	* 3. This notice may not be removed or altered from any source distribution.
mbed_official	50:a417edff4437	19	*
mbed_official	50:a417edff4437	20	* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no
mbed_official	50:a417edff4437	21	* obligation to support this Software. Silicon Labs is providing the
mbed_official	50:a417edff4437	22	* Software "AS IS", with no express or implied warranties of any kind,
mbed_official	50:a417edff4437	23	* including, but not limited to, any implied warranties of merchantability
mbed_official	50:a417edff4437	24	* or fitness for any particular purpose or warranties against infringement
mbed_official	50:a417edff4437	25	* of any proprietary rights of a third party.
mbed_official	50:a417edff4437	26	*
mbed_official	50:a417edff4437	27	* Silicon Labs will not be liable for any consequential, incidental, or
mbed_official	50:a417edff4437	28	* special damages, or any other relief, or for any claim by any third party,
mbed_official	50:a417edff4437	29	* arising from your use of this Software.
mbed_official	50:a417edff4437	30	*
mbed_official	50:a417edff4437	31	******************************************************************************/
mbed_official	50:a417edff4437	32	#include "em_device.h"
mbed_official	50:a417edff4437	33
mbed_official	50:a417edff4437	34	#if defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0)
mbed_official	50:a417edff4437	35
mbed_official	50:a417edff4437	36	#include "em_crypto.h"
mbed_official	50:a417edff4437	37	#include "em_assert.h"
mbed_official	50:a417edff4437	38
mbed_official	50:a417edff4437	39	/*************************************************************************//
<>	150:02e0a0aed4ec	40	* @addtogroup emlib
mbed_official	50:a417edff4437	41	* @{
mbed_official	50:a417edff4437	42	******************************************************************************/
mbed_official	50:a417edff4437	43
mbed_official	50:a417edff4437	44	/*************************************************************************//
mbed_official	50:a417edff4437	45	* @addtogroup CRYPTO
mbed_official	50:a417edff4437	46	* @{
mbed_official	50:a417edff4437	47	******************************************************************************/
mbed_official	50:a417edff4437	48
mbed_official	50:a417edff4437	49	/*******************************************************************************
mbed_official	50:a417edff4437	50	***************************** DEFINES *********************************
mbed_official	50:a417edff4437	51	******************************************************************************/
mbed_official	50:a417edff4437	52
mbed_official	50:a417edff4437	53	/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
mbed_official	50:a417edff4437	54
mbed_official	50:a417edff4437	55	#define CRYPTO_INSTRUCTIONS_PER_REG (4)
mbed_official	50:a417edff4437	56	#define CRYPTO_INSTRUCTIONS_MAX (12)
mbed_official	50:a417edff4437	57	#define CRYPTO_INSTRUCTION_REGS (CRYPTO_INSTRUCTIONS_MAX/CRYPTO_INSTRUCTIONS_PER_REG)
mbed_official	50:a417edff4437	58
mbed_official	50:a417edff4437	59	#define CRYPTO_SHA1_BLOCK_SIZE_IN_BITS (512)
mbed_official	50:a417edff4437	60	#define CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES (CRYPTO_SHA1_BLOCK_SIZE_IN_BITS/8)
mbed_official	50:a417edff4437	61	#define CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS (CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES/sizeof(uint32_t))
mbed_official	50:a417edff4437	62	#define CRYPTO_SHA1_DIGEST_SIZE_IN_32BIT_WORDS (CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES/sizeof(uint32_t))
mbed_official	50:a417edff4437	63
mbed_official	50:a417edff4437	64	#define CRYPTO_SHA256_BLOCK_SIZE_IN_BITS (512)
mbed_official	50:a417edff4437	65	#define CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES (CRYPTO_SHA256_BLOCK_SIZE_IN_BITS/8)
mbed_official	50:a417edff4437	66	#define CRYPTO_SHA256_BLOCK_SIZE_IN_32BIT_WORDS (CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES/sizeof(uint32_t))
mbed_official	50:a417edff4437	67
mbed_official	50:a417edff4437	68	#define CRYPTO_SHA256_DIGEST_SIZE_IN_32BIT_WORDS (CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES/sizeof(uint32_t))
mbed_official	50:a417edff4437	69
mbed_official	50:a417edff4437	70	#define PARTIAL_OPERAND_WIDTH_LOG2 (7) /* 2^7 = 128 */
mbed_official	50:a417edff4437	71	#define PARTIAL_OPERAND_WIDTH (1<<PARTIAL_OPERAND_WIDTH_LOG2)
mbed_official	50:a417edff4437	72	#define PARTIAL_OPERAND_WIDTH_MASK (PARTIAL_OPERAND_WIDTH-1)
mbed_official	50:a417edff4437	73	#define PARTIAL_OPERAND_WIDTH_IN_BYTES (PARTIAL_OPERAND_WIDTH/8)
mbed_official	50:a417edff4437	74	#define PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS (PARTIAL_OPERAND_WIDTH_IN_BYTES/sizeof(uint32_t))
mbed_official	50:a417edff4437	75
mbed_official	50:a417edff4437	76	#define SWAP32(x) (__REV(x))
mbed_official	50:a417edff4437	77
mbed_official	50:a417edff4437	78	#define CRYPTO_AES_BLOCKSIZE (16)
mbed_official	50:a417edff4437	79
mbed_official	50:a417edff4437	80	/*******************************************************************************
mbed_official	50:a417edff4437	81	********************* STATIC FUNCTIONS ********************************
mbed_official	50:a417edff4437	82	******************************************************************************/
mbed_official	50:a417edff4437	83
<>	150:02e0a0aed4ec	84	static inline void CRYPTO_AES_ProcessLoop(CRYPTO_TypeDef *crypto,
<>	150:02e0a0aed4ec	85	uint32_t len,
mbed_official	50:a417edff4437	86	CRYPTO_DataReg_TypeDef inReg,
mbed_official	50:a417edff4437	87	uint32_t * in,
mbed_official	50:a417edff4437	88	CRYPTO_DataReg_TypeDef outReg,
mbed_official	50:a417edff4437	89	uint32_t * out);
mbed_official	50:a417edff4437	90
<>	150:02e0a0aed4ec	91	static void CRYPTO_AES_CBCx(CRYPTO_TypeDef *crypto,
<>	150:02e0a0aed4ec	92	uint8_t * out,
mbed_official	50:a417edff4437	93	const uint8_t * in,
mbed_official	50:a417edff4437	94	unsigned int len,
mbed_official	50:a417edff4437	95	const uint8_t * key,
mbed_official	50:a417edff4437	96	const uint8_t * iv,
mbed_official	50:a417edff4437	97	bool encrypt,
mbed_official	50:a417edff4437	98	CRYPTO_KeyWidth_TypeDef keyWidth);
mbed_official	50:a417edff4437	99
<>	150:02e0a0aed4ec	100	static void CRYPTO_AES_CFBx(CRYPTO_TypeDef *crypto,
<>	150:02e0a0aed4ec	101	uint8_t * out,
mbed_official	50:a417edff4437	102	const uint8_t * in,
mbed_official	50:a417edff4437	103	unsigned int len,
mbed_official	50:a417edff4437	104	const uint8_t * key,
mbed_official	50:a417edff4437	105	const uint8_t * iv,
mbed_official	50:a417edff4437	106	bool encrypt,
mbed_official	50:a417edff4437	107	CRYPTO_KeyWidth_TypeDef keyWidth);
mbed_official	50:a417edff4437	108
<>	150:02e0a0aed4ec	109	static void CRYPTO_AES_CTRx(CRYPTO_TypeDef *crypto,
<>	150:02e0a0aed4ec	110	uint8_t * out,
mbed_official	50:a417edff4437	111	const uint8_t * in,
mbed_official	50:a417edff4437	112	unsigned int len,
mbed_official	50:a417edff4437	113	const uint8_t * key,
mbed_official	50:a417edff4437	114	uint8_t * ctr,
mbed_official	50:a417edff4437	115	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc,
mbed_official	50:a417edff4437	116	CRYPTO_KeyWidth_TypeDef keyWidth);
mbed_official	50:a417edff4437	117
<>	150:02e0a0aed4ec	118	static void CRYPTO_AES_ECBx(CRYPTO_TypeDef *crypto,
<>	150:02e0a0aed4ec	119	uint8_t * out,
mbed_official	50:a417edff4437	120	const uint8_t * in,
mbed_official	50:a417edff4437	121	unsigned int len,
mbed_official	50:a417edff4437	122	const uint8_t * key,
mbed_official	50:a417edff4437	123	bool encrypt,
mbed_official	50:a417edff4437	124	CRYPTO_KeyWidth_TypeDef keyWidth);
mbed_official	50:a417edff4437	125
<>	150:02e0a0aed4ec	126	static void CRYPTO_AES_OFBx(CRYPTO_TypeDef *crypto,
<>	150:02e0a0aed4ec	127	uint8_t * out,
mbed_official	50:a417edff4437	128	const uint8_t * in,
mbed_official	50:a417edff4437	129	unsigned int len,
mbed_official	50:a417edff4437	130	const uint8_t * key,
mbed_official	50:a417edff4437	131	const uint8_t * iv,
mbed_official	50:a417edff4437	132	CRYPTO_KeyWidth_TypeDef keyWidth);
mbed_official	50:a417edff4437	133
mbed_official	50:a417edff4437	134	#ifdef USE_VARIABLE_SIZED_DATA_LOADS
mbed_official	50:a417edff4437	135	/*************************************************************************//
mbed_official	50:a417edff4437	136	* @brief
mbed_official	50:a417edff4437	137	* Write variable sized 32 bit data array (max 128 bits) to a DATAX register
mbed_official	50:a417edff4437	138	*
mbed_official	50:a417edff4437	139	* @details
mbed_official	50:a417edff4437	140	* Write variable sized 32 bit array (max 128 bits / 4 words) to a DATAX
mbed_official	50:a417edff4437	141	* register in the CRYPTO module.
mbed_official	50:a417edff4437	142	*
mbed_official	50:a417edff4437	143	* @param[in] dataReg The 128 bits DATA register.
mbed_official	50:a417edff4437	144	* @param[in] val Value of the data to write to the DATA register.
mbed_official	50:a417edff4437	145	* @param[in] valSize Size of @ref val in number of 32bit words.
mbed_official	50:a417edff4437	146	******************************************************************************/
mbed_official	50:a417edff4437	147	__STATIC_INLINE
mbed_official	50:a417edff4437	148	void CRYPTO_DataWriteVariableSize(CRYPTO_DataReg_TypeDef dataReg,
mbed_official	50:a417edff4437	149	const CRYPTO_Data_TypeDef val,
mbed_official	50:a417edff4437	150	int valSize)
mbed_official	50:a417edff4437	151	{
mbed_official	50:a417edff4437	152	int i;
mbed_official	50:a417edff4437	153	volatile uint32_t * reg = (volatile uint32_t *) dataReg;
<>	150:02e0a0aed4ec	154
mbed_official	50:a417edff4437	155	if (valSize < 4)
mbed_official	50:a417edff4437	156	{
mbed_official	50:a417edff4437	157	/* Non optimal write of data. */
mbed_official	50:a417edff4437	158	for (i = 0; i < valSize; i++)
mbed_official	50:a417edff4437	159	reg = val++;
mbed_official	50:a417edff4437	160	for (; i < 4; i++)
mbed_official	50:a417edff4437	161	*reg = 0;
mbed_official	50:a417edff4437	162	}
mbed_official	50:a417edff4437	163	else
mbed_official	50:a417edff4437	164	{
mbed_official	50:a417edff4437	165	CRYPTO_BurstToCrypto(reg, &val[0]);
mbed_official	50:a417edff4437	166	}
mbed_official	50:a417edff4437	167	}
mbed_official	50:a417edff4437	168	#endif
mbed_official	50:a417edff4437	169
mbed_official	50:a417edff4437	170	/** @endcond */
mbed_official	50:a417edff4437	171
mbed_official	50:a417edff4437	172	/*******************************************************************************
mbed_official	50:a417edff4437	173	************************ GLOBAL FUNCTIONS *****************************
mbed_official	50:a417edff4437	174	******************************************************************************/
mbed_official	50:a417edff4437	175
mbed_official	50:a417edff4437	176	/*************************************************************************//
mbed_official	50:a417edff4437	177	* @brief
<>	150:02e0a0aed4ec	178	* Set the modulus used for wide modular operations.
mbed_official	50:a417edff4437	179	*
mbed_official	50:a417edff4437	180	* @details
<>	150:02e0a0aed4ec	181	* This function sets the modulus to be used by the modular instructions
mbed_official	50:a417edff4437	182	* of the CRYPTO module.
mbed_official	50:a417edff4437	183	*
<>	150:02e0a0aed4ec	184	* @param[in] crypto
<>	150:02e0a0aed4ec	185	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	186	*
<>	150:02e0a0aed4ec	187	* @param[in] modulusId
<>	150:02e0a0aed4ec	188	* Modulus identifier.
mbed_official	50:a417edff4437	189	******************************************************************************/
<>	150:02e0a0aed4ec	190	void CRYPTO_ModulusSet(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	191	CRYPTO_ModulusId_TypeDef modulusId)
mbed_official	50:a417edff4437	192	{
<>	150:02e0a0aed4ec	193	uint32_t temp = crypto->WAC & (~(_CRYPTO_WAC_MODULUS_MASK \| _CRYPTO_WAC_MODOP_MASK));
mbed_official	50:a417edff4437	194
<>	150:02e0a0aed4ec	195	switch (modulusId)
mbed_official	50:a417edff4437	196	{
mbed_official	50:a417edff4437	197	case cryptoModulusBin256:
mbed_official	50:a417edff4437	198	case cryptoModulusBin128:
mbed_official	50:a417edff4437	199	case cryptoModulusGcmBin128:
mbed_official	50:a417edff4437	200	case cryptoModulusEccB233:
mbed_official	50:a417edff4437	201	case cryptoModulusEccB163:
mbed_official	50:a417edff4437	202	#ifdef _CRYPTO_WAC_MODULUS_ECCBIN233N
mbed_official	50:a417edff4437	203	case cryptoModulusEccB233Order:
mbed_official	50:a417edff4437	204	case cryptoModulusEccB233KOrder:
mbed_official	50:a417edff4437	205	case cryptoModulusEccB163Order:
mbed_official	50:a417edff4437	206	case cryptoModulusEccB163KOrder:
mbed_official	50:a417edff4437	207	#endif
<>	150:02e0a0aed4ec	208	crypto->WAC = temp \| modulusId \| CRYPTO_WAC_MODOP_BINARY;
mbed_official	50:a417edff4437	209	break;
mbed_official	50:a417edff4437	210
mbed_official	50:a417edff4437	211	case cryptoModulusEccP256:
mbed_official	50:a417edff4437	212	case cryptoModulusEccP224:
mbed_official	50:a417edff4437	213	case cryptoModulusEccP192:
mbed_official	50:a417edff4437	214	#ifdef _CRYPTO_WAC_MODULUS_ECCPRIME256P
mbed_official	50:a417edff4437	215	case cryptoModulusEccP256Order:
mbed_official	50:a417edff4437	216	case cryptoModulusEccP224Order:
mbed_official	50:a417edff4437	217	case cryptoModulusEccP192Order:
mbed_official	50:a417edff4437	218	#endif
<>	150:02e0a0aed4ec	219	crypto->WAC = temp \| modulusId \| CRYPTO_WAC_MODOP_REGULAR;
mbed_official	50:a417edff4437	220	break;
mbed_official	50:a417edff4437	221
mbed_official	50:a417edff4437	222	default:
<>	150:02e0a0aed4ec	223	/* Unknown modulus identifier. */
mbed_official	50:a417edff4437	224	EFM_ASSERT(0);
mbed_official	50:a417edff4437	225	}
mbed_official	50:a417edff4437	226	}
mbed_official	50:a417edff4437	227
mbed_official	50:a417edff4437	228	/*************************************************************************//
mbed_official	50:a417edff4437	229	* @brief
mbed_official	50:a417edff4437	230	* Read the key value currently used by the CRYPTO module.
mbed_official	50:a417edff4437	231	*
mbed_official	50:a417edff4437	232	* @details
mbed_official	50:a417edff4437	233	* Read 128 bits or 256 bits from KEY register in the CRYPTO module.
mbed_official	50:a417edff4437	234	*
<>	150:02e0a0aed4ec	235	* @param[in] crypto
<>	150:02e0a0aed4ec	236	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	237	*
<>	150:02e0a0aed4ec	238	* @param[in] val
<>	150:02e0a0aed4ec	239	* Value of the data to write to the KEYBUF register.
<>	150:02e0a0aed4ec	240	*
<>	150:02e0a0aed4ec	241	* @param[in] keyWidth
<>	150:02e0a0aed4ec	242	* Key width - 128 or 256 bits
mbed_official	50:a417edff4437	243	******************************************************************************/
<>	150:02e0a0aed4ec	244	void CRYPTO_KeyRead(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	245	CRYPTO_KeyBuf_TypeDef val,
mbed_official	50:a417edff4437	246	CRYPTO_KeyWidth_TypeDef keyWidth)
mbed_official	50:a417edff4437	247	{
mbed_official	50:a417edff4437	248	EFM_ASSERT(val);
mbed_official	50:a417edff4437	249
<>	150:02e0a0aed4ec	250	CRYPTO_BurstFromCrypto(&crypto->KEY, &val[0]);
mbed_official	50:a417edff4437	251	if (keyWidth == cryptoKey256Bits)
mbed_official	50:a417edff4437	252	{
<>	150:02e0a0aed4ec	253	CRYPTO_BurstFromCrypto(&crypto->KEY, &val[4]);
mbed_official	50:a417edff4437	254	}
mbed_official	50:a417edff4437	255	}
mbed_official	50:a417edff4437	256
mbed_official	50:a417edff4437	257	/*************************************************************************//
mbed_official	50:a417edff4437	258	* @brief
mbed_official	50:a417edff4437	259	* Perform a SHA-1 hash operation on a message.
mbed_official	50:a417edff4437	260	*
mbed_official	50:a417edff4437	261	* @details
mbed_official	50:a417edff4437	262	* This function performs a SHA-1 hash operation on the message specified by
mbed_official	50:a417edff4437	263	* msg with length msgLen, and returns the message digest in msgDigest.
mbed_official	50:a417edff4437	264	*
<>	150:02e0a0aed4ec	265	* @param[in] crypto
<>	150:02e0a0aed4ec	266	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	267	*
<>	150:02e0a0aed4ec	268	* @param[in] msg
<>	150:02e0a0aed4ec	269	* Message to hash.
<>	150:02e0a0aed4ec	270	*
<>	150:02e0a0aed4ec	271	* @param[in] msgLen
<>	150:02e0a0aed4ec	272	* Length of message in bytes.
<>	150:02e0a0aed4ec	273	*
<>	150:02e0a0aed4ec	274	* @param[out] msgDigest
<>	150:02e0a0aed4ec	275	* Message digest.
mbed_official	50:a417edff4437	276	******************************************************************************/
<>	150:02e0a0aed4ec	277	void CRYPTO_SHA_1(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	278	const uint8_t * msg,
mbed_official	50:a417edff4437	279	uint64_t msgLen,
mbed_official	50:a417edff4437	280	CRYPTO_SHA1_Digest_TypeDef msgDigest)
mbed_official	50:a417edff4437	281	{
mbed_official	50:a417edff4437	282	uint32_t temp;
<>	150:02e0a0aed4ec	283	uint32_t len;
mbed_official	50:a417edff4437	284	int blockLen;
mbed_official	50:a417edff4437	285	uint32_t shaBlock[CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS]=
mbed_official	50:a417edff4437	286	{
mbed_official	50:a417edff4437	287	/* Initial value */
mbed_official	50:a417edff4437	288	0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
mbed_official	50:a417edff4437	289	};
mbed_official	50:a417edff4437	290	uint8_t * p8ShaBlock = (uint8_t *) shaBlock;
mbed_official	50:a417edff4437	291
mbed_official	50:a417edff4437	292	/* Initialize crypto module to do SHA-1. */
<>	150:02e0a0aed4ec	293	crypto->CTRL = CRYPTO_CTRL_SHA_SHA1;
<>	150:02e0a0aed4ec	294	crypto->SEQCTRL = 0;
<>	150:02e0a0aed4ec	295	crypto->SEQCTRLB = 0;
mbed_official	50:a417edff4437	296
mbed_official	50:a417edff4437	297	/* Set result width of MADD32 operation. */
<>	150:02e0a0aed4ec	298	CRYPTO_ResultWidthSet(crypto, cryptoResult256Bits);
<>	150:02e0a0aed4ec	299
mbed_official	50:a417edff4437	300	/* Write init value to DDATA1. */
<>	150:02e0a0aed4ec	301	CRYPTO_DDataWrite(&crypto->DDATA1, shaBlock);
mbed_official	50:a417edff4437	302
mbed_official	50:a417edff4437	303	/* Copy data to DDATA0 and select DDATA0 and DDATA1 for SHA operation. */
<>	150:02e0a0aed4ec	304	CRYPTO_EXECUTE_2(crypto,
<>	150:02e0a0aed4ec	305	CRYPTO_CMD_INSTR_DDATA1TODDATA0,
mbed_official	50:a417edff4437	306	CRYPTO_CMD_INSTR_SELDDATA0DDATA1);
mbed_official	50:a417edff4437	307
mbed_official	50:a417edff4437	308	len = msgLen;
mbed_official	50:a417edff4437	309
mbed_official	50:a417edff4437	310	while (len >= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES)
mbed_official	50:a417edff4437	311	{
mbed_official	50:a417edff4437	312	/* Write block to QDATA1. */
<>	150:02e0a0aed4ec	313	CRYPTO_QDataWrite(&crypto->QDATA1BIG, (uint32_t *) msg);
mbed_official	50:a417edff4437	314
mbed_official	50:a417edff4437	315	/* Execute SHA */
<>	150:02e0a0aed4ec	316	CRYPTO_EXECUTE_3(crypto,
<>	150:02e0a0aed4ec	317	CRYPTO_CMD_INSTR_SHA,
mbed_official	50:a417edff4437	318	CRYPTO_CMD_INSTR_MADD32,
mbed_official	50:a417edff4437	319	CRYPTO_CMD_INSTR_DDATA0TODDATA1);
mbed_official	50:a417edff4437	320
mbed_official	50:a417edff4437	321	len -= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES;
mbed_official	50:a417edff4437	322	msg += CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES;
mbed_official	50:a417edff4437	323	}
mbed_official	50:a417edff4437	324
mbed_official	50:a417edff4437	325	blockLen = 0;
mbed_official	50:a417edff4437	326
mbed_official	50:a417edff4437	327	/* Build the last (or second to last) block */
mbed_official	50:a417edff4437	328	for (; len; len--)
mbed_official	50:a417edff4437	329	p8ShaBlock[blockLen++] = *msg++;
mbed_official	50:a417edff4437	330
mbed_official	50:a417edff4437	331	/* append the '1' bit */
mbed_official	50:a417edff4437	332	p8ShaBlock[blockLen++] = 0x80;
mbed_official	50:a417edff4437	333
mbed_official	50:a417edff4437	334	/* if the length is currently above 56 bytes we append zeros
mbed_official	50:a417edff4437	335	* then compress. Then we can fall back to padding zeros and length
mbed_official	50:a417edff4437	336	* encoding like normal.
mbed_official	50:a417edff4437	337	*/
mbed_official	50:a417edff4437	338	if (blockLen > 56)
mbed_official	50:a417edff4437	339	{
mbed_official	50:a417edff4437	340	while (blockLen < 64)
mbed_official	50:a417edff4437	341	p8ShaBlock[blockLen++] = 0;
mbed_official	50:a417edff4437	342
mbed_official	50:a417edff4437	343	/* Write block to QDATA1BIG. */
<>	150:02e0a0aed4ec	344	CRYPTO_QDataWrite(&crypto->QDATA1BIG, shaBlock);
mbed_official	50:a417edff4437	345
mbed_official	50:a417edff4437	346	/* Execute SHA */
<>	150:02e0a0aed4ec	347	CRYPTO_EXECUTE_3(crypto,
<>	150:02e0a0aed4ec	348	CRYPTO_CMD_INSTR_SHA,
mbed_official	50:a417edff4437	349	CRYPTO_CMD_INSTR_MADD32,
mbed_official	50:a417edff4437	350	CRYPTO_CMD_INSTR_DDATA0TODDATA1);
mbed_official	50:a417edff4437	351	blockLen = 0;
mbed_official	50:a417edff4437	352	}
mbed_official	50:a417edff4437	353
mbed_official	50:a417edff4437	354	/* pad upto 56 bytes of zeroes */
mbed_official	50:a417edff4437	355	while (blockLen < 56)
mbed_official	50:a417edff4437	356	p8ShaBlock[blockLen++] = 0;
mbed_official	50:a417edff4437	357
mbed_official	50:a417edff4437	358	/* And finally, encode the message length. */
mbed_official	50:a417edff4437	359	{
mbed_official	50:a417edff4437	360	uint64_t msgLenInBits = msgLen << 3;
mbed_official	50:a417edff4437	361	temp = msgLenInBits >> 32;
mbed_official	50:a417edff4437	362	(uint32_t)&p8ShaBlock[56] = SWAP32(temp);
mbed_official	50:a417edff4437	363	temp = msgLenInBits & 0xFFFFFFFF;
mbed_official	50:a417edff4437	364	(uint32_t)&p8ShaBlock[60] = SWAP32(temp);
mbed_official	50:a417edff4437	365	}
mbed_official	50:a417edff4437	366
mbed_official	50:a417edff4437	367	/* Write block to QDATA1BIG. */
<>	150:02e0a0aed4ec	368	CRYPTO_QDataWrite(&crypto->QDATA1BIG, shaBlock);
mbed_official	50:a417edff4437	369
mbed_official	50:a417edff4437	370	/* Execute SHA */
<>	150:02e0a0aed4ec	371	CRYPTO_EXECUTE_3(crypto,
<>	150:02e0a0aed4ec	372	CRYPTO_CMD_INSTR_SHA,
mbed_official	50:a417edff4437	373	CRYPTO_CMD_INSTR_MADD32,
mbed_official	50:a417edff4437	374	CRYPTO_CMD_INSTR_DDATA0TODDATA1);
mbed_official	50:a417edff4437	375
mbed_official	50:a417edff4437	376	/* Read resulting message digest from DDATA0BIG. */
<>	150:02e0a0aed4ec	377	((uint32_t*)msgDigest)[0] = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	378	((uint32_t*)msgDigest)[1] = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	379	((uint32_t*)msgDigest)[2] = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	380	((uint32_t*)msgDigest)[3] = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	381	((uint32_t*)msgDigest)[4] = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	382	temp = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	383	temp = crypto->DDATA0BIG;
<>	150:02e0a0aed4ec	384	temp = crypto->DDATA0BIG;
mbed_official	50:a417edff4437	385	}
mbed_official	50:a417edff4437	386
mbed_official	50:a417edff4437	387	/*************************************************************************//
mbed_official	50:a417edff4437	388	* @brief
mbed_official	50:a417edff4437	389	* Perform a SHA-256 hash operation on a message.
mbed_official	50:a417edff4437	390	*
mbed_official	50:a417edff4437	391	* @details
mbed_official	50:a417edff4437	392	* This function performs a SHA-256 hash operation on the message specified
mbed_official	50:a417edff4437	393	* by msg with length msgLen, and returns the message digest in msgDigest.
mbed_official	50:a417edff4437	394	*
<>	150:02e0a0aed4ec	395	* @param[in] crypto
<>	150:02e0a0aed4ec	396	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	397	*
<>	150:02e0a0aed4ec	398	* @param[in] msg
<>	150:02e0a0aed4ec	399	* Message to hash.
<>	150:02e0a0aed4ec	400	*
<>	150:02e0a0aed4ec	401	* @param[in] msgLen
<>	150:02e0a0aed4ec	402	* Length of message in bytes.
<>	150:02e0a0aed4ec	403	*
<>	150:02e0a0aed4ec	404	* @param[out] msgDigest
<>	150:02e0a0aed4ec	405	* Message digest.
mbed_official	50:a417edff4437	406	******************************************************************************/
<>	150:02e0a0aed4ec	407	void CRYPTO_SHA_256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	408	const uint8_t * msg,
mbed_official	50:a417edff4437	409	uint64_t msgLen,
mbed_official	50:a417edff4437	410	CRYPTO_SHA256_Digest_TypeDef msgDigest)
mbed_official	50:a417edff4437	411	{
mbed_official	50:a417edff4437	412	uint32_t temp;
<>	150:02e0a0aed4ec	413	uint32_t len;
mbed_official	50:a417edff4437	414	int blockLen;
mbed_official	50:a417edff4437	415	uint32_t shaBlock[CRYPTO_SHA256_BLOCK_SIZE_IN_32BIT_WORDS]=
mbed_official	50:a417edff4437	416	{
mbed_official	50:a417edff4437	417	/* Initial value */
mbed_official	50:a417edff4437	418	0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
mbed_official	50:a417edff4437	419	0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
mbed_official	50:a417edff4437	420	};
mbed_official	50:a417edff4437	421	uint8_t * p8ShaBlock = (uint8_t *) shaBlock;
mbed_official	50:a417edff4437	422
mbed_official	50:a417edff4437	423	/* Initialize crypyo module to do SHA-256 (SHA-2). */
<>	150:02e0a0aed4ec	424	crypto->CTRL = CRYPTO_CTRL_SHA_SHA2;
<>	150:02e0a0aed4ec	425	crypto->SEQCTRL = 0;
<>	150:02e0a0aed4ec	426	crypto->SEQCTRLB = 0;
mbed_official	50:a417edff4437	427
mbed_official	50:a417edff4437	428	/* Set result width of MADD32 operation. */
<>	150:02e0a0aed4ec	429	CRYPTO_ResultWidthSet(crypto, cryptoResult256Bits);
mbed_official	50:a417edff4437	430
mbed_official	50:a417edff4437	431	/* Write init value to DDATA1. */
<>	150:02e0a0aed4ec	432	CRYPTO_DDataWrite(&crypto->DDATA1, shaBlock);
mbed_official	50:a417edff4437	433
mbed_official	50:a417edff4437	434	/* Copy data ot DDATA0 and select DDATA0 and DDATA1 for SHA operation. */
<>	150:02e0a0aed4ec	435	CRYPTO_EXECUTE_2(crypto,
<>	150:02e0a0aed4ec	436	CRYPTO_CMD_INSTR_DDATA1TODDATA0,
mbed_official	50:a417edff4437	437	CRYPTO_CMD_INSTR_SELDDATA0DDATA1);
mbed_official	50:a417edff4437	438	len = msgLen;
mbed_official	50:a417edff4437	439
mbed_official	50:a417edff4437	440	while (len >= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES)
mbed_official	50:a417edff4437	441	{
mbed_official	50:a417edff4437	442	/* Write block to QDATA1BIG. */
<>	150:02e0a0aed4ec	443	CRYPTO_QDataWrite(&crypto->QDATA1BIG, (uint32_t *) msg);
mbed_official	50:a417edff4437	444
mbed_official	50:a417edff4437	445	/* Execute SHA */
<>	150:02e0a0aed4ec	446	CRYPTO_EXECUTE_3(crypto,
<>	150:02e0a0aed4ec	447	CRYPTO_CMD_INSTR_SHA,
mbed_official	50:a417edff4437	448	CRYPTO_CMD_INSTR_MADD32,
mbed_official	50:a417edff4437	449	CRYPTO_CMD_INSTR_DDATA0TODDATA1);
mbed_official	50:a417edff4437	450
mbed_official	50:a417edff4437	451	len -= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES;
mbed_official	50:a417edff4437	452	msg += CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES;
mbed_official	50:a417edff4437	453	}
mbed_official	50:a417edff4437	454
mbed_official	50:a417edff4437	455	blockLen = 0;
mbed_official	50:a417edff4437	456
mbed_official	50:a417edff4437	457	/* Build the last (or second to last) block */
mbed_official	50:a417edff4437	458	for (; len; len--)
mbed_official	50:a417edff4437	459	p8ShaBlock[blockLen++] = *msg++;
mbed_official	50:a417edff4437	460
mbed_official	50:a417edff4437	461	/* append the '1' bit */
mbed_official	50:a417edff4437	462	p8ShaBlock[blockLen++] = 0x80;
mbed_official	50:a417edff4437	463
mbed_official	50:a417edff4437	464	/* if the length is currently above 56 bytes we append zeros
mbed_official	50:a417edff4437	465	* then compress. Then we can fall back to padding zeros and length
mbed_official	50:a417edff4437	466	* encoding like normal.
mbed_official	50:a417edff4437	467	*/
mbed_official	50:a417edff4437	468	if (blockLen > 56)
mbed_official	50:a417edff4437	469	{
mbed_official	50:a417edff4437	470	while (blockLen < 64)
mbed_official	50:a417edff4437	471	p8ShaBlock[blockLen++] = 0;
mbed_official	50:a417edff4437	472
mbed_official	50:a417edff4437	473	/* Write block to QDATA1BIG. */
<>	150:02e0a0aed4ec	474	CRYPTO_QDataWrite(&crypto->QDATA1BIG, shaBlock);
mbed_official	50:a417edff4437	475
mbed_official	50:a417edff4437	476	/* Execute SHA */
<>	150:02e0a0aed4ec	477	CRYPTO_EXECUTE_3(crypto,
<>	150:02e0a0aed4ec	478	CRYPTO_CMD_INSTR_SHA,
mbed_official	50:a417edff4437	479	CRYPTO_CMD_INSTR_MADD32,
mbed_official	50:a417edff4437	480	CRYPTO_CMD_INSTR_DDATA0TODDATA1);
mbed_official	50:a417edff4437	481	blockLen = 0;
mbed_official	50:a417edff4437	482	}
mbed_official	50:a417edff4437	483
mbed_official	50:a417edff4437	484	/* Pad upto 56 bytes of zeroes */
mbed_official	50:a417edff4437	485	while (blockLen < 56)
mbed_official	50:a417edff4437	486	p8ShaBlock[blockLen++] = 0;
mbed_official	50:a417edff4437	487
mbed_official	50:a417edff4437	488	/* And finally, encode the message length. */
mbed_official	50:a417edff4437	489	{
mbed_official	50:a417edff4437	490	uint64_t msgLenInBits = msgLen << 3;
mbed_official	50:a417edff4437	491	temp = msgLenInBits >> 32;
mbed_official	50:a417edff4437	492	(uint32_t )&p8ShaBlock[56] = SWAP32(temp);
mbed_official	50:a417edff4437	493	temp = msgLenInBits & 0xFFFFFFFF;
mbed_official	50:a417edff4437	494	(uint32_t )&p8ShaBlock[60] = SWAP32(temp);
mbed_official	50:a417edff4437	495	}
mbed_official	50:a417edff4437	496
mbed_official	50:a417edff4437	497	/* Write the final block to QDATA1BIG. */
<>	150:02e0a0aed4ec	498	CRYPTO_QDataWrite(&crypto->QDATA1BIG, shaBlock);
mbed_official	50:a417edff4437	499
mbed_official	50:a417edff4437	500	/* Execute SHA */
<>	150:02e0a0aed4ec	501	CRYPTO_EXECUTE_3(crypto,
<>	150:02e0a0aed4ec	502	CRYPTO_CMD_INSTR_SHA,
mbed_official	50:a417edff4437	503	CRYPTO_CMD_INSTR_MADD32,
mbed_official	50:a417edff4437	504	CRYPTO_CMD_INSTR_DDATA0TODDATA1);
mbed_official	50:a417edff4437	505
mbed_official	50:a417edff4437	506	/* Read resulting message digest from DDATA0BIG. */
<>	150:02e0a0aed4ec	507	CRYPTO_DDataRead(&crypto->DDATA0BIG, (uint32_t *)msgDigest);
mbed_official	50:a417edff4437	508	}
mbed_official	50:a417edff4437	509
mbed_official	50:a417edff4437	510	/*************************************************************************//
mbed_official	50:a417edff4437	511	* @brief
mbed_official	50:a417edff4437	512	* Set 32bit word array to zero.
mbed_official	50:a417edff4437	513	*
mbed_official	50:a417edff4437	514	* @param[in] words32bits Pointer to 32bit word array
mbed_official	50:a417edff4437	515	* @param[in] num32bitWords Number of 32bit words in array
mbed_official	50:a417edff4437	516	******************************************************************************/
mbed_official	50:a417edff4437	517	__STATIC_INLINE void cryptoBigintZeroize(uint32_t * words32bits,
mbed_official	50:a417edff4437	518	int num32bitWords)
mbed_official	50:a417edff4437	519	{
mbed_official	50:a417edff4437	520	while (num32bitWords--)
mbed_official	50:a417edff4437	521	*words32bits++ = 0;
mbed_official	50:a417edff4437	522	}
mbed_official	50:a417edff4437	523
mbed_official	50:a417edff4437	524	/*************************************************************************//
mbed_official	50:a417edff4437	525	* @brief
mbed_official	50:a417edff4437	526	* Increment value of 32bit word array by one.
mbed_official	50:a417edff4437	527	*
mbed_official	50:a417edff4437	528	* @param[in] words32bits Pointer to 32bit word array
mbed_official	50:a417edff4437	529	* @param[in] num32bitWords Number of 32bit words in array
mbed_official	50:a417edff4437	530	******************************************************************************/
mbed_official	50:a417edff4437	531	__STATIC_INLINE void cryptoBigintIncrement(uint32_t * words32bits,
mbed_official	50:a417edff4437	532	int num32bitWords)
mbed_official	50:a417edff4437	533	{
mbed_official	50:a417edff4437	534	int i;
mbed_official	50:a417edff4437	535	for (i=0; i<num32bitWords; i++)
mbed_official	50:a417edff4437	536	if (++words32bits[i] != 0)
mbed_official	50:a417edff4437	537	break;
mbed_official	50:a417edff4437	538	return;
mbed_official	50:a417edff4437	539	}
mbed_official	50:a417edff4437	540
mbed_official	50:a417edff4437	541	/*************************************************************************//
mbed_official	50:a417edff4437	542	* @brief
mbed_official	50:a417edff4437	543	* Multiply two big integers.
mbed_official	50:a417edff4437	544	*
mbed_official	50:a417edff4437	545	* @details
mbed_official	50:a417edff4437	546	* This function uses the CRYPTO unit to multiply two big integer operands.
mbed_official	50:a417edff4437	547	* If USE_VARIABLE_SIZED_DATA_LOADS is defined, the sizes of the operands
mbed_official	50:a417edff4437	548	* may be any multiple of 32 bits. If USE_VARIABLE_SIZED_DATA_LOADS is _not_
mbed_official	50:a417edff4437	549	* defined, the sizes of the operands must be a multiple of 128 bits.
mbed_official	50:a417edff4437	550	*
mbed_official	50:a417edff4437	551	* @param[in] A operand A
mbed_official	50:a417edff4437	552	* @param[in] aSize size of operand A in bits
mbed_official	50:a417edff4437	553	* @param[in] B operand B
mbed_official	50:a417edff4437	554	* @param[in] bSize size of operand B in bits
mbed_official	50:a417edff4437	555	* @param[out] R result of multiplication
mbed_official	50:a417edff4437	556	* @param[in] rSize size of result buffer R in bits
mbed_official	50:a417edff4437	557	******************************************************************************/
<>	150:02e0a0aed4ec	558	void CRYPTO_Mul(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	559	uint32_t * A, int aSize,
mbed_official	50:a417edff4437	560	uint32_t * B, int bSize,
mbed_official	50:a417edff4437	561	uint32_t * R, int rSize)
mbed_official	50:a417edff4437	562	{
mbed_official	50:a417edff4437	563	int i, j;
mbed_official	50:a417edff4437	564
mbed_official	50:a417edff4437	565	/************** Initializations ****************/
mbed_official	50:a417edff4437	566
mbed_official	50:a417edff4437	567	#ifdef USE_VARIABLE_SIZED_DATA_LOADS
mbed_official	50:a417edff4437	568	int numWordsLastOperandA = (aSize&PARTIAL_OPERAND_WIDTH_MASK)>>5;
mbed_official	50:a417edff4437	569	int numPartialOperandsA = numWordsLastOperandA ?
mbed_official	50:a417edff4437	570	(aSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 :
mbed_official	50:a417edff4437	571	aSize >> PARTIAL_OPERAND_WIDTH_LOG2;
mbed_official	50:a417edff4437	572	int numWordsLastOperandB = (bSize&PARTIAL_OPERAND_WIDTH_MASK)>>5;
mbed_official	50:a417edff4437	573	int numPartialOperandsB = numWordsLastOperandB ?
mbed_official	50:a417edff4437	574	(bSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 :
mbed_official	50:a417edff4437	575	bSize >> PARTIAL_OPERAND_WIDTH_LOG2;
mbed_official	50:a417edff4437	576	int numWordsLastOperandR = (rSize&PARTIAL_OPERAND_WIDTH_MASK)>>5;
mbed_official	50:a417edff4437	577	int numPartialOperandsR = numWordsLastOperandR ?
mbed_official	50:a417edff4437	578	(rSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 :
mbed_official	50:a417edff4437	579	rSize >> PARTIAL_OPERAND_WIDTH_LOG2;
mbed_official	50:a417edff4437	580	EFM_ASSERT(numPartialOperandsA + numPartialOperandsB <= numPartialOperandsR);
mbed_official	50:a417edff4437	581	#else
mbed_official	50:a417edff4437	582	int numPartialOperandsA = aSize >> PARTIAL_OPERAND_WIDTH_LOG2;
mbed_official	50:a417edff4437	583	int numPartialOperandsB = bSize >> PARTIAL_OPERAND_WIDTH_LOG2;
mbed_official	50:a417edff4437	584	EFM_ASSERT((aSize & PARTIAL_OPERAND_WIDTH_MASK) == 0);
mbed_official	50:a417edff4437	585	EFM_ASSERT((bSize & PARTIAL_OPERAND_WIDTH_MASK) == 0);
mbed_official	50:a417edff4437	586	#endif
mbed_official	50:a417edff4437	587	EFM_ASSERT(aSize + bSize <= rSize);
<>	150:02e0a0aed4ec	588
mbed_official	50:a417edff4437	589	/* Set R to zero. */
mbed_official	50:a417edff4437	590	cryptoBigintZeroize(R, rSize >> 5);
mbed_official	50:a417edff4437	591
mbed_official	50:a417edff4437	592	/* Set multiplication width. */
<>	150:02e0a0aed4ec	593	crypto->WAC = CRYPTO_WAC_MULWIDTH_MUL128 \| CRYPTO_WAC_RESULTWIDTH_256BIT;
mbed_official	50:a417edff4437	594
mbed_official	50:a417edff4437	595	/* Setup DMA request signalling in order for MCU to run in parallel with
mbed_official	50:a417edff4437	596	CRYPTO instruction sequence execution, and prepare data loading which
mbed_official	50:a417edff4437	597	can take place immediately when CRYPTO is ready inside the instruction
mbed_official	50:a417edff4437	598	sequence. */
<>	150:02e0a0aed4ec	599	crypto->CTRL =
mbed_official	50:a417edff4437	600	CRYPTO_CTRL_DMA0RSEL_DATA0 \| CRYPTO_CTRL_DMA0MODE_FULL \|
mbed_official	50:a417edff4437	601	CRYPTO_CTRL_DMA1RSEL_DATA1 \| CRYPTO_CTRL_DMA1MODE_FULL;
mbed_official	50:a417edff4437	602
<>	150:02e0a0aed4ec	603	CRYPTO_EXECUTE_4(crypto,
mbed_official	50:a417edff4437	604	CRYPTO_CMD_INSTR_CCLR, /* Carry = 0 */
mbed_official	50:a417edff4437	605	CRYPTO_CMD_INSTR_CLR, /* DDATA0 = 0 */
mbed_official	50:a417edff4437	606	/* clear result accumulation register */
mbed_official	50:a417edff4437	607	CRYPTO_CMD_INSTR_DDATA0TODDATA2,
mbed_official	50:a417edff4437	608	CRYPTO_CMD_INSTR_SELDDATA1DDATA3);
mbed_official	50:a417edff4437	609	/*
mbed_official	50:a417edff4437	610	register map:
mbed_official	50:a417edff4437	611	DDATA0: working register
mbed_official	50:a417edff4437	612	DDATA1: B(j)
mbed_official	50:a417edff4437	613	DDATA2: R(i+j+1) and R(i+j), combined with DMA entry for B(j)
mbed_official	50:a417edff4437	614	DDATA3: A(i)
mbed_official	50:a417edff4437	615	*/
mbed_official	50:a417edff4437	616
<>	150:02e0a0aed4ec	617	CRYPTO_SEQ_LOAD_10(crypto,
mbed_official	50:a417edff4437	618	/* Temporarily load partial operand B(j) to DATA0. */
mbed_official	50:a417edff4437	619	/* R(i+j+1) is still in DATA1 */
mbed_official	50:a417edff4437	620	CRYPTO_CMD_INSTR_DMA0TODATA,
mbed_official	50:a417edff4437	621	/* Move B(j) to DDATA1 */
mbed_official	50:a417edff4437	622	CRYPTO_CMD_INSTR_DDATA2TODDATA1,
mbed_official	50:a417edff4437	623
mbed_official	50:a417edff4437	624	/* Restore previous partial result (now R(i+j)) */
mbed_official	50:a417edff4437	625	CRYPTO_CMD_INSTR_DATA1TODATA0,
mbed_official	50:a417edff4437	626
mbed_official	50:a417edff4437	627	/* Load next partial result R(i+j+1) */
mbed_official	50:a417edff4437	628	CRYPTO_CMD_INSTR_DMA1TODATA,
mbed_official	50:a417edff4437	629
mbed_official	50:a417edff4437	630	/* Execute partial multiplication A(i)inDDATA1 * B(j)inDDATA3*/
mbed_official	50:a417edff4437	631	CRYPTO_CMD_INSTR_MULO,
mbed_official	50:a417edff4437	632
mbed_official	50:a417edff4437	633	/* Add the result to the previous partial result */
mbed_official	50:a417edff4437	634	/* AND take the previous carry value into account */
mbed_official	50:a417edff4437	635	/* at the right place (bit 128, ADDIC instruction */
mbed_official	50:a417edff4437	636	CRYPTO_CMD_INSTR_SELDDATA0DDATA2,
mbed_official	50:a417edff4437	637	CRYPTO_CMD_INSTR_ADDIC,
mbed_official	50:a417edff4437	638
mbed_official	50:a417edff4437	639	/* Save the new partial result (lower half) */
mbed_official	50:a417edff4437	640	CRYPTO_CMD_INSTR_DDATA0TODDATA2,
mbed_official	50:a417edff4437	641	CRYPTO_CMD_INSTR_DATATODMA0,
mbed_official	50:a417edff4437	642	/* Reset the operand selector for next*/
mbed_official	50:a417edff4437	643	CRYPTO_CMD_INSTR_SELDDATA2DDATA3
mbed_official	50:a417edff4437	644	);
mbed_official	50:a417edff4437	645
mbed_official	50:a417edff4437	646	/************** End Initializations ****************/
mbed_official	50:a417edff4437	647
mbed_official	50:a417edff4437	648	for(i=0; i<numPartialOperandsA; i++)
mbed_official	50:a417edff4437	649	{
mbed_official	50:a417edff4437	650	/* Load partial operand #1 A>>(iPARTIAL_OPERAND_WIDTH) to DDATA1. /
mbed_official	50:a417edff4437	651	#ifdef USE_VARIABLE_SIZED_DATA_LOADS
mbed_official	50:a417edff4437	652	if ( (numWordsLastOperandA != 0) && ( i == numPartialOperandsA-1 ) )
<>	150:02e0a0aed4ec	653	CRYPTO_DataWriteVariableSize(&crypto->DATA2,
mbed_official	50:a417edff4437	654	&A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
mbed_official	50:a417edff4437	655	numWordsLastOperandA);
mbed_official	50:a417edff4437	656	else
<>	150:02e0a0aed4ec	657	CRYPTO_DataWrite(&crypto->DATA2, &A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	658	#else
<>	150:02e0a0aed4ec	659	CRYPTO_DataWrite(&crypto->DATA2, &A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	660	#endif
mbed_official	50:a417edff4437	661
mbed_official	50:a417edff4437	662	/* Load partial result in R>>(iPARTIAL_OPERAND_WIDTH) to DATA1. /
mbed_official	50:a417edff4437	663	#ifdef USE_VARIABLE_SIZED_DATA_LOADS
mbed_official	50:a417edff4437	664	if ( (numWordsLastOperandR != 0) && ( i == numPartialOperandsR-1 ) )
<>	150:02e0a0aed4ec	665	CRYPTO_DataWriteVariableSize(&crypto->DATA1,
mbed_official	50:a417edff4437	666	&R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
mbed_official	50:a417edff4437	667	numWordsLastOperandR);
mbed_official	50:a417edff4437	668	else
<>	150:02e0a0aed4ec	669	CRYPTO_DataWrite(&crypto->DATA1, &R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	670	#else
<>	150:02e0a0aed4ec	671	CRYPTO_DataWrite(&crypto->DATA1, &R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	672	#endif
<>	150:02e0a0aed4ec	673
mbed_official	50:a417edff4437	674	/* Clear carry */
<>	150:02e0a0aed4ec	675	crypto->CMD = CRYPTO_CMD_INSTR_CCLR;
mbed_official	50:a417edff4437	676
mbed_official	50:a417edff4437	677	/* Setup number of sequence iterations and block size. */
<>	150:02e0a0aed4ec	678	crypto->SEQCTRL = CRYPTO_SEQCTRL_BLOCKSIZE_16BYTES
mbed_official	50:a417edff4437	679	\| (PARTIAL_OPERAND_WIDTH_IN_BYTES * numPartialOperandsB);
mbed_official	50:a417edff4437	680
mbed_official	50:a417edff4437	681	/* Execute the MULtiply instruction sequence. */
<>	150:02e0a0aed4ec	682	CRYPTO_InstructionSequenceExecute(crypto);
mbed_official	50:a417edff4437	683
mbed_official	50:a417edff4437	684	for (j=0; j<numPartialOperandsB; j++)
mbed_official	50:a417edff4437	685	{
mbed_official	50:a417edff4437	686	/* Load partial operand 2 B>>(j*`PARTIAL_OPERAND_WIDTH) to DDATA2
mbed_official	50:a417edff4437	687	(via DATA0). */
mbed_official	50:a417edff4437	688	#ifdef USE_VARIABLE_SIZED_DATA_LOADS
mbed_official	50:a417edff4437	689	if ( (numWordsLastOperandB != 0) && ( j == numPartialOperandsB-1 ) )
<>	150:02e0a0aed4ec	690	CRYPTO_DataWriteVariableSize(&crypto->DATA0,
mbed_official	50:a417edff4437	691	&B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
mbed_official	50:a417edff4437	692	numWordsLastOperandB);
mbed_official	50:a417edff4437	693	else
<>	150:02e0a0aed4ec	694	CRYPTO_DataWrite(&crypto->DATA0,
mbed_official	50:a417edff4437	695	&B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	696	#else
<>	150:02e0a0aed4ec	697	CRYPTO_DataWrite(&crypto->DATA0,
mbed_official	50:a417edff4437	698	&B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	699	#endif
mbed_official	50:a417edff4437	700
mbed_official	50:a417edff4437	701	/* Load most significant partial result
mbed_official	50:a417edff4437	702	R>>((i+j+1)`PARTIAL_OPERAND_WIDTH) into DATA1. /
mbed_official	50:a417edff4437	703	#ifdef USE_VARIABLE_SIZED_DATA_LOADS
mbed_official	50:a417edff4437	704	if ( (numWordsLastOperandR != 0) && ( (i+j+1) == numPartialOperandsR-1 ) )
<>	150:02e0a0aed4ec	705	CRYPTO_DataWriteVariableSize(&crypto->DATA1,
mbed_official	50:a417edff4437	706	&R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
mbed_official	50:a417edff4437	707	numWordsLastOperandR);
mbed_official	50:a417edff4437	708	else
<>	150:02e0a0aed4ec	709	CRYPTO_DataWrite(&crypto->DATA1,
mbed_official	50:a417edff4437	710	&R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	711	#else
<>	150:02e0a0aed4ec	712	CRYPTO_DataWrite(&crypto->DATA1,
mbed_official	50:a417edff4437	713	&R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	714	#endif
mbed_official	50:a417edff4437	715	/* Store least significant partial result */
<>	150:02e0a0aed4ec	716	CRYPTO_DataRead(&crypto->DATA0,
mbed_official	50:a417edff4437	717	&R[(i+j)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	718
mbed_official	50:a417edff4437	719	} /* for (j=0; j<numPartialOperandsB; j++) */
mbed_official	50:a417edff4437	720
mbed_official	50:a417edff4437	721	/* Handle carry at the end of the inner loop. */
<>	150:02e0a0aed4ec	722	if (CRYPTO_CarryIsSet(crypto))
mbed_official	50:a417edff4437	723	cryptoBigintIncrement(&R[(i+numPartialOperandsB+1)
mbed_official	50:a417edff4437	724	*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
mbed_official	50:a417edff4437	725	(numPartialOperandsA-i-1)
mbed_official	50:a417edff4437	726	*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS);
mbed_official	50:a417edff4437	727
<>	150:02e0a0aed4ec	728	CRYPTO_DataRead(&crypto->DATA1,
mbed_official	50:a417edff4437	729	&R[(i+numPartialOperandsB)
mbed_official	50:a417edff4437	730	* PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
mbed_official	50:a417edff4437	731
mbed_official	50:a417edff4437	732	} /* for (i=0; i<numPartialOperandsA; i++) */
mbed_official	50:a417edff4437	733	}
mbed_official	50:a417edff4437	734
mbed_official	50:a417edff4437	735	/*************************************************************************//
mbed_official	50:a417edff4437	736	* @brief
mbed_official	50:a417edff4437	737	* AES Cipher-block chaining (CBC) cipher mode encryption/decryption, 128 bit key.
mbed_official	50:a417edff4437	738	*
mbed_official	50:a417edff4437	739	* @details
mbed_official	50:a417edff4437	740	* Encryption:
mbed_official	50:a417edff4437	741	* @verbatim
mbed_official	50:a417edff4437	742	* Plaintext Plaintext
mbed_official	50:a417edff4437	743	* \| \|
mbed_official	50:a417edff4437	744	* V V
mbed_official	50:a417edff4437	745	* InitVector ->XOR +-------------->XOR
mbed_official	50:a417edff4437	746	* \| \| \|
mbed_official	50:a417edff4437	747	* V \| V
mbed_official	50:a417edff4437	748	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	749	* Key ->\| Block cipher \| \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	750	* \| encryption \| \| \| encryption \|
mbed_official	50:a417edff4437	751	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	752	* \|---------+ \|
mbed_official	50:a417edff4437	753	* V V
mbed_official	50:a417edff4437	754	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	755	* @endverbatim
mbed_official	50:a417edff4437	756	* Decryption:
mbed_official	50:a417edff4437	757	* @verbatim
mbed_official	50:a417edff4437	758	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	759	* \|----------+ \|
mbed_official	50:a417edff4437	760	* V \| V
mbed_official	50:a417edff4437	761	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	762	* Key ->\| Block cipher \| \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	763	* \| decryption \| \| \| decryption \|
mbed_official	50:a417edff4437	764	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	765	* \| \| \|
mbed_official	50:a417edff4437	766	* V \| V
mbed_official	50:a417edff4437	767	* InitVector ->XOR +-------------->XOR
mbed_official	50:a417edff4437	768	* \| \|
mbed_official	50:a417edff4437	769	* V V
mbed_official	50:a417edff4437	770	* Plaintext Plaintext
mbed_official	50:a417edff4437	771	* @endverbatim
mbed_official	50:a417edff4437	772	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	773	*
<>	150:02e0a0aed4ec	774	* @param[in] crypto
<>	150:02e0a0aed4ec	775	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	776	*
mbed_official	50:a417edff4437	777	* @param[out] out
mbed_official	50:a417edff4437	778	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	779	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	780	*
mbed_official	50:a417edff4437	781	* @param[in] in
mbed_official	50:a417edff4437	782	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	783	*
mbed_official	50:a417edff4437	784	* @param[in] len
mbed_official	50:a417edff4437	785	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	786	*
mbed_official	50:a417edff4437	787	* @param[in] key
mbed_official	50:a417edff4437	788	* When doing encryption, this is the 128 bit encryption key. When doing
mbed_official	50:a417edff4437	789	* decryption, this is the 128 bit decryption key. The decryption key may
mbed_official	50:a417edff4437	790	* be generated from the encryption key with CRYPTO_AES_DecryptKey128().
mbed_official	50:a417edff4437	791	* If this argument is null, the key will not be loaded, as it is assumed
mbed_official	50:a417edff4437	792	* the key has been loaded into KEYHA previously.
mbed_official	50:a417edff4437	793	*
mbed_official	50:a417edff4437	794	* @param[in] iv
mbed_official	50:a417edff4437	795	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	796	*
mbed_official	50:a417edff4437	797	* @param[in] encrypt
mbed_official	50:a417edff4437	798	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	799	******************************************************************************/
<>	150:02e0a0aed4ec	800	void CRYPTO_AES_CBC128(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	801	uint8_t * out,
<>	150:02e0a0aed4ec	802	const uint8_t * in,
<>	150:02e0a0aed4ec	803	unsigned int len,
<>	150:02e0a0aed4ec	804	const uint8_t * key,
<>	150:02e0a0aed4ec	805	const uint8_t * iv,
<>	150:02e0a0aed4ec	806	bool encrypt)
mbed_official	50:a417edff4437	807	{
<>	150:02e0a0aed4ec	808	crypto->CTRL = CRYPTO_CTRL_AES_AES128;
<>	150:02e0a0aed4ec	809	CRYPTO_AES_CBCx(crypto, out, in, len, key, iv, encrypt, cryptoKey128Bits);
mbed_official	50:a417edff4437	810	}
mbed_official	50:a417edff4437	811
mbed_official	50:a417edff4437	812	/*************************************************************************//
mbed_official	50:a417edff4437	813	* @brief
mbed_official	50:a417edff4437	814	* AES Cipher-block chaining (CBC) cipher mode encryption/decryption, 256 bit
mbed_official	50:a417edff4437	815	* key.
mbed_official	50:a417edff4437	816	*
mbed_official	50:a417edff4437	817	* @details
mbed_official	50:a417edff4437	818	* Please see CRYPTO_AES_CBC128() for CBC figure.
mbed_official	50:a417edff4437	819	*
mbed_official	50:a417edff4437	820	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	821	*
<>	150:02e0a0aed4ec	822	* @param[in] crypto
<>	150:02e0a0aed4ec	823	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	824	*
mbed_official	50:a417edff4437	825	* @param[out] out
mbed_official	50:a417edff4437	826	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	827	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	828	*
mbed_official	50:a417edff4437	829	* @param[in] in
mbed_official	50:a417edff4437	830	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	831	*
mbed_official	50:a417edff4437	832	* @param[in] len
mbed_official	50:a417edff4437	833	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	834	*
mbed_official	50:a417edff4437	835	* @param[in] key
mbed_official	50:a417edff4437	836	* When doing encryption, this is the 256 bit encryption key. When doing
mbed_official	50:a417edff4437	837	* decryption, this is the 256 bit decryption key. The decryption key may
mbed_official	50:a417edff4437	838	* be generated from the encryption key with CRYPTO_AES_DecryptKey256().
mbed_official	50:a417edff4437	839	*
mbed_official	50:a417edff4437	840	* @param[in] iv
mbed_official	50:a417edff4437	841	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	842	*
mbed_official	50:a417edff4437	843	* @param[in] encrypt
mbed_official	50:a417edff4437	844	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	845	******************************************************************************/
<>	150:02e0a0aed4ec	846	void CRYPTO_AES_CBC256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	847	uint8_t * out,
<>	150:02e0a0aed4ec	848	const uint8_t * in,
<>	150:02e0a0aed4ec	849	unsigned int len,
<>	150:02e0a0aed4ec	850	const uint8_t * key,
<>	150:02e0a0aed4ec	851	const uint8_t * iv,
<>	150:02e0a0aed4ec	852	bool encrypt)
mbed_official	50:a417edff4437	853	{
<>	150:02e0a0aed4ec	854	crypto->CTRL = CRYPTO_CTRL_AES_AES256;
<>	150:02e0a0aed4ec	855	CRYPTO_AES_CBCx(crypto, out, in, len, key, iv, encrypt, cryptoKey256Bits);
mbed_official	50:a417edff4437	856	}
mbed_official	50:a417edff4437	857
mbed_official	50:a417edff4437	858	/*************************************************************************//
mbed_official	50:a417edff4437	859	* @brief
mbed_official	50:a417edff4437	860	* AES Cipher feedback (CFB) cipher mode encryption/decryption, 128 bit key.
mbed_official	50:a417edff4437	861	*
mbed_official	50:a417edff4437	862	* @details
mbed_official	50:a417edff4437	863	* Encryption:
mbed_official	50:a417edff4437	864	* @verbatim
mbed_official	50:a417edff4437	865	* InitVector +----------------+
mbed_official	50:a417edff4437	866	* \| \| \|
mbed_official	50:a417edff4437	867	* V \| V
mbed_official	50:a417edff4437	868	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	869	* Key ->\| Block cipher \| \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	870	* \| encryption \| \| \| encryption \|
mbed_official	50:a417edff4437	871	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	872	* \| \| \|
mbed_official	50:a417edff4437	873	* V \| V
mbed_official	50:a417edff4437	874	* Plaintext ->XOR \| Plaintext ->XOR
mbed_official	50:a417edff4437	875	* \|---------+ \|
mbed_official	50:a417edff4437	876	* V V
mbed_official	50:a417edff4437	877	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	878	* @endverbatim
mbed_official	50:a417edff4437	879	* Decryption:
mbed_official	50:a417edff4437	880	* @verbatim
mbed_official	50:a417edff4437	881	* InitVector +----------------+
mbed_official	50:a417edff4437	882	* \| \| \|
mbed_official	50:a417edff4437	883	* V \| V
mbed_official	50:a417edff4437	884	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	885	* Key ->\| Block cipher \| \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	886	* \| encryption \| \| \| encryption \|
mbed_official	50:a417edff4437	887	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	888	* \| \| \|
mbed_official	50:a417edff4437	889	* V \| V
mbed_official	50:a417edff4437	890	* XOR<- Ciphertext XOR<- Ciphertext
mbed_official	50:a417edff4437	891	* \| \|
mbed_official	50:a417edff4437	892	* V V
mbed_official	50:a417edff4437	893	* Plaintext Plaintext
mbed_official	50:a417edff4437	894	* @endverbatim
mbed_official	50:a417edff4437	895	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	896	*
<>	150:02e0a0aed4ec	897	* @param[in] crypto
<>	150:02e0a0aed4ec	898	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	899	*
mbed_official	50:a417edff4437	900	* @param[out] out
mbed_official	50:a417edff4437	901	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	902	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	903	*
mbed_official	50:a417edff4437	904	* @param[in] in
mbed_official	50:a417edff4437	905	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	906	*
mbed_official	50:a417edff4437	907	* @param[in] len
mbed_official	50:a417edff4437	908	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	909	*
mbed_official	50:a417edff4437	910	* @param[in] key
mbed_official	50:a417edff4437	911	* 128 bit encryption key is used for both encryption and decryption modes.
mbed_official	50:a417edff4437	912	*
mbed_official	50:a417edff4437	913	* @param[in] iv
mbed_official	50:a417edff4437	914	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	915	*
mbed_official	50:a417edff4437	916	* @param[in] encrypt
mbed_official	50:a417edff4437	917	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	918	******************************************************************************/
<>	150:02e0a0aed4ec	919	void CRYPTO_AES_CFB128(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	920	uint8_t * out,
<>	150:02e0a0aed4ec	921	const uint8_t * in,
<>	150:02e0a0aed4ec	922	unsigned int len,
<>	150:02e0a0aed4ec	923	const uint8_t * key,
<>	150:02e0a0aed4ec	924	const uint8_t * iv,
<>	150:02e0a0aed4ec	925	bool encrypt)
mbed_official	50:a417edff4437	926	{
<>	150:02e0a0aed4ec	927	crypto->CTRL = CRYPTO_CTRL_AES_AES128;
<>	150:02e0a0aed4ec	928	CRYPTO_AES_CFBx(crypto, out, in, len, key, iv, encrypt, cryptoKey128Bits);
mbed_official	50:a417edff4437	929	}
mbed_official	50:a417edff4437	930
mbed_official	50:a417edff4437	931	/*************************************************************************//
mbed_official	50:a417edff4437	932	* @brief
mbed_official	50:a417edff4437	933	* AES Cipher feedback (CFB) cipher mode encryption/decryption, 256 bit key.
mbed_official	50:a417edff4437	934	*
mbed_official	50:a417edff4437	935	* @details
mbed_official	50:a417edff4437	936	* Please see CRYPTO_AES_CFB128() for CFB figure.
mbed_official	50:a417edff4437	937	*
mbed_official	50:a417edff4437	938	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	939	*
<>	150:02e0a0aed4ec	940	* @param[in] crypto
<>	150:02e0a0aed4ec	941	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	942	*
mbed_official	50:a417edff4437	943	* @param[out] out
mbed_official	50:a417edff4437	944	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	945	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	946	*
mbed_official	50:a417edff4437	947	* @param[in] in
mbed_official	50:a417edff4437	948	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	949	*
mbed_official	50:a417edff4437	950	* @param[in] len
mbed_official	50:a417edff4437	951	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	952	*
mbed_official	50:a417edff4437	953	* @param[in] key
mbed_official	50:a417edff4437	954	* 256 bit encryption key is used for both encryption and decryption modes.
mbed_official	50:a417edff4437	955	*
mbed_official	50:a417edff4437	956	* @param[in] iv
mbed_official	50:a417edff4437	957	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	958	*
mbed_official	50:a417edff4437	959	* @param[in] encrypt
mbed_official	50:a417edff4437	960	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	961	******************************************************************************/
<>	150:02e0a0aed4ec	962	void CRYPTO_AES_CFB256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	963	uint8_t * out,
<>	150:02e0a0aed4ec	964	const uint8_t * in,
<>	150:02e0a0aed4ec	965	unsigned int len,
<>	150:02e0a0aed4ec	966	const uint8_t * key,
<>	150:02e0a0aed4ec	967	const uint8_t * iv,
<>	150:02e0a0aed4ec	968	bool encrypt)
mbed_official	50:a417edff4437	969	{
<>	150:02e0a0aed4ec	970	crypto->CTRL = CRYPTO_CTRL_AES_AES256;
<>	150:02e0a0aed4ec	971	CRYPTO_AES_CFBx(crypto, out, in, len, key, iv, encrypt, cryptoKey256Bits);
mbed_official	50:a417edff4437	972	}
mbed_official	50:a417edff4437	973
mbed_official	50:a417edff4437	974	/*************************************************************************//
mbed_official	50:a417edff4437	975	* @brief
mbed_official	50:a417edff4437	976	* AES Counter (CTR) cipher mode encryption/decryption, 128 bit key.
mbed_official	50:a417edff4437	977	*
mbed_official	50:a417edff4437	978	* @details
mbed_official	50:a417edff4437	979	* Encryption:
mbed_official	50:a417edff4437	980	* @verbatim
mbed_official	50:a417edff4437	981	* Counter Counter
mbed_official	50:a417edff4437	982	* \| \|
mbed_official	50:a417edff4437	983	* V V
mbed_official	50:a417edff4437	984	* +--------------+ +--------------+
mbed_official	50:a417edff4437	985	* Key ->\| Block cipher \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	986	* \| encryption \| \| encryption \|
mbed_official	50:a417edff4437	987	* +--------------+ +--------------+
mbed_official	50:a417edff4437	988	* \| \|
mbed_official	50:a417edff4437	989	* Plaintext ->XOR Plaintext ->XOR
mbed_official	50:a417edff4437	990	* \| \|
mbed_official	50:a417edff4437	991	* V V
mbed_official	50:a417edff4437	992	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	993	* @endverbatim
mbed_official	50:a417edff4437	994	* Decryption:
mbed_official	50:a417edff4437	995	* @verbatim
mbed_official	50:a417edff4437	996	* Counter Counter
mbed_official	50:a417edff4437	997	* \| \|
mbed_official	50:a417edff4437	998	* V V
mbed_official	50:a417edff4437	999	* +--------------+ +--------------+
mbed_official	50:a417edff4437	1000	* Key ->\| Block cipher \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	1001	* \| encryption \| \| encryption \|
mbed_official	50:a417edff4437	1002	* +--------------+ +--------------+
mbed_official	50:a417edff4437	1003	* \| \|
mbed_official	50:a417edff4437	1004	* Ciphertext ->XOR Ciphertext ->XOR
mbed_official	50:a417edff4437	1005	* \| \|
mbed_official	50:a417edff4437	1006	* V V
mbed_official	50:a417edff4437	1007	* Plaintext Plaintext
mbed_official	50:a417edff4437	1008	* @endverbatim
mbed_official	50:a417edff4437	1009	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1010	*
<>	150:02e0a0aed4ec	1011	* @param[in] crypto
<>	150:02e0a0aed4ec	1012	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1013	*
mbed_official	50:a417edff4437	1014	* @param[out] out
mbed_official	50:a417edff4437	1015	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1016	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1017	*
mbed_official	50:a417edff4437	1018	* @param[in] in
mbed_official	50:a417edff4437	1019	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1020	*
mbed_official	50:a417edff4437	1021	* @param[in] len
mbed_official	50:a417edff4437	1022	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1023	*
mbed_official	50:a417edff4437	1024	* @param[in] key
mbed_official	50:a417edff4437	1025	* 128 bit encryption key.
mbed_official	50:a417edff4437	1026	* If this argument is null, the key will not be loaded, as it is assumed
mbed_official	50:a417edff4437	1027	* the key has been loaded into KEYHA previously.
mbed_official	50:a417edff4437	1028	*
mbed_official	50:a417edff4437	1029	* @param[in,out] ctr
mbed_official	50:a417edff4437	1030	* 128 bit initial counter value. The counter is updated after each AES
mbed_official	50:a417edff4437	1031	* block encoding through use of @p ctrFunc.
mbed_official	50:a417edff4437	1032	*
mbed_official	50:a417edff4437	1033	* @param[in] ctrFunc
mbed_official	50:a417edff4437	1034	* Function used to update counter value. Not supported by CRYPTO.
mbed_official	50:a417edff4437	1035	* This parameter is included in order for backwards compatibility with
mbed_official	50:a417edff4437	1036	* the EFM32 em_aes.h API.
mbed_official	50:a417edff4437	1037	******************************************************************************/
<>	150:02e0a0aed4ec	1038	void CRYPTO_AES_CTR128(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1039	uint8_t * out,
<>	150:02e0a0aed4ec	1040	const uint8_t * in,
<>	150:02e0a0aed4ec	1041	unsigned int len,
<>	150:02e0a0aed4ec	1042	const uint8_t * key,
<>	150:02e0a0aed4ec	1043	uint8_t * ctr,
mbed_official	50:a417edff4437	1044	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
mbed_official	50:a417edff4437	1045	{
<>	150:02e0a0aed4ec	1046	crypto->CTRL = CRYPTO_CTRL_AES_AES128;
<>	150:02e0a0aed4ec	1047	CRYPTO_AES_CTRx(crypto, out, in, len, key, ctr, ctrFunc, cryptoKey128Bits);
mbed_official	50:a417edff4437	1048	}
mbed_official	50:a417edff4437	1049
mbed_official	50:a417edff4437	1050	/*************************************************************************//
mbed_official	50:a417edff4437	1051	* @brief
mbed_official	50:a417edff4437	1052	* AES Counter (CTR) cipher mode encryption/decryption, 256 bit key.
mbed_official	50:a417edff4437	1053	*
mbed_official	50:a417edff4437	1054	* @details
mbed_official	50:a417edff4437	1055	* Please see CRYPTO_AES_CTR128() for CTR figure.
mbed_official	50:a417edff4437	1056	*
mbed_official	50:a417edff4437	1057	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1058	*
<>	150:02e0a0aed4ec	1059	* @param[in] crypto
<>	150:02e0a0aed4ec	1060	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1061	*
mbed_official	50:a417edff4437	1062	* @param[out] out
mbed_official	50:a417edff4437	1063	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1064	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1065	*
mbed_official	50:a417edff4437	1066	* @param[in] in
mbed_official	50:a417edff4437	1067	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1068	*
mbed_official	50:a417edff4437	1069	* @param[in] len
mbed_official	50:a417edff4437	1070	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1071	*
mbed_official	50:a417edff4437	1072	* @param[in] key
mbed_official	50:a417edff4437	1073	* 256 bit encryption key.
mbed_official	50:a417edff4437	1074	*
mbed_official	50:a417edff4437	1075	* @param[in,out] ctr
mbed_official	50:a417edff4437	1076	* 128 bit initial counter value. The counter is updated after each AES
mbed_official	50:a417edff4437	1077	* block encoding through use of @p ctrFunc.
mbed_official	50:a417edff4437	1078	*
mbed_official	50:a417edff4437	1079	* @param[in] ctrFunc
mbed_official	50:a417edff4437	1080	* Function used to update counter value. Not supported by CRYPTO.
mbed_official	50:a417edff4437	1081	* This parameter is included in order for backwards compatibility with
mbed_official	50:a417edff4437	1082	* the EFM32 em_aes.h API.
mbed_official	50:a417edff4437	1083	******************************************************************************/
<>	150:02e0a0aed4ec	1084	void CRYPTO_AES_CTR256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1085	uint8_t * out,
<>	150:02e0a0aed4ec	1086	const uint8_t * in,
<>	150:02e0a0aed4ec	1087	unsigned int len,
<>	150:02e0a0aed4ec	1088	const uint8_t * key,
<>	150:02e0a0aed4ec	1089	uint8_t * ctr,
mbed_official	50:a417edff4437	1090	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
mbed_official	50:a417edff4437	1091	{
<>	150:02e0a0aed4ec	1092	crypto->CTRL = CRYPTO_CTRL_AES_AES256;
<>	150:02e0a0aed4ec	1093	CRYPTO_AES_CTRx(crypto, out, in, len, key, ctr, ctrFunc, cryptoKey256Bits);
mbed_official	50:a417edff4437	1094	}
mbed_official	50:a417edff4437	1095
mbed_official	50:a417edff4437	1096	/*************************************************************************//
mbed_official	50:a417edff4437	1097	* @brief
mbed_official	50:a417edff4437	1098	* Update last 32 bits of 128 bit counter, by incrementing with 1.
mbed_official	50:a417edff4437	1099	*
mbed_official	50:a417edff4437	1100	* @details
mbed_official	50:a417edff4437	1101	* Notice that no special consideration is given to possible wrap around. If
mbed_official	50:a417edff4437	1102	* 32 least significant bits are 0xFFFFFFFF, they will be updated to 0x00000000,
mbed_official	50:a417edff4437	1103	* ignoring overflow.
mbed_official	50:a417edff4437	1104	*
mbed_official	50:a417edff4437	1105	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1106	*
mbed_official	50:a417edff4437	1107	* @param[in,out] ctr
mbed_official	50:a417edff4437	1108	* Buffer holding 128 bit counter to be updated.
mbed_official	50:a417edff4437	1109	******************************************************************************/
mbed_official	50:a417edff4437	1110	void CRYPTO_AES_CTRUpdate32Bit(uint8_t * ctr)
mbed_official	50:a417edff4437	1111	{
mbed_official	50:a417edff4437	1112	uint32_t * _ctr = (uint32_t *) ctr;
mbed_official	50:a417edff4437	1113
mbed_official	50:a417edff4437	1114	_ctr[3] = __REV(__REV(_ctr[3]) + 1);
mbed_official	50:a417edff4437	1115	}
mbed_official	50:a417edff4437	1116
mbed_official	50:a417edff4437	1117	/*************************************************************************//
mbed_official	50:a417edff4437	1118	* @brief
mbed_official	50:a417edff4437	1119	* Generate 128 bit AES decryption key from 128 bit encryption key. The
mbed_official	50:a417edff4437	1120	* decryption key is used for some cipher modes when decrypting.
mbed_official	50:a417edff4437	1121	*
mbed_official	50:a417edff4437	1122	* @details
mbed_official	50:a417edff4437	1123	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1124	*
<>	150:02e0a0aed4ec	1125	* @param[in] crypto
<>	150:02e0a0aed4ec	1126	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1127	*
mbed_official	50:a417edff4437	1128	* @param[out] out
mbed_official	50:a417edff4437	1129	* Buffer to place 128 bit decryption key. Must be at least 16 bytes long. It
mbed_official	50:a417edff4437	1130	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1131	*
mbed_official	50:a417edff4437	1132	* @param[in] in
mbed_official	50:a417edff4437	1133	* Buffer holding 128 bit encryption key. Must be at least 16 bytes long.
mbed_official	50:a417edff4437	1134	******************************************************************************/
<>	150:02e0a0aed4ec	1135	void CRYPTO_AES_DecryptKey128(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1136	uint8_t * out,
<>	150:02e0a0aed4ec	1137	const uint8_t * in)
mbed_official	50:a417edff4437	1138	{
mbed_official	50:a417edff4437	1139	uint32_t * _out = (uint32_t *) out;
mbed_official	50:a417edff4437	1140	const uint32_t * _in = (const uint32_t *) in;
mbed_official	50:a417edff4437	1141
<>	161:2cc1468da177	1142	/* Setup CRYPTO in AES-128 mode. */
<>	161:2cc1468da177	1143	crypto->CTRL = CRYPTO_CTRL_AES_AES128;
<>	161:2cc1468da177	1144
mbed_official	50:a417edff4437	1145	/* Load key */
<>	150:02e0a0aed4ec	1146	CRYPTO_BurstToCrypto(&crypto->KEYBUF, &_in[0]);
mbed_official	50:a417edff4437	1147
mbed_official	50:a417edff4437	1148	/* Do dummy encryption to generate decrypt key */
<>	150:02e0a0aed4ec	1149	crypto->CMD = CRYPTO_CMD_INSTR_AESENC;
mbed_official	50:a417edff4437	1150
mbed_official	50:a417edff4437	1151	/* Save decryption key */
<>	150:02e0a0aed4ec	1152	CRYPTO_BurstFromCrypto(&crypto->KEY, &_out[0]);
mbed_official	50:a417edff4437	1153	}
mbed_official	50:a417edff4437	1154
mbed_official	50:a417edff4437	1155	/*************************************************************************//
mbed_official	50:a417edff4437	1156	* @brief
mbed_official	50:a417edff4437	1157	* Generate 256 bit AES decryption key from 256 bit encryption key. The
mbed_official	50:a417edff4437	1158	* decryption key is used for some cipher modes when decrypting.
mbed_official	50:a417edff4437	1159	*
mbed_official	50:a417edff4437	1160	* @details
mbed_official	50:a417edff4437	1161	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1162	*
<>	150:02e0a0aed4ec	1163	* @param[in] crypto
<>	150:02e0a0aed4ec	1164	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1165	*
mbed_official	50:a417edff4437	1166	* @param[out] out
mbed_official	50:a417edff4437	1167	* Buffer to place 256 bit decryption key. Must be at least 32 bytes long. It
mbed_official	50:a417edff4437	1168	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1169	*
mbed_official	50:a417edff4437	1170	* @param[in] in
mbed_official	50:a417edff4437	1171	* Buffer holding 256 bit encryption key. Must be at least 32 bytes long.
mbed_official	50:a417edff4437	1172	******************************************************************************/
<>	150:02e0a0aed4ec	1173	void CRYPTO_AES_DecryptKey256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1174	uint8_t * out,
<>	150:02e0a0aed4ec	1175	const uint8_t * in)
mbed_official	50:a417edff4437	1176	{
mbed_official	50:a417edff4437	1177	uint32_t * _out = (uint32_t *) out;
mbed_official	50:a417edff4437	1178	const uint32_t * _in = (const uint32_t *) in;
mbed_official	50:a417edff4437	1179
<>	161:2cc1468da177	1180	/* Setup CRYPTO in AES-256 mode. */
<>	161:2cc1468da177	1181	crypto->CTRL = CRYPTO_CTRL_AES_AES256;
<>	161:2cc1468da177	1182
mbed_official	50:a417edff4437	1183	/* Load key */
<>	150:02e0a0aed4ec	1184	CRYPTO_BurstToCrypto(&crypto->KEYBUF, &_in[0]);
<>	150:02e0a0aed4ec	1185	CRYPTO_BurstToCrypto(&crypto->KEYBUF, &_in[4]);
mbed_official	50:a417edff4437	1186
mbed_official	50:a417edff4437	1187	/* Do dummy encryption to generate decrypt key */
<>	150:02e0a0aed4ec	1188	crypto->CMD = CRYPTO_CMD_INSTR_AESENC;
mbed_official	50:a417edff4437	1189
mbed_official	50:a417edff4437	1190	/* Save decryption key */
<>	150:02e0a0aed4ec	1191	CRYPTO_BurstFromCrypto(&crypto->KEY, &_out[0]);
<>	150:02e0a0aed4ec	1192	CRYPTO_BurstFromCrypto(&crypto->KEY, &_out[4]);
mbed_official	50:a417edff4437	1193	}
mbed_official	50:a417edff4437	1194
mbed_official	50:a417edff4437	1195	/*************************************************************************//
mbed_official	50:a417edff4437	1196	* @brief
mbed_official	50:a417edff4437	1197	* AES Electronic Codebook (ECB) cipher mode encryption/decryption,
mbed_official	50:a417edff4437	1198	* 128 bit key.
mbed_official	50:a417edff4437	1199	*
mbed_official	50:a417edff4437	1200	* @details
mbed_official	50:a417edff4437	1201	* Encryption:
mbed_official	50:a417edff4437	1202	* @verbatim
mbed_official	50:a417edff4437	1203	* Plaintext Plaintext
mbed_official	50:a417edff4437	1204	* \| \|
mbed_official	50:a417edff4437	1205	* V V
mbed_official	50:a417edff4437	1206	* +--------------+ +--------------+
mbed_official	50:a417edff4437	1207	* Key ->\| Block cipher \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	1208	* \| encryption \| \| encryption \|
mbed_official	50:a417edff4437	1209	* +--------------+ +--------------+
mbed_official	50:a417edff4437	1210	* \| \|
mbed_official	50:a417edff4437	1211	* V V
mbed_official	50:a417edff4437	1212	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	1213	* @endverbatim
mbed_official	50:a417edff4437	1214	* Decryption:
mbed_official	50:a417edff4437	1215	* @verbatim
mbed_official	50:a417edff4437	1216	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	1217	* \| \|
mbed_official	50:a417edff4437	1218	* V V
mbed_official	50:a417edff4437	1219	* +--------------+ +--------------+
mbed_official	50:a417edff4437	1220	* Key ->\| Block cipher \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	1221	* \| decryption \| \| decryption \|
mbed_official	50:a417edff4437	1222	* +--------------+ +--------------+
mbed_official	50:a417edff4437	1223	* \| \|
mbed_official	50:a417edff4437	1224	* V V
mbed_official	50:a417edff4437	1225	* Plaintext Plaintext
mbed_official	50:a417edff4437	1226	* @endverbatim
mbed_official	50:a417edff4437	1227	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1228	*
<>	150:02e0a0aed4ec	1229	* @param[in] crypto
<>	150:02e0a0aed4ec	1230	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1231	*
mbed_official	50:a417edff4437	1232	* @param[out] out
mbed_official	50:a417edff4437	1233	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1234	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1235	*
mbed_official	50:a417edff4437	1236	* @param[in] in
mbed_official	50:a417edff4437	1237	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1238	*
mbed_official	50:a417edff4437	1239	* @param[in] len
mbed_official	50:a417edff4437	1240	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1241	*
mbed_official	50:a417edff4437	1242	* @param[in] key
mbed_official	50:a417edff4437	1243	* When doing encryption, this is the 128 bit encryption key. When doing
mbed_official	50:a417edff4437	1244	* decryption, this is the 128 bit decryption key. The decryption key may
mbed_official	50:a417edff4437	1245	* be generated from the encryption key with CRYPTO_AES_DecryptKey128().
mbed_official	50:a417edff4437	1246	*
mbed_official	50:a417edff4437	1247	* @param[in] encrypt
mbed_official	50:a417edff4437	1248	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	1249	******************************************************************************/
<>	150:02e0a0aed4ec	1250	void CRYPTO_AES_ECB128(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1251	uint8_t * out,
<>	150:02e0a0aed4ec	1252	const uint8_t * in,
<>	150:02e0a0aed4ec	1253	unsigned int len,
<>	150:02e0a0aed4ec	1254	const uint8_t * key,
<>	150:02e0a0aed4ec	1255	bool encrypt)
mbed_official	50:a417edff4437	1256	{
<>	150:02e0a0aed4ec	1257	crypto->CTRL = CRYPTO_CTRL_AES_AES128;
<>	150:02e0a0aed4ec	1258	CRYPTO_AES_ECBx(crypto, out, in, len, key, encrypt, cryptoKey128Bits);
mbed_official	50:a417edff4437	1259	}
mbed_official	50:a417edff4437	1260
mbed_official	50:a417edff4437	1261	/*************************************************************************//
mbed_official	50:a417edff4437	1262	* @brief
mbed_official	50:a417edff4437	1263	* AES Electronic Codebook (ECB) cipher mode encryption/decryption,
mbed_official	50:a417edff4437	1264	* 256 bit key.
mbed_official	50:a417edff4437	1265	*
mbed_official	50:a417edff4437	1266	* @details
mbed_official	50:a417edff4437	1267	* Please see CRYPTO_AES_ECB128() for ECB figure.
mbed_official	50:a417edff4437	1268	*
mbed_official	50:a417edff4437	1269	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1270	*
<>	150:02e0a0aed4ec	1271	* @param[in] crypto
<>	150:02e0a0aed4ec	1272	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1273	*
mbed_official	50:a417edff4437	1274	* @param[out] out
mbed_official	50:a417edff4437	1275	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1276	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1277	*
mbed_official	50:a417edff4437	1278	* @param[in] in
mbed_official	50:a417edff4437	1279	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1280	*
mbed_official	50:a417edff4437	1281	* @param[in] len
mbed_official	50:a417edff4437	1282	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1283	*
mbed_official	50:a417edff4437	1284	* @param[in] key
mbed_official	50:a417edff4437	1285	* When doing encryption, this is the 256 bit encryption key. When doing
mbed_official	50:a417edff4437	1286	* decryption, this is the 256 bit decryption key. The decryption key may
mbed_official	50:a417edff4437	1287	* be generated from the encryption key with CRYPTO_AES_DecryptKey256().
mbed_official	50:a417edff4437	1288	*
mbed_official	50:a417edff4437	1289	* @param[in] encrypt
mbed_official	50:a417edff4437	1290	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	1291	******************************************************************************/
<>	150:02e0a0aed4ec	1292	void CRYPTO_AES_ECB256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1293	uint8_t * out,
<>	150:02e0a0aed4ec	1294	const uint8_t * in,
<>	150:02e0a0aed4ec	1295	unsigned int len,
<>	150:02e0a0aed4ec	1296	const uint8_t * key,
<>	150:02e0a0aed4ec	1297	bool encrypt)
mbed_official	50:a417edff4437	1298	{
<>	150:02e0a0aed4ec	1299	crypto->CTRL = CRYPTO_CTRL_AES_AES256;
<>	150:02e0a0aed4ec	1300	CRYPTO_AES_ECBx(crypto, out, in, len, key, encrypt, cryptoKey256Bits);
mbed_official	50:a417edff4437	1301	}
mbed_official	50:a417edff4437	1302
mbed_official	50:a417edff4437	1303	/*************************************************************************//
mbed_official	50:a417edff4437	1304	* @brief
mbed_official	50:a417edff4437	1305	* AES Output feedback (OFB) cipher mode encryption/decryption, 128 bit key.
mbed_official	50:a417edff4437	1306	*
mbed_official	50:a417edff4437	1307	* @details
mbed_official	50:a417edff4437	1308	* Encryption:
mbed_official	50:a417edff4437	1309	* @verbatim
mbed_official	50:a417edff4437	1310	* InitVector +----------------+
mbed_official	50:a417edff4437	1311	* \| \| \|
mbed_official	50:a417edff4437	1312	* V \| V
mbed_official	50:a417edff4437	1313	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	1314	* Key ->\| Block cipher \| \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	1315	* \| encryption \| \| \| encryption \|
mbed_official	50:a417edff4437	1316	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	1317	* \| \| \|
mbed_official	50:a417edff4437	1318	* \|---------+ \|
mbed_official	50:a417edff4437	1319	* V V
mbed_official	50:a417edff4437	1320	* Plaintext ->XOR Plaintext ->XOR
mbed_official	50:a417edff4437	1321	* \| \|
mbed_official	50:a417edff4437	1322	* V V
mbed_official	50:a417edff4437	1323	* Ciphertext Ciphertext
mbed_official	50:a417edff4437	1324	* @endverbatim
mbed_official	50:a417edff4437	1325	* Decryption:
mbed_official	50:a417edff4437	1326	* @verbatim
mbed_official	50:a417edff4437	1327	* InitVector +----------------+
mbed_official	50:a417edff4437	1328	* \| \| \|
mbed_official	50:a417edff4437	1329	* V \| V
mbed_official	50:a417edff4437	1330	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	1331	* Key ->\| Block cipher \| \| Key ->\| Block cipher \|
mbed_official	50:a417edff4437	1332	* \| encryption \| \| \| encryption \|
mbed_official	50:a417edff4437	1333	* +--------------+ \| +--------------+
mbed_official	50:a417edff4437	1334	* \| \| \|
mbed_official	50:a417edff4437	1335	* \|---------+ \|
mbed_official	50:a417edff4437	1336	* V V
mbed_official	50:a417edff4437	1337	* Ciphertext ->XOR Ciphertext ->XOR
mbed_official	50:a417edff4437	1338	* \| \|
mbed_official	50:a417edff4437	1339	* V V
mbed_official	50:a417edff4437	1340	* Plaintext Plaintext
mbed_official	50:a417edff4437	1341	* @endverbatim
mbed_official	50:a417edff4437	1342	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1343	*
<>	150:02e0a0aed4ec	1344	* @param[in] crypto
<>	150:02e0a0aed4ec	1345	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1346	*
mbed_official	50:a417edff4437	1347	* @param[out] out
mbed_official	50:a417edff4437	1348	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1349	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1350	*
mbed_official	50:a417edff4437	1351	* @param[in] in
mbed_official	50:a417edff4437	1352	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1353	*
mbed_official	50:a417edff4437	1354	* @param[in] len
mbed_official	50:a417edff4437	1355	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1356	*
mbed_official	50:a417edff4437	1357	* @param[in] key
mbed_official	50:a417edff4437	1358	* 128 bit encryption key.
mbed_official	50:a417edff4437	1359	*
mbed_official	50:a417edff4437	1360	* @param[in] iv
mbed_official	50:a417edff4437	1361	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	1362	******************************************************************************/
<>	150:02e0a0aed4ec	1363	void CRYPTO_AES_OFB128(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1364	uint8_t * out,
<>	150:02e0a0aed4ec	1365	const uint8_t * in,
<>	150:02e0a0aed4ec	1366	unsigned int len,
<>	150:02e0a0aed4ec	1367	const uint8_t * key,
<>	150:02e0a0aed4ec	1368	const uint8_t * iv)
mbed_official	50:a417edff4437	1369	{
<>	150:02e0a0aed4ec	1370	crypto->CTRL = CRYPTO_CTRL_AES_AES128;
<>	150:02e0a0aed4ec	1371	CRYPTO_AES_OFBx(crypto, out, in, len, key, iv, cryptoKey128Bits);
mbed_official	50:a417edff4437	1372	}
mbed_official	50:a417edff4437	1373
mbed_official	50:a417edff4437	1374	/*************************************************************************//
mbed_official	50:a417edff4437	1375	* @brief
mbed_official	50:a417edff4437	1376	* AES Output feedback (OFB) cipher mode encryption/decryption, 256 bit key.
mbed_official	50:a417edff4437	1377	*
mbed_official	50:a417edff4437	1378	* @details
mbed_official	50:a417edff4437	1379	* Please see CRYPTO_AES_OFB128() for OFB figure.
mbed_official	50:a417edff4437	1380	*
mbed_official	50:a417edff4437	1381	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1382	*
<>	150:02e0a0aed4ec	1383	* @param[in] crypto
<>	150:02e0a0aed4ec	1384	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1385	*
mbed_official	50:a417edff4437	1386	* @param[out] out
mbed_official	50:a417edff4437	1387	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1388	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1389	*
mbed_official	50:a417edff4437	1390	* @param[in] in
mbed_official	50:a417edff4437	1391	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1392	*
mbed_official	50:a417edff4437	1393	* @param[in] len
mbed_official	50:a417edff4437	1394	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1395	*
mbed_official	50:a417edff4437	1396	* @param[in] key
mbed_official	50:a417edff4437	1397	* 256 bit encryption key.
mbed_official	50:a417edff4437	1398	*
mbed_official	50:a417edff4437	1399	* @param[in] iv
mbed_official	50:a417edff4437	1400	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	1401	******************************************************************************/
<>	150:02e0a0aed4ec	1402	void CRYPTO_AES_OFB256(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1403	uint8_t * out,
<>	150:02e0a0aed4ec	1404	const uint8_t * in,
<>	150:02e0a0aed4ec	1405	unsigned int len,
<>	150:02e0a0aed4ec	1406	const uint8_t * key,
<>	150:02e0a0aed4ec	1407	const uint8_t * iv)
mbed_official	50:a417edff4437	1408	{
<>	150:02e0a0aed4ec	1409	crypto->CTRL = CRYPTO_CTRL_AES_AES256;
<>	150:02e0a0aed4ec	1410	CRYPTO_AES_OFBx(crypto, out, in, len, key, iv, cryptoKey256Bits);
mbed_official	50:a417edff4437	1411	}
mbed_official	50:a417edff4437	1412
mbed_official	50:a417edff4437	1413	/*******************************************************************************
mbed_official	50:a417edff4437	1414	************************ LOCAL FUNCTIONS *****************************
mbed_official	50:a417edff4437	1415	******************************************************************************/
mbed_official	50:a417edff4437	1416
mbed_official	50:a417edff4437	1417	/*************************************************************************//
mbed_official	50:a417edff4437	1418	* @brief
mbed_official	50:a417edff4437	1419	* Cipher-block chaining (CBC) cipher mode encryption/decryption, 128/256 bit key.
mbed_official	50:a417edff4437	1420	*
mbed_official	50:a417edff4437	1421	* @details
mbed_official	50:a417edff4437	1422	* Please see CRYPTO_AES_CBC128() for CBC figure.
mbed_official	50:a417edff4437	1423	*
mbed_official	50:a417edff4437	1424	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1425	*
<>	150:02e0a0aed4ec	1426	* @param[in] crypto
<>	150:02e0a0aed4ec	1427	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1428	*
mbed_official	50:a417edff4437	1429	* @param[out] out
mbed_official	50:a417edff4437	1430	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1431	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1432	*
mbed_official	50:a417edff4437	1433	* @param[in] in
mbed_official	50:a417edff4437	1434	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1435	*
mbed_official	50:a417edff4437	1436	* @param[in] len
mbed_official	50:a417edff4437	1437	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1438	*
mbed_official	50:a417edff4437	1439	* @param[in] key
mbed_official	50:a417edff4437	1440	* When doing encryption, this is the 256 bit encryption key. When doing
mbed_official	50:a417edff4437	1441	* decryption, this is the 256 bit decryption key. The decryption key may
mbed_official	50:a417edff4437	1442	* be generated from the encryption key with CRYPTO_AES_DecryptKey256().
mbed_official	50:a417edff4437	1443	*
mbed_official	50:a417edff4437	1444	* @param[in] iv
mbed_official	50:a417edff4437	1445	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	1446	*
mbed_official	50:a417edff4437	1447	* @param[in] encrypt
mbed_official	50:a417edff4437	1448	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	1449	*
mbed_official	50:a417edff4437	1450	* @param[in] keyWidth
mbed_official	50:a417edff4437	1451	* Set to cryptoKey128Bits or cryptoKey256Bits.
mbed_official	50:a417edff4437	1452	******************************************************************************/
<>	150:02e0a0aed4ec	1453	static void CRYPTO_AES_CBCx(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1454	uint8_t * out,
<>	150:02e0a0aed4ec	1455	const uint8_t * in,
<>	150:02e0a0aed4ec	1456	unsigned int len,
<>	150:02e0a0aed4ec	1457	const uint8_t * key,
<>	150:02e0a0aed4ec	1458	const uint8_t * iv,
<>	150:02e0a0aed4ec	1459	bool encrypt,
mbed_official	50:a417edff4437	1460	CRYPTO_KeyWidth_TypeDef keyWidth)
mbed_official	50:a417edff4437	1461	{
mbed_official	50:a417edff4437	1462	EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
mbed_official	50:a417edff4437	1463
mbed_official	50:a417edff4437	1464	/* Initialize control registers. */
<>	150:02e0a0aed4ec	1465	crypto->WAC = 0;
<>	150:02e0a0aed4ec	1466
<>	150:02e0a0aed4ec	1467	CRYPTO_KeyBufWrite(crypto, (uint32_t *)key, keyWidth);
mbed_official	50:a417edff4437	1468
mbed_official	50:a417edff4437	1469	if (encrypt)
mbed_official	50:a417edff4437	1470	{
<>	150:02e0a0aed4ec	1471	CRYPTO_DataWrite(&crypto->DATA0, (uint32_t *)iv);
mbed_official	50:a417edff4437	1472
<>	150:02e0a0aed4ec	1473	crypto->SEQ0 =
mbed_official	50:a417edff4437	1474	CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1475	CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR1_SHIFT;
<>	150:02e0a0aed4ec	1476
<>	150:02e0a0aed4ec	1477	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1478	&crypto->DATA1, (uint32_t *) in,
<>	150:02e0a0aed4ec	1479	&crypto->DATA0, (uint32_t *) out);
mbed_official	50:a417edff4437	1480	}
mbed_official	50:a417edff4437	1481	else
mbed_official	50:a417edff4437	1482	{
<>	150:02e0a0aed4ec	1483	CRYPTO_DataWrite(&crypto->DATA2, (uint32_t *) iv);
mbed_official	50:a417edff4437	1484
<>	150:02e0a0aed4ec	1485	crypto->SEQ0 =
mbed_official	50:a417edff4437	1486	CRYPTO_CMD_INSTR_DATA1TODATA0 << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1487	CRYPTO_CMD_INSTR_AESDEC << _CRYPTO_SEQ0_INSTR1_SHIFT \|
mbed_official	50:a417edff4437	1488	CRYPTO_CMD_INSTR_DATA2TODATA0XOR << _CRYPTO_SEQ0_INSTR2_SHIFT \|
mbed_official	50:a417edff4437	1489	CRYPTO_CMD_INSTR_DATA1TODATA2 << _CRYPTO_SEQ0_INSTR3_SHIFT;
mbed_official	50:a417edff4437	1490
<>	150:02e0a0aed4ec	1491	crypto->SEQ1 = 0;
mbed_official	50:a417edff4437	1492
mbed_official	50:a417edff4437	1493	/* The following call is equivalent to the last call in the
mbed_official	50:a417edff4437	1494	'if( encrypt )' branch. However moving this
mbed_official	50:a417edff4437	1495	call outside the conditional scope results in slightly poorer
mbed_official	50:a417edff4437	1496	performance for some compiler optimizations. */
<>	150:02e0a0aed4ec	1497	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1498	&crypto->DATA1, (uint32_t *) in,
<>	150:02e0a0aed4ec	1499	&crypto->DATA0, (uint32_t *) out);
mbed_official	50:a417edff4437	1500	}
mbed_official	50:a417edff4437	1501	}
mbed_official	50:a417edff4437	1502
mbed_official	50:a417edff4437	1503	/*************************************************************************//
mbed_official	50:a417edff4437	1504	* @brief
mbed_official	50:a417edff4437	1505	* Cipher feedback (CFB) cipher mode encryption/decryption, 128/256 bit key.
mbed_official	50:a417edff4437	1506	*
mbed_official	50:a417edff4437	1507	* @details
mbed_official	50:a417edff4437	1508	* Please see CRYPTO_AES_CFB128() for CFB figure.
mbed_official	50:a417edff4437	1509	*
mbed_official	50:a417edff4437	1510	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1511	*
<>	150:02e0a0aed4ec	1512	* @param[in] crypto
<>	150:02e0a0aed4ec	1513	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1514	*
mbed_official	50:a417edff4437	1515	* @param[out] out
mbed_official	50:a417edff4437	1516	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1517	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1518	*
mbed_official	50:a417edff4437	1519	* @param[in] in
mbed_official	50:a417edff4437	1520	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1521	*
mbed_official	50:a417edff4437	1522	* @param[in] len
mbed_official	50:a417edff4437	1523	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1524	*
mbed_official	50:a417edff4437	1525	* @param[in] key
mbed_official	50:a417edff4437	1526	* 256 bit encryption key is used for both encryption and decryption modes.
mbed_official	50:a417edff4437	1527	*
mbed_official	50:a417edff4437	1528	* @param[in] iv
mbed_official	50:a417edff4437	1529	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	1530	*
mbed_official	50:a417edff4437	1531	* @param[in] encrypt
mbed_official	50:a417edff4437	1532	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	1533	*
mbed_official	50:a417edff4437	1534	* @param[in] keyWidth
mbed_official	50:a417edff4437	1535	* Set to cryptoKey128Bits or cryptoKey256Bits.
mbed_official	50:a417edff4437	1536	******************************************************************************/
<>	150:02e0a0aed4ec	1537	static void CRYPTO_AES_CFBx(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1538	uint8_t * out,
<>	150:02e0a0aed4ec	1539	const uint8_t * in,
<>	150:02e0a0aed4ec	1540	unsigned int len,
<>	150:02e0a0aed4ec	1541	const uint8_t * key,
<>	150:02e0a0aed4ec	1542	const uint8_t * iv,
<>	150:02e0a0aed4ec	1543	bool encrypt,
mbed_official	50:a417edff4437	1544	CRYPTO_KeyWidth_TypeDef keyWidth)
mbed_official	50:a417edff4437	1545	{
mbed_official	50:a417edff4437	1546	EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
mbed_official	50:a417edff4437	1547
mbed_official	50:a417edff4437	1548	/* Initialize control registers. */
<>	150:02e0a0aed4ec	1549	crypto->WAC = 0;
mbed_official	50:a417edff4437	1550
mbed_official	50:a417edff4437	1551	/* Load Key */
<>	150:02e0a0aed4ec	1552	CRYPTO_KeyBufWrite(crypto, (uint32_t *)key, keyWidth);
mbed_official	50:a417edff4437	1553
mbed_official	50:a417edff4437	1554	/* Load instructions to CRYPTO sequencer. */
mbed_official	50:a417edff4437	1555	if (encrypt)
mbed_official	50:a417edff4437	1556	{
mbed_official	50:a417edff4437	1557	/* Load IV */
<>	150:02e0a0aed4ec	1558	CRYPTO_DataWrite(&crypto->DATA0, (uint32_t *)iv);
mbed_official	50:a417edff4437	1559
<>	150:02e0a0aed4ec	1560	crypto->SEQ0 =
mbed_official	50:a417edff4437	1561	CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1562	CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ0_INSTR1_SHIFT;
<>	150:02e0a0aed4ec	1563
<>	150:02e0a0aed4ec	1564	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1565	&crypto->DATA1, (uint32_t *)in,
<>	150:02e0a0aed4ec	1566	&crypto->DATA0, (uint32_t *)out
mbed_official	50:a417edff4437	1567	);
mbed_official	50:a417edff4437	1568	}
mbed_official	50:a417edff4437	1569	else
mbed_official	50:a417edff4437	1570	{
mbed_official	50:a417edff4437	1571	/* Load IV */
<>	150:02e0a0aed4ec	1572	CRYPTO_DataWrite(&crypto->DATA2, (uint32_t *)iv);
mbed_official	50:a417edff4437	1573
<>	150:02e0a0aed4ec	1574	crypto->SEQ0 =
mbed_official	50:a417edff4437	1575	CRYPTO_CMD_INSTR_DATA2TODATA0 << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1576	CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR1_SHIFT \|
mbed_official	50:a417edff4437	1577	CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ0_INSTR2_SHIFT \|
mbed_official	50:a417edff4437	1578	CRYPTO_CMD_INSTR_DATA1TODATA2 << _CRYPTO_SEQ0_INSTR3_SHIFT;
<>	150:02e0a0aed4ec	1579	crypto->SEQ1 = 0;
<>	150:02e0a0aed4ec	1580
<>	150:02e0a0aed4ec	1581	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1582	&crypto->DATA1, (uint32_t *)in,
<>	150:02e0a0aed4ec	1583	&crypto->DATA0, (uint32_t *)out
mbed_official	50:a417edff4437	1584	);
mbed_official	50:a417edff4437	1585	}
mbed_official	50:a417edff4437	1586	}
mbed_official	50:a417edff4437	1587
mbed_official	50:a417edff4437	1588	/*************************************************************************//
mbed_official	50:a417edff4437	1589	* @brief
mbed_official	50:a417edff4437	1590	* Counter (CTR) cipher mode encryption/decryption, 128/256 bit key.
mbed_official	50:a417edff4437	1591	*
mbed_official	50:a417edff4437	1592	* @details
mbed_official	50:a417edff4437	1593	* Please see CRYPTO_AES_CTR128() for CTR figure.
mbed_official	50:a417edff4437	1594	*
mbed_official	50:a417edff4437	1595	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1596	*
<>	150:02e0a0aed4ec	1597	* @param[in] crypto
<>	150:02e0a0aed4ec	1598	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1599	*
mbed_official	50:a417edff4437	1600	* @param[out] out
mbed_official	50:a417edff4437	1601	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1602	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1603	*
mbed_official	50:a417edff4437	1604	* @param[in] in
mbed_official	50:a417edff4437	1605	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1606	*
mbed_official	50:a417edff4437	1607	* @param[in] len
mbed_official	50:a417edff4437	1608	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1609	*
mbed_official	50:a417edff4437	1610	* @param[in] key
mbed_official	50:a417edff4437	1611	* 256 bit encryption key.
mbed_official	50:a417edff4437	1612	*
mbed_official	50:a417edff4437	1613	* @param[in,out] ctr
mbed_official	50:a417edff4437	1614	* 128 bit initial counter value. The counter is updated after each AES
mbed_official	50:a417edff4437	1615	* block encoding through use of @p ctrFunc.
mbed_official	50:a417edff4437	1616	*
mbed_official	50:a417edff4437	1617	* @param[in] ctrFunc
mbed_official	50:a417edff4437	1618	* Function used to update counter value. Not supported by CRYPTO.
mbed_official	50:a417edff4437	1619	* This parameter is included in order for backwards compatibility with
mbed_official	50:a417edff4437	1620	* the EFM32 em_aes.h API.
mbed_official	50:a417edff4437	1621	*
mbed_official	50:a417edff4437	1622	* @param[in] keyWidth
mbed_official	50:a417edff4437	1623	* Set to cryptoKey128Bits or cryptoKey256Bits.
mbed_official	50:a417edff4437	1624	******************************************************************************/
<>	150:02e0a0aed4ec	1625	static void CRYPTO_AES_CTRx(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1626	uint8_t * out,
<>	150:02e0a0aed4ec	1627	const uint8_t * in,
<>	150:02e0a0aed4ec	1628	unsigned int len,
<>	150:02e0a0aed4ec	1629	const uint8_t * key,
<>	150:02e0a0aed4ec	1630	uint8_t * ctr,
mbed_official	50:a417edff4437	1631	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc,
mbed_official	50:a417edff4437	1632	CRYPTO_KeyWidth_TypeDef keyWidth)
mbed_official	50:a417edff4437	1633	{
mbed_official	50:a417edff4437	1634	(void) ctrFunc;
<>	150:02e0a0aed4ec	1635
mbed_official	50:a417edff4437	1636	EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
mbed_official	50:a417edff4437	1637
mbed_official	50:a417edff4437	1638	/* Initialize control registers. */
<>	150:02e0a0aed4ec	1639	crypto->CTRL \|= CRYPTO_CTRL_INCWIDTH_INCWIDTH4;
<>	150:02e0a0aed4ec	1640	crypto->WAC = 0;
mbed_official	50:a417edff4437	1641
<>	150:02e0a0aed4ec	1642	CRYPTO_KeyBufWrite(crypto, (uint32_t *)key, keyWidth);
mbed_official	50:a417edff4437	1643
<>	150:02e0a0aed4ec	1644	CRYPTO_DataWrite(&crypto->DATA1, (uint32_t *) ctr);
mbed_official	50:a417edff4437	1645
<>	150:02e0a0aed4ec	1646	crypto->SEQ0 = CRYPTO_CMD_INSTR_DATA1TODATA0 << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1647	CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR1_SHIFT \|
mbed_official	50:a417edff4437	1648	CRYPTO_CMD_INSTR_DATA0TODATA3 << _CRYPTO_SEQ0_INSTR2_SHIFT \|
mbed_official	50:a417edff4437	1649	CRYPTO_CMD_INSTR_DATA1INC << _CRYPTO_SEQ0_INSTR3_SHIFT;
mbed_official	50:a417edff4437	1650
<>	150:02e0a0aed4ec	1651	crypto->SEQ1 = CRYPTO_CMD_INSTR_DATA2TODATA0XOR << _CRYPTO_SEQ1_INSTR4_SHIFT;
mbed_official	50:a417edff4437	1652
<>	150:02e0a0aed4ec	1653	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1654	&crypto->DATA2, (uint32_t *) in,
<>	150:02e0a0aed4ec	1655	&crypto->DATA0, (uint32_t *) out);
mbed_official	50:a417edff4437	1656
<>	150:02e0a0aed4ec	1657	CRYPTO_DataRead(&crypto->DATA1, (uint32_t *) ctr);
mbed_official	50:a417edff4437	1658	}
mbed_official	50:a417edff4437	1659
mbed_official	50:a417edff4437	1660	/*************************************************************************//
mbed_official	50:a417edff4437	1661	* @brief
mbed_official	50:a417edff4437	1662	* Electronic Codebook (ECB) cipher mode encryption/decryption, 128/256 bit key.
mbed_official	50:a417edff4437	1663	*
mbed_official	50:a417edff4437	1664	* @details
mbed_official	50:a417edff4437	1665	* Please see CRYPTO_AES_ECB128() for ECB figure.
mbed_official	50:a417edff4437	1666	*
mbed_official	50:a417edff4437	1667	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1668	*
<>	150:02e0a0aed4ec	1669	* @param[in] crypto
<>	150:02e0a0aed4ec	1670	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1671	*
mbed_official	50:a417edff4437	1672	* @param[out] out
mbed_official	50:a417edff4437	1673	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1674	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1675	*
mbed_official	50:a417edff4437	1676	* @param[in] in
mbed_official	50:a417edff4437	1677	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1678	*
mbed_official	50:a417edff4437	1679	* @param[in] len
mbed_official	50:a417edff4437	1680	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1681	*
mbed_official	50:a417edff4437	1682	* @param[in] key
mbed_official	50:a417edff4437	1683	* When doing encryption, this is the 256 bit encryption key. When doing
mbed_official	50:a417edff4437	1684	* decryption, this is the 256 bit decryption key. The decryption key may
mbed_official	50:a417edff4437	1685	* be generated from the encryption key with CRYPTO_AES_DecryptKey256().
mbed_official	50:a417edff4437	1686	*
mbed_official	50:a417edff4437	1687	* @param[in] encrypt
mbed_official	50:a417edff4437	1688	* Set to true to encrypt, false to decrypt.
mbed_official	50:a417edff4437	1689	*
mbed_official	50:a417edff4437	1690	* @param[in] keyWidth
mbed_official	50:a417edff4437	1691	* Set to cryptoKey128Bits or cryptoKey256Bits.
mbed_official	50:a417edff4437	1692	******************************************************************************/
<>	150:02e0a0aed4ec	1693	static void CRYPTO_AES_ECBx(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1694	uint8_t * out,
<>	150:02e0a0aed4ec	1695	const uint8_t * in,
<>	150:02e0a0aed4ec	1696	unsigned int len,
<>	150:02e0a0aed4ec	1697	const uint8_t * key,
<>	150:02e0a0aed4ec	1698	bool encrypt,
mbed_official	50:a417edff4437	1699	CRYPTO_KeyWidth_TypeDef keyWidth)
mbed_official	50:a417edff4437	1700	{
mbed_official	50:a417edff4437	1701	EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
mbed_official	50:a417edff4437	1702
<>	150:02e0a0aed4ec	1703	crypto->WAC = 0;
mbed_official	50:a417edff4437	1704
<>	150:02e0a0aed4ec	1705	CRYPTO_KeyBufWrite(crypto, (uint32_t *)key, keyWidth);
mbed_official	50:a417edff4437	1706
mbed_official	50:a417edff4437	1707	if (encrypt)
mbed_official	50:a417edff4437	1708	{
<>	150:02e0a0aed4ec	1709	crypto->SEQ0 =
mbed_official	50:a417edff4437	1710	(CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1711	CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ0_INSTR1_SHIFT);
mbed_official	50:a417edff4437	1712	}
mbed_official	50:a417edff4437	1713	else
mbed_official	50:a417edff4437	1714	{
<>	150:02e0a0aed4ec	1715	crypto->SEQ0 =
mbed_official	50:a417edff4437	1716	(CRYPTO_CMD_INSTR_AESDEC << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1717	CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ0_INSTR1_SHIFT);
mbed_official	50:a417edff4437	1718	}
mbed_official	50:a417edff4437	1719
<>	150:02e0a0aed4ec	1720	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1721	&crypto->DATA0, (uint32_t *) in,
<>	150:02e0a0aed4ec	1722	&crypto->DATA1, (uint32_t *) out);
mbed_official	50:a417edff4437	1723	}
mbed_official	50:a417edff4437	1724
mbed_official	50:a417edff4437	1725	/*************************************************************************//
mbed_official	50:a417edff4437	1726	* @brief
mbed_official	50:a417edff4437	1727	* Output feedback (OFB) cipher mode encryption/decryption, 128/256 bit key.
mbed_official	50:a417edff4437	1728	*
mbed_official	50:a417edff4437	1729	* @details
mbed_official	50:a417edff4437	1730	* Please see CRYPTO_AES_OFB128() for OFB figure.
mbed_official	50:a417edff4437	1731	*
mbed_official	50:a417edff4437	1732	* Please refer to general comments on layout and byte ordering of parameters.
mbed_official	50:a417edff4437	1733	*
<>	150:02e0a0aed4ec	1734	* @param[in] crypto
<>	150:02e0a0aed4ec	1735	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1736	*
mbed_official	50:a417edff4437	1737	* @param[out] out
mbed_official	50:a417edff4437	1738	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1739	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1740	*
mbed_official	50:a417edff4437	1741	* @param[in] in
mbed_official	50:a417edff4437	1742	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1743	*
mbed_official	50:a417edff4437	1744	* @param[in] len
mbed_official	50:a417edff4437	1745	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1746	*
mbed_official	50:a417edff4437	1747	* @param[in] key
mbed_official	50:a417edff4437	1748	* 256 bit encryption key.
mbed_official	50:a417edff4437	1749	*
mbed_official	50:a417edff4437	1750	* @param[in] iv
mbed_official	50:a417edff4437	1751	* 128 bit initialization vector to use.
mbed_official	50:a417edff4437	1752	*
mbed_official	50:a417edff4437	1753	* @param[in] keyWidth
mbed_official	50:a417edff4437	1754	* Set to cryptoKey128Bits or cryptoKey256Bits.
mbed_official	50:a417edff4437	1755	******************************************************************************/
<>	150:02e0a0aed4ec	1756	static void CRYPTO_AES_OFBx(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1757	uint8_t * out,
<>	150:02e0a0aed4ec	1758	const uint8_t * in,
<>	150:02e0a0aed4ec	1759	unsigned int len,
<>	150:02e0a0aed4ec	1760	const uint8_t * key,
<>	150:02e0a0aed4ec	1761	const uint8_t * iv,
mbed_official	50:a417edff4437	1762	CRYPTO_KeyWidth_TypeDef keyWidth)
mbed_official	50:a417edff4437	1763	{
mbed_official	50:a417edff4437	1764	EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
mbed_official	50:a417edff4437	1765
<>	150:02e0a0aed4ec	1766	crypto->WAC = 0;
mbed_official	50:a417edff4437	1767
<>	150:02e0a0aed4ec	1768	CRYPTO_KeyBufWrite(crypto, (uint32_t *)key, keyWidth);
mbed_official	50:a417edff4437	1769
<>	150:02e0a0aed4ec	1770	CRYPTO_DataWrite(&crypto->DATA2, (uint32_t *)iv);
mbed_official	50:a417edff4437	1771
<>	150:02e0a0aed4ec	1772	crypto->SEQ0 =
mbed_official	50:a417edff4437	1773	CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ0_INSTR0_SHIFT \|
mbed_official	50:a417edff4437	1774	CRYPTO_CMD_INSTR_DATA2TODATA0 << _CRYPTO_SEQ0_INSTR1_SHIFT \|
mbed_official	50:a417edff4437	1775	CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR2_SHIFT \|
mbed_official	50:a417edff4437	1776	CRYPTO_CMD_INSTR_DATA0TODATA2 << _CRYPTO_SEQ0_INSTR3_SHIFT;
<>	150:02e0a0aed4ec	1777	crypto->SEQ1 =
mbed_official	50:a417edff4437	1778	CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ1_INSTR4_SHIFT \|
mbed_official	50:a417edff4437	1779	CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ1_INSTR5_SHIFT;
mbed_official	50:a417edff4437	1780
<>	150:02e0a0aed4ec	1781	CRYPTO_AES_ProcessLoop(crypto, len,
<>	150:02e0a0aed4ec	1782	&crypto->DATA0, (uint32_t *) in,
<>	150:02e0a0aed4ec	1783	&crypto->DATA1, (uint32_t *) out);
mbed_official	50:a417edff4437	1784	}
mbed_official	50:a417edff4437	1785
mbed_official	50:a417edff4437	1786	/*************************************************************************//
mbed_official	50:a417edff4437	1787	* @brief
mbed_official	50:a417edff4437	1788	* Function performs generic AES loop.
mbed_official	50:a417edff4437	1789	*
mbed_official	50:a417edff4437	1790	* @details
mbed_official	50:a417edff4437	1791	* Function loads given register with provided input data. Triggers CRYPTO to
mbed_official	50:a417edff4437	1792	* perform sequence of instructions and read specified output register to
mbed_official	50:a417edff4437	1793	* output buffer.
mbed_official	50:a417edff4437	1794	*
<>	150:02e0a0aed4ec	1795	* @param[in] crypto
<>	150:02e0a0aed4ec	1796	* Pointer to CRYPTO peripheral register block.
<>	150:02e0a0aed4ec	1797	*
mbed_official	50:a417edff4437	1798	* @param[in] len
mbed_official	50:a417edff4437	1799	* Number of bytes to encrypt/decrypt. Must be a multiple of 16.
mbed_official	50:a417edff4437	1800	*
mbed_official	50:a417edff4437	1801	* @param[in] inReg
mbed_official	50:a417edff4437	1802	* Input register - one of DATA0,DATA1,DATA2,DATA3
mbed_official	50:a417edff4437	1803	*
mbed_official	50:a417edff4437	1804	* @param[in] in
mbed_official	50:a417edff4437	1805	* Buffer holding data to encrypt/decrypt. Must be at least @p len long.
mbed_official	50:a417edff4437	1806	*
mbed_official	50:a417edff4437	1807	* @param[in] outReg
mbed_official	50:a417edff4437	1808	* Output register - one of DATA0,DATA1,DATA2,DATA3
mbed_official	50:a417edff4437	1809	*
mbed_official	50:a417edff4437	1810	* @param[out] out
mbed_official	50:a417edff4437	1811	* Buffer to place encrypted/decrypted data. Must be at least @p len long. It
mbed_official	50:a417edff4437	1812	* may be set equal to @p in, in which case the input buffer is overwritten.
mbed_official	50:a417edff4437	1813	******************************************************************************/
<>	150:02e0a0aed4ec	1814	static inline void CRYPTO_AES_ProcessLoop(CRYPTO_TypeDef * crypto,
<>	150:02e0a0aed4ec	1815	uint32_t len,
mbed_official	50:a417edff4437	1816	CRYPTO_DataReg_TypeDef inReg,
mbed_official	50:a417edff4437	1817	uint32_t * in,
mbed_official	50:a417edff4437	1818	CRYPTO_DataReg_TypeDef outReg,
mbed_official	50:a417edff4437	1819	uint32_t * out)
mbed_official	50:a417edff4437	1820	{
mbed_official	50:a417edff4437	1821	len /= CRYPTO_AES_BLOCKSIZE;
<>	150:02e0a0aed4ec	1822	crypto->SEQCTRL = 16 << _CRYPTO_SEQCTRL_LENGTHA_SHIFT;
mbed_official	50:a417edff4437	1823
mbed_official	50:a417edff4437	1824	while (len--)
mbed_official	50:a417edff4437	1825	{
mbed_official	50:a417edff4437	1826	/* Load data and trigger encryption */
mbed_official	50:a417edff4437	1827	CRYPTO_DataWrite(inReg, (uint32_t *)in);
mbed_official	50:a417edff4437	1828
<>	150:02e0a0aed4ec	1829	crypto->CMD = CRYPTO_CMD_SEQSTART;
mbed_official	50:a417edff4437	1830
mbed_official	50:a417edff4437	1831	/* Save encrypted/decrypted data */
mbed_official	50:a417edff4437	1832	CRYPTO_DataRead(outReg, (uint32_t *)out);
mbed_official	50:a417edff4437	1833
mbed_official	50:a417edff4437	1834	out += 4;
mbed_official	50:a417edff4437	1835	in += 4;
mbed_official	50:a417edff4437	1836	}
mbed_official	50:a417edff4437	1837	}
mbed_official	50:a417edff4437	1838
mbed_official	50:a417edff4437	1839	/** @} (end addtogroup CRYPTO) */
<>	150:02e0a0aed4ec	1840	/** @} (end addtogroup emlib) */
mbed_official	50:a417edff4437	1841
mbed_official	50:a417edff4437	1842	#endif /* defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0) */