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/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_crypto.c@149:156823d33999, 2016-10-28 (annotated)

Committer:: <>
Date:: Fri Oct 28 11:17:30 2016 +0100
Revision:: 149:156823d33999
Parent:: targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_crypto.c@50:a417edff4437
Child:: 150:02e0a0aed4ec

This updates the lib to the mbed lib v128

NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

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) */