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@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:: AnnaBridge
Date:: Wed Feb 20 22:31:08 2019 +0000
Revision:: 189:f392fc9709a3
Parent:: 179:b0033dcd6934

mbed library release version 165

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