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

Users » mbed_official » Code » mbed-dev

mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

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

targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_crypto.c@50:a417edff4437, 2016-01-15 (annotated)

Committer:: mbed_official
Date:: Fri Jan 15 07:45:16 2016 +0000
Revision:: 50:a417edff4437

Synchronized with git revision 6010f32619bfcbb01cc73747d4ff9040863482d9

Full URL: https://github.com/mbedmicro/mbed/commit/6010f32619bfcbb01cc73747d4ff9040863482d9/

Remove doubling of buffer size in realiseEndpoint()

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