added prescaler for 16 bit pwm in LPC1347 target
Fork of mbed-dev by
targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_crypto.c@50:a417edff4437, 2016-01-15 (annotated)
- Committer:
- mbed_official
- Date:
- Fri Jan 15 07:45:16 2016 +0000
- Revision:
- 50:a417edff4437
Synchronized with git revision 6010f32619bfcbb01cc73747d4ff9040863482d9
Full URL: https://github.com/mbedmicro/mbed/commit/6010f32619bfcbb01cc73747d4ff9040863482d9/
Remove doubling of buffer size in realiseEndpoint()
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
mbed_official | 50:a417edff4437 | 1 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 2 | * @file em_crypto.c |
mbed_official | 50:a417edff4437 | 3 | * @brief Cryptography accelerator peripheral API |
mbed_official | 50:a417edff4437 | 4 | * @version 4.2.1 |
mbed_official | 50:a417edff4437 | 5 | ******************************************************************************* |
mbed_official | 50:a417edff4437 | 6 | * @section License |
mbed_official | 50:a417edff4437 | 7 | * <b>(C) Copyright 2015 Silicon Labs, http://www.silabs.com</b> |
mbed_official | 50:a417edff4437 | 8 | ******************************************************************************* |
mbed_official | 50:a417edff4437 | 9 | * |
mbed_official | 50:a417edff4437 | 10 | * Permission is granted to anyone to use this software for any purpose, |
mbed_official | 50:a417edff4437 | 11 | * including commercial applications, and to alter it and redistribute it |
mbed_official | 50:a417edff4437 | 12 | * freely, subject to the following restrictions: |
mbed_official | 50:a417edff4437 | 13 | * |
mbed_official | 50:a417edff4437 | 14 | * 1. The origin of this software must not be misrepresented; you must not |
mbed_official | 50:a417edff4437 | 15 | * claim that you wrote the original software.@n |
mbed_official | 50:a417edff4437 | 16 | * 2. Altered source versions must be plainly marked as such, and must not be |
mbed_official | 50:a417edff4437 | 17 | * misrepresented as being the original software.@n |
mbed_official | 50:a417edff4437 | 18 | * 3. This notice may not be removed or altered from any source distribution. |
mbed_official | 50:a417edff4437 | 19 | * |
mbed_official | 50:a417edff4437 | 20 | * DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no |
mbed_official | 50:a417edff4437 | 21 | * obligation to support this Software. Silicon Labs is providing the |
mbed_official | 50:a417edff4437 | 22 | * Software "AS IS", with no express or implied warranties of any kind, |
mbed_official | 50:a417edff4437 | 23 | * including, but not limited to, any implied warranties of merchantability |
mbed_official | 50:a417edff4437 | 24 | * or fitness for any particular purpose or warranties against infringement |
mbed_official | 50:a417edff4437 | 25 | * of any proprietary rights of a third party. |
mbed_official | 50:a417edff4437 | 26 | * |
mbed_official | 50:a417edff4437 | 27 | * Silicon Labs will not be liable for any consequential, incidental, or |
mbed_official | 50:a417edff4437 | 28 | * special damages, or any other relief, or for any claim by any third party, |
mbed_official | 50:a417edff4437 | 29 | * arising from your use of this Software. |
mbed_official | 50:a417edff4437 | 30 | * |
mbed_official | 50:a417edff4437 | 31 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 32 | #include "em_device.h" |
mbed_official | 50:a417edff4437 | 33 | |
mbed_official | 50:a417edff4437 | 34 | #if defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0) |
mbed_official | 50:a417edff4437 | 35 | |
mbed_official | 50:a417edff4437 | 36 | #include "em_crypto.h" |
mbed_official | 50:a417edff4437 | 37 | #include "em_assert.h" |
mbed_official | 50:a417edff4437 | 38 | #include "em_bitband.h" |
mbed_official | 50:a417edff4437 | 39 | |
mbed_official | 50:a417edff4437 | 40 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 41 | * @addtogroup EM_Library |
mbed_official | 50:a417edff4437 | 42 | * @{ |
mbed_official | 50:a417edff4437 | 43 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 44 | |
mbed_official | 50:a417edff4437 | 45 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 46 | * @addtogroup CRYPTO |
mbed_official | 50:a417edff4437 | 47 | * |
mbed_official | 50:a417edff4437 | 48 | * @brief Cryptography accelerator peripheral API |
mbed_official | 50:a417edff4437 | 49 | * |
mbed_official | 50:a417edff4437 | 50 | * @details |
mbed_official | 50:a417edff4437 | 51 | * This API is intended for use on Silicon Labs target devices, and provides |
mbed_official | 50:a417edff4437 | 52 | * a thin software interface for the functions of the crypto module, including |
mbed_official | 50:a417edff4437 | 53 | * @li AES (Advanced Encryption Standard) @ref crypto_aes |
mbed_official | 50:a417edff4437 | 54 | * @li SHA (Secure Hash Algorithm) @ref crypto_sha |
mbed_official | 50:a417edff4437 | 55 | * @li Big Integer multiplier @ref crypto_mul |
mbed_official | 50:a417edff4437 | 56 | * @li Functions for loading data and executing instruction sequences @ref crypto_exec |
mbed_official | 50:a417edff4437 | 57 | * |
mbed_official | 50:a417edff4437 | 58 | * @n @section crypto_aes AES |
mbed_official | 50:a417edff4437 | 59 | * The AES APIs include support for AES-128 and AES-256 with block cipher |
mbed_official | 50:a417edff4437 | 60 | * modes: |
mbed_official | 50:a417edff4437 | 61 | * @li CBC - Cipher Block Chaining mode |
mbed_official | 50:a417edff4437 | 62 | * @li CFB - Cipher Feedback mode |
mbed_official | 50:a417edff4437 | 63 | * @li CTR - Counter mode |
mbed_official | 50:a417edff4437 | 64 | * @li ECB - Electronic Code Book mode |
mbed_official | 50:a417edff4437 | 65 | * @li OFB - Output Feedback mode |
mbed_official | 50:a417edff4437 | 66 | * |
mbed_official | 50:a417edff4437 | 67 | * For the AES APIs Input/output data (plaintext, ciphertext, key etc) are |
mbed_official | 50:a417edff4437 | 68 | * treated as byte arrays, starting with most significant byte. Ie, 32 bytes |
mbed_official | 50:a417edff4437 | 69 | * of plaintext (B0...B31) is located in memory in the same order, with B0 at |
mbed_official | 50:a417edff4437 | 70 | * the lower address and B31 at the higher address. |
mbed_official | 50:a417edff4437 | 71 | * |
mbed_official | 50:a417edff4437 | 72 | * Byte arrays must always be a multiple of AES block size, ie. a multiple |
mbed_official | 50:a417edff4437 | 73 | * of 16. Padding, if required, is done at the end of the byte array. |
mbed_official | 50:a417edff4437 | 74 | * |
mbed_official | 50:a417edff4437 | 75 | * Byte arrays should be word (32 bit) aligned for performance |
mbed_official | 50:a417edff4437 | 76 | * considerations, since the array is accessed with 32 bit access type. |
mbed_official | 50:a417edff4437 | 77 | * The core MCUs supports unaligned accesses, but with a performance penalty. |
mbed_official | 50:a417edff4437 | 78 | * |
mbed_official | 50:a417edff4437 | 79 | * It is possible to specify the same output buffer as input buffer as long |
mbed_official | 50:a417edff4437 | 80 | * as they point to the same address. In that case the provided input buffer |
mbed_official | 50:a417edff4437 | 81 | * is replaced with the encrypted/decrypted output. Notice that the buffers |
mbed_official | 50:a417edff4437 | 82 | * must be exactly overlapping. If partly overlapping, the behavior is |
mbed_official | 50:a417edff4437 | 83 | * undefined. |
mbed_official | 50:a417edff4437 | 84 | * |
mbed_official | 50:a417edff4437 | 85 | * It is up to the user to use a cipher mode according to its requirements |
mbed_official | 50:a417edff4437 | 86 | * in order to not break security. Please refer to specific cipher mode |
mbed_official | 50:a417edff4437 | 87 | * theory for details. |
mbed_official | 50:a417edff4437 | 88 | * |
mbed_official | 50:a417edff4437 | 89 | * References: |
mbed_official | 50:a417edff4437 | 90 | * @li Wikipedia - Cipher modes, http://en.wikipedia.org/wiki/Cipher_modes |
mbed_official | 50:a417edff4437 | 91 | * |
mbed_official | 50:a417edff4437 | 92 | * @li Recommendation for Block Cipher Modes of Operation, |
mbed_official | 50:a417edff4437 | 93 | * NIST Special Publication 800-38A, 2001 Edition, |
mbed_official | 50:a417edff4437 | 94 | * http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf |
mbed_official | 50:a417edff4437 | 95 | * |
mbed_official | 50:a417edff4437 | 96 | * @li Recommendation for Block Cipher Modes of Operation, |
mbed_official | 50:a417edff4437 | 97 | * http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf |
mbed_official | 50:a417edff4437 | 98 | * |
mbed_official | 50:a417edff4437 | 99 | * @n @section crypto_sha SHA |
mbed_official | 50:a417edff4437 | 100 | * The SHA APIs include support for |
mbed_official | 50:a417edff4437 | 101 | * @li SHA-1 @ref CRYPTO_SHA_1 |
mbed_official | 50:a417edff4437 | 102 | * @li SHA-256 @ref CRYPTO_SHA_256 |
mbed_official | 50:a417edff4437 | 103 | * |
mbed_official | 50:a417edff4437 | 104 | * The SHA-1 implementation is FIPS-180-1 compliant, ref: |
mbed_official | 50:a417edff4437 | 105 | * @li Wikipedia - SHA-1, https://en.wikipedia.org/wiki/SHA-1 |
mbed_official | 50:a417edff4437 | 106 | * @li SHA-1 spec - http://www.itl.nist.gov/fipspubs/fip180-1.htm |
mbed_official | 50:a417edff4437 | 107 | * |
mbed_official | 50:a417edff4437 | 108 | * The SHA-256 implementation is FIPS-180-2 compliant, ref: |
mbed_official | 50:a417edff4437 | 109 | * @li Wikipedia - SHA-2, https://en.wikipedia.org/wiki/SHA-2 |
mbed_official | 50:a417edff4437 | 110 | * @li SHA-2 spec - http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf |
mbed_official | 50:a417edff4437 | 111 | * |
mbed_official | 50:a417edff4437 | 112 | * @n @section crypto_mul CRYPTO_Mul |
mbed_official | 50:a417edff4437 | 113 | * @ref CRYPTO_Mul is a function for multiplying big integers that are |
mbed_official | 50:a417edff4437 | 114 | * bigger than the operand size of the MUL instruction which is 128 bits. |
mbed_official | 50:a417edff4437 | 115 | * CRYPTO_Mul multiplies all partial operands of the input operands using |
mbed_official | 50:a417edff4437 | 116 | * MUL to form a resulting number which may be twice the size of |
mbed_official | 50:a417edff4437 | 117 | * the operands. |
mbed_official | 50:a417edff4437 | 118 | * |
mbed_official | 50:a417edff4437 | 119 | * CRPYTO_Mul is typically used by RSA implementations which perform a |
mbed_official | 50:a417edff4437 | 120 | * huge amount of multiplication and square operations in order to |
mbed_official | 50:a417edff4437 | 121 | * implement modular exponentiation. |
mbed_official | 50:a417edff4437 | 122 | * Some RSA implementations use a number representation including arrays |
mbed_official | 50:a417edff4437 | 123 | * of 32bit words of variable size. The user should compile with |
mbed_official | 50:a417edff4437 | 124 | * -D USE_VARIABLE_SIZED_DATA_LOADS in order to load these numbers |
mbed_official | 50:a417edff4437 | 125 | * directly into CRYPTO without converting the number representation. |
mbed_official | 50:a417edff4437 | 126 | * |
mbed_official | 50:a417edff4437 | 127 | * @n @section crypto_exec Load and Execute Instruction Sequences |
mbed_official | 50:a417edff4437 | 128 | * The functions for loading data and executing instruction sequences can |
mbed_official | 50:a417edff4437 | 129 | * be used to implement complex algorithms like elliptic curve cryptography |
mbed_official | 50:a417edff4437 | 130 | * (ECC)) and authenticated encryption algorithms. There are two typical |
mbed_official | 50:a417edff4437 | 131 | * modes of operation: |
mbed_official | 50:a417edff4437 | 132 | * @li Multi sequence operation |
mbed_official | 50:a417edff4437 | 133 | * @li Single static instruction sequence operation |
mbed_official | 50:a417edff4437 | 134 | * |
mbed_official | 50:a417edff4437 | 135 | * In multi sequence mode the software starts by loading input data, then |
mbed_official | 50:a417edff4437 | 136 | * an instruction sequence, execute, and finally read the result. This |
mbed_official | 50:a417edff4437 | 137 | * process is repeated until the full crypto operation is complete. |
mbed_official | 50:a417edff4437 | 138 | * |
mbed_official | 50:a417edff4437 | 139 | * When using a single static instruction sequence, there is just one |
mbed_official | 50:a417edff4437 | 140 | * instruction sequence which is loaded initially. The sequence can be setup |
mbed_official | 50:a417edff4437 | 141 | * to run multiple times. The data can be loaded during the execution of the |
mbed_official | 50:a417edff4437 | 142 | * sequence by using DMA, BUFC and/or programmed I/O directly from the MCU |
mbed_official | 50:a417edff4437 | 143 | * core. For details on how to program the instruction sequences please refer |
mbed_official | 50:a417edff4437 | 144 | * to the reference manual of the particular Silicon Labs device. |
mbed_official | 50:a417edff4437 | 145 | * |
mbed_official | 50:a417edff4437 | 146 | * In order to load input data to the CRYPTO module use any of the following |
mbed_official | 50:a417edff4437 | 147 | * functions: |
mbed_official | 50:a417edff4437 | 148 | * @li @ref CRYPTO_DataWrite - Write 128 bits to a DATA register. |
mbed_official | 50:a417edff4437 | 149 | * @li @ref CRYPTO_DDataWrite - Write 256 bits to a DDATA register. |
mbed_official | 50:a417edff4437 | 150 | * @li @ref CRYPTO_QDataWrite - Write 512 bits to a QDATA register. |
mbed_official | 50:a417edff4437 | 151 | * |
mbed_official | 50:a417edff4437 | 152 | * In order to read output data from the CRYPTO module use any of the |
mbed_official | 50:a417edff4437 | 153 | * following functions: |
mbed_official | 50:a417edff4437 | 154 | * @li @ref CRYPTO_DataRead - Read 128 bits from a DATA register. |
mbed_official | 50:a417edff4437 | 155 | * @li @ref CRYPTO_DDataRead - Read 256 bits from a DDATA register. |
mbed_official | 50:a417edff4437 | 156 | * @li @ref CRYPTO_QDataRead - Read 512 bits from a QDATA register. |
mbed_official | 50:a417edff4437 | 157 | * |
mbed_official | 50:a417edff4437 | 158 | * In order to load an instruction sequence to the CRYPTO module use |
mbed_official | 50:a417edff4437 | 159 | * @ref CRYPTO_InstructionSequenceLoad. |
mbed_official | 50:a417edff4437 | 160 | * |
mbed_official | 50:a417edff4437 | 161 | * In order to execute the current instruction sequence in the CRYPTO module |
mbed_official | 50:a417edff4437 | 162 | * use @ref CRYPTO_InstructionSequenceExecute. |
mbed_official | 50:a417edff4437 | 163 | * |
mbed_official | 50:a417edff4437 | 164 | * In order to check whether an instruction sequence has completed |
mbed_official | 50:a417edff4437 | 165 | * use @ref CRYPTO_InstructionSequenceDone. |
mbed_official | 50:a417edff4437 | 166 | * |
mbed_official | 50:a417edff4437 | 167 | * In order to wait for an instruction sequence to complete |
mbed_official | 50:a417edff4437 | 168 | * use @ref CRYPTO_InstructionSequenceWait. |
mbed_official | 50:a417edff4437 | 169 | * |
mbed_official | 50:a417edff4437 | 170 | * In order to optimally load (with regards to speed) and execute an |
mbed_official | 50:a417edff4437 | 171 | * instruction sequence use any of the CRYPTO_EXECUTE_X macros (where X is |
mbed_official | 50:a417edff4437 | 172 | * in the range 1-20) defined in @ref em_crypto.h. E.g. CRYPTO_EXECUTE_19. |
mbed_official | 50:a417edff4437 | 173 | * @{ |
mbed_official | 50:a417edff4437 | 174 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 175 | |
mbed_official | 50:a417edff4437 | 176 | /******************************************************************************* |
mbed_official | 50:a417edff4437 | 177 | ******************************* DEFINES *********************************** |
mbed_official | 50:a417edff4437 | 178 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 179 | |
mbed_official | 50:a417edff4437 | 180 | /** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */ |
mbed_official | 50:a417edff4437 | 181 | |
mbed_official | 50:a417edff4437 | 182 | #define CRYPTO_INSTRUCTIONS_PER_REG (4) |
mbed_official | 50:a417edff4437 | 183 | #define CRYPTO_INSTRUCTIONS_MAX (12) |
mbed_official | 50:a417edff4437 | 184 | #define CRYPTO_INSTRUCTION_REGS (CRYPTO_INSTRUCTIONS_MAX/CRYPTO_INSTRUCTIONS_PER_REG) |
mbed_official | 50:a417edff4437 | 185 | |
mbed_official | 50:a417edff4437 | 186 | #define CRYPTO_SHA1_BLOCK_SIZE_IN_BITS (512) |
mbed_official | 50:a417edff4437 | 187 | #define CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES (CRYPTO_SHA1_BLOCK_SIZE_IN_BITS/8) |
mbed_official | 50:a417edff4437 | 188 | #define CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS (CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES/sizeof(uint32_t)) |
mbed_official | 50:a417edff4437 | 189 | #define CRYPTO_SHA1_DIGEST_SIZE_IN_32BIT_WORDS (CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES/sizeof(uint32_t)) |
mbed_official | 50:a417edff4437 | 190 | |
mbed_official | 50:a417edff4437 | 191 | #define CRYPTO_SHA256_BLOCK_SIZE_IN_BITS (512) |
mbed_official | 50:a417edff4437 | 192 | #define CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES (CRYPTO_SHA256_BLOCK_SIZE_IN_BITS/8) |
mbed_official | 50:a417edff4437 | 193 | #define CRYPTO_SHA256_BLOCK_SIZE_IN_32BIT_WORDS (CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES/sizeof(uint32_t)) |
mbed_official | 50:a417edff4437 | 194 | |
mbed_official | 50:a417edff4437 | 195 | #define CRYPTO_SHA256_DIGEST_SIZE_IN_32BIT_WORDS (CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES/sizeof(uint32_t)) |
mbed_official | 50:a417edff4437 | 196 | |
mbed_official | 50:a417edff4437 | 197 | #define PARTIAL_OPERAND_WIDTH_LOG2 (7) /* 2^7 = 128 */ |
mbed_official | 50:a417edff4437 | 198 | #define PARTIAL_OPERAND_WIDTH (1<<PARTIAL_OPERAND_WIDTH_LOG2) |
mbed_official | 50:a417edff4437 | 199 | #define PARTIAL_OPERAND_WIDTH_MASK (PARTIAL_OPERAND_WIDTH-1) |
mbed_official | 50:a417edff4437 | 200 | #define PARTIAL_OPERAND_WIDTH_IN_BYTES (PARTIAL_OPERAND_WIDTH/8) |
mbed_official | 50:a417edff4437 | 201 | #define PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS (PARTIAL_OPERAND_WIDTH_IN_BYTES/sizeof(uint32_t)) |
mbed_official | 50:a417edff4437 | 202 | |
mbed_official | 50:a417edff4437 | 203 | #define SWAP32(x) (__REV(x)) |
mbed_official | 50:a417edff4437 | 204 | |
mbed_official | 50:a417edff4437 | 205 | #define CRYPTO_AES_BLOCKSIZE (16) |
mbed_official | 50:a417edff4437 | 206 | |
mbed_official | 50:a417edff4437 | 207 | /******************************************************************************* |
mbed_official | 50:a417edff4437 | 208 | *********************** STATIC FUNCTIONS ********************************** |
mbed_official | 50:a417edff4437 | 209 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 210 | |
mbed_official | 50:a417edff4437 | 211 | static inline void CRYPTO_AES_ProcessLoop(uint32_t len, |
mbed_official | 50:a417edff4437 | 212 | CRYPTO_DataReg_TypeDef inReg, |
mbed_official | 50:a417edff4437 | 213 | uint32_t * in, |
mbed_official | 50:a417edff4437 | 214 | CRYPTO_DataReg_TypeDef outReg, |
mbed_official | 50:a417edff4437 | 215 | uint32_t * out); |
mbed_official | 50:a417edff4437 | 216 | |
mbed_official | 50:a417edff4437 | 217 | static void CRYPTO_AES_CBCx(uint8_t * out, |
mbed_official | 50:a417edff4437 | 218 | const uint8_t * in, |
mbed_official | 50:a417edff4437 | 219 | unsigned int len, |
mbed_official | 50:a417edff4437 | 220 | const uint8_t * key, |
mbed_official | 50:a417edff4437 | 221 | const uint8_t * iv, |
mbed_official | 50:a417edff4437 | 222 | bool encrypt, |
mbed_official | 50:a417edff4437 | 223 | CRYPTO_KeyWidth_TypeDef keyWidth); |
mbed_official | 50:a417edff4437 | 224 | |
mbed_official | 50:a417edff4437 | 225 | static void CRYPTO_AES_CFBx(uint8_t * out, |
mbed_official | 50:a417edff4437 | 226 | const uint8_t * in, |
mbed_official | 50:a417edff4437 | 227 | unsigned int len, |
mbed_official | 50:a417edff4437 | 228 | const uint8_t * key, |
mbed_official | 50:a417edff4437 | 229 | const uint8_t * iv, |
mbed_official | 50:a417edff4437 | 230 | bool encrypt, |
mbed_official | 50:a417edff4437 | 231 | CRYPTO_KeyWidth_TypeDef keyWidth); |
mbed_official | 50:a417edff4437 | 232 | |
mbed_official | 50:a417edff4437 | 233 | static void CRYPTO_AES_CTRx(uint8_t * out, |
mbed_official | 50:a417edff4437 | 234 | const uint8_t * in, |
mbed_official | 50:a417edff4437 | 235 | unsigned int len, |
mbed_official | 50:a417edff4437 | 236 | const uint8_t * key, |
mbed_official | 50:a417edff4437 | 237 | uint8_t * ctr, |
mbed_official | 50:a417edff4437 | 238 | CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc, |
mbed_official | 50:a417edff4437 | 239 | CRYPTO_KeyWidth_TypeDef keyWidth); |
mbed_official | 50:a417edff4437 | 240 | |
mbed_official | 50:a417edff4437 | 241 | static void CRYPTO_AES_ECBx(uint8_t * out, |
mbed_official | 50:a417edff4437 | 242 | const uint8_t * in, |
mbed_official | 50:a417edff4437 | 243 | unsigned int len, |
mbed_official | 50:a417edff4437 | 244 | const uint8_t * key, |
mbed_official | 50:a417edff4437 | 245 | bool encrypt, |
mbed_official | 50:a417edff4437 | 246 | CRYPTO_KeyWidth_TypeDef keyWidth); |
mbed_official | 50:a417edff4437 | 247 | |
mbed_official | 50:a417edff4437 | 248 | static void CRYPTO_AES_OFBx(uint8_t * out, |
mbed_official | 50:a417edff4437 | 249 | const uint8_t * in, |
mbed_official | 50:a417edff4437 | 250 | unsigned int len, |
mbed_official | 50:a417edff4437 | 251 | const uint8_t * key, |
mbed_official | 50:a417edff4437 | 252 | const uint8_t * iv, |
mbed_official | 50:a417edff4437 | 253 | CRYPTO_KeyWidth_TypeDef keyWidth); |
mbed_official | 50:a417edff4437 | 254 | |
mbed_official | 50:a417edff4437 | 255 | #ifdef USE_VARIABLE_SIZED_DATA_LOADS |
mbed_official | 50:a417edff4437 | 256 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 257 | * @brief |
mbed_official | 50:a417edff4437 | 258 | * Write variable sized 32 bit data array (max 128 bits) to a DATAX register |
mbed_official | 50:a417edff4437 | 259 | * |
mbed_official | 50:a417edff4437 | 260 | * @details |
mbed_official | 50:a417edff4437 | 261 | * Write variable sized 32 bit array (max 128 bits / 4 words) to a DATAX |
mbed_official | 50:a417edff4437 | 262 | * register in the CRYPTO module. |
mbed_official | 50:a417edff4437 | 263 | * |
mbed_official | 50:a417edff4437 | 264 | * @param[in] dataReg The 128 bits DATA register. |
mbed_official | 50:a417edff4437 | 265 | * @param[in] val Value of the data to write to the DATA register. |
mbed_official | 50:a417edff4437 | 266 | * @param[in] valSize Size of @ref val in number of 32bit words. |
mbed_official | 50:a417edff4437 | 267 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 268 | __STATIC_INLINE |
mbed_official | 50:a417edff4437 | 269 | void CRYPTO_DataWriteVariableSize(CRYPTO_DataReg_TypeDef dataReg, |
mbed_official | 50:a417edff4437 | 270 | const CRYPTO_Data_TypeDef val, |
mbed_official | 50:a417edff4437 | 271 | int valSize) |
mbed_official | 50:a417edff4437 | 272 | { |
mbed_official | 50:a417edff4437 | 273 | int i; |
mbed_official | 50:a417edff4437 | 274 | volatile uint32_t * reg = (volatile uint32_t *) dataReg; |
mbed_official | 50:a417edff4437 | 275 | |
mbed_official | 50:a417edff4437 | 276 | if (valSize < 4) |
mbed_official | 50:a417edff4437 | 277 | { |
mbed_official | 50:a417edff4437 | 278 | /* Non optimal write of data. */ |
mbed_official | 50:a417edff4437 | 279 | for (i = 0; i < valSize; i++) |
mbed_official | 50:a417edff4437 | 280 | *reg = *val++; |
mbed_official | 50:a417edff4437 | 281 | for (; i < 4; i++) |
mbed_official | 50:a417edff4437 | 282 | *reg = 0; |
mbed_official | 50:a417edff4437 | 283 | } |
mbed_official | 50:a417edff4437 | 284 | else |
mbed_official | 50:a417edff4437 | 285 | { |
mbed_official | 50:a417edff4437 | 286 | CRYPTO_BurstToCrypto(reg, &val[0]); |
mbed_official | 50:a417edff4437 | 287 | } |
mbed_official | 50:a417edff4437 | 288 | } |
mbed_official | 50:a417edff4437 | 289 | #endif |
mbed_official | 50:a417edff4437 | 290 | |
mbed_official | 50:a417edff4437 | 291 | /** @endcond */ |
mbed_official | 50:a417edff4437 | 292 | |
mbed_official | 50:a417edff4437 | 293 | /******************************************************************************* |
mbed_official | 50:a417edff4437 | 294 | ************************** GLOBAL FUNCTIONS ******************************* |
mbed_official | 50:a417edff4437 | 295 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 296 | |
mbed_official | 50:a417edff4437 | 297 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 298 | * @brief |
mbed_official | 50:a417edff4437 | 299 | * Set the modulus type used for wide arithmetic operations. |
mbed_official | 50:a417edff4437 | 300 | * |
mbed_official | 50:a417edff4437 | 301 | * @details |
mbed_official | 50:a417edff4437 | 302 | * This function sets the modulus type to be used by the Modulus instructions |
mbed_official | 50:a417edff4437 | 303 | * of the CRYPTO module. |
mbed_official | 50:a417edff4437 | 304 | * |
mbed_official | 50:a417edff4437 | 305 | * @param[in] modType Modulus type. |
mbed_official | 50:a417edff4437 | 306 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 307 | void CRYPTO_ModulusSet(CRYPTO_ModulusType_TypeDef modType) |
mbed_official | 50:a417edff4437 | 308 | { |
mbed_official | 50:a417edff4437 | 309 | uint32_t temp = CRYPTO->WAC & (~(_CRYPTO_WAC_MODULUS_MASK | _CRYPTO_WAC_MODOP_MASK)); |
mbed_official | 50:a417edff4437 | 310 | |
mbed_official | 50:a417edff4437 | 311 | switch (modType) |
mbed_official | 50:a417edff4437 | 312 | { |
mbed_official | 50:a417edff4437 | 313 | case cryptoModulusBin256: |
mbed_official | 50:a417edff4437 | 314 | case cryptoModulusBin128: |
mbed_official | 50:a417edff4437 | 315 | case cryptoModulusGcmBin128: |
mbed_official | 50:a417edff4437 | 316 | case cryptoModulusEccB233: |
mbed_official | 50:a417edff4437 | 317 | case cryptoModulusEccB163: |
mbed_official | 50:a417edff4437 | 318 | #ifdef _CRYPTO_WAC_MODULUS_ECCBIN233N |
mbed_official | 50:a417edff4437 | 319 | case cryptoModulusEccB233Order: |
mbed_official | 50:a417edff4437 | 320 | case cryptoModulusEccB233KOrder: |
mbed_official | 50:a417edff4437 | 321 | case cryptoModulusEccB163Order: |
mbed_official | 50:a417edff4437 | 322 | case cryptoModulusEccB163KOrder: |
mbed_official | 50:a417edff4437 | 323 | #endif |
mbed_official | 50:a417edff4437 | 324 | CRYPTO->WAC = temp | modType | CRYPTO_WAC_MODOP_BINARY; |
mbed_official | 50:a417edff4437 | 325 | break; |
mbed_official | 50:a417edff4437 | 326 | |
mbed_official | 50:a417edff4437 | 327 | case cryptoModulusEccP256: |
mbed_official | 50:a417edff4437 | 328 | case cryptoModulusEccP224: |
mbed_official | 50:a417edff4437 | 329 | case cryptoModulusEccP192: |
mbed_official | 50:a417edff4437 | 330 | #ifdef _CRYPTO_WAC_MODULUS_ECCPRIME256P |
mbed_official | 50:a417edff4437 | 331 | case cryptoModulusEccP256Order: |
mbed_official | 50:a417edff4437 | 332 | case cryptoModulusEccP224Order: |
mbed_official | 50:a417edff4437 | 333 | case cryptoModulusEccP192Order: |
mbed_official | 50:a417edff4437 | 334 | #endif |
mbed_official | 50:a417edff4437 | 335 | CRYPTO->WAC = temp | modType | CRYPTO_WAC_MODOP_REGULAR; |
mbed_official | 50:a417edff4437 | 336 | break; |
mbed_official | 50:a417edff4437 | 337 | |
mbed_official | 50:a417edff4437 | 338 | default: |
mbed_official | 50:a417edff4437 | 339 | /* Unknown modulus type. */ |
mbed_official | 50:a417edff4437 | 340 | EFM_ASSERT(0); |
mbed_official | 50:a417edff4437 | 341 | } |
mbed_official | 50:a417edff4437 | 342 | } |
mbed_official | 50:a417edff4437 | 343 | |
mbed_official | 50:a417edff4437 | 344 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 345 | * @brief |
mbed_official | 50:a417edff4437 | 346 | * Read the key value currently used by the CRYPTO module. |
mbed_official | 50:a417edff4437 | 347 | * |
mbed_official | 50:a417edff4437 | 348 | * @details |
mbed_official | 50:a417edff4437 | 349 | * Read 128 bits or 256 bits from KEY register in the CRYPTO module. |
mbed_official | 50:a417edff4437 | 350 | * |
mbed_official | 50:a417edff4437 | 351 | * @param[in] val Value of the data to write to the KEYBUF register. |
mbed_official | 50:a417edff4437 | 352 | * @param[in] keyWidth Key width - 128 or 256 bits |
mbed_official | 50:a417edff4437 | 353 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 354 | void CRYPTO_KeyRead(CRYPTO_KeyBuf_TypeDef val, |
mbed_official | 50:a417edff4437 | 355 | CRYPTO_KeyWidth_TypeDef keyWidth) |
mbed_official | 50:a417edff4437 | 356 | { |
mbed_official | 50:a417edff4437 | 357 | EFM_ASSERT(val); |
mbed_official | 50:a417edff4437 | 358 | |
mbed_official | 50:a417edff4437 | 359 | CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &val[0]); |
mbed_official | 50:a417edff4437 | 360 | if (keyWidth == cryptoKey256Bits) |
mbed_official | 50:a417edff4437 | 361 | { |
mbed_official | 50:a417edff4437 | 362 | CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &val[4]); |
mbed_official | 50:a417edff4437 | 363 | } |
mbed_official | 50:a417edff4437 | 364 | } |
mbed_official | 50:a417edff4437 | 365 | |
mbed_official | 50:a417edff4437 | 366 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 367 | * @brief |
mbed_official | 50:a417edff4437 | 368 | * Perform a SHA-1 hash operation on a message. |
mbed_official | 50:a417edff4437 | 369 | * |
mbed_official | 50:a417edff4437 | 370 | * @details |
mbed_official | 50:a417edff4437 | 371 | * This function performs a SHA-1 hash operation on the message specified by |
mbed_official | 50:a417edff4437 | 372 | * msg with length msgLen, and returns the message digest in msgDigest. |
mbed_official | 50:a417edff4437 | 373 | * |
mbed_official | 50:a417edff4437 | 374 | * @param[in] msg Message to hash. |
mbed_official | 50:a417edff4437 | 375 | * @param[in] msgLen Length of message in bytes. |
mbed_official | 50:a417edff4437 | 376 | * @param[out] msgDigest Message digest. |
mbed_official | 50:a417edff4437 | 377 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 378 | void CRYPTO_SHA_1(const uint8_t * msg, |
mbed_official | 50:a417edff4437 | 379 | uint64_t msgLen, |
mbed_official | 50:a417edff4437 | 380 | CRYPTO_SHA1_Digest_TypeDef msgDigest) |
mbed_official | 50:a417edff4437 | 381 | { |
mbed_official | 50:a417edff4437 | 382 | uint32_t temp; |
mbed_official | 50:a417edff4437 | 383 | int len; |
mbed_official | 50:a417edff4437 | 384 | int blockLen; |
mbed_official | 50:a417edff4437 | 385 | uint32_t shaBlock[CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS]= |
mbed_official | 50:a417edff4437 | 386 | { |
mbed_official | 50:a417edff4437 | 387 | /* Initial value */ |
mbed_official | 50:a417edff4437 | 388 | 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 |
mbed_official | 50:a417edff4437 | 389 | }; |
mbed_official | 50:a417edff4437 | 390 | uint8_t * p8ShaBlock = (uint8_t *) shaBlock; |
mbed_official | 50:a417edff4437 | 391 | |
mbed_official | 50:a417edff4437 | 392 | /* Initialize crypto module to do SHA-1. */ |
mbed_official | 50:a417edff4437 | 393 | CRYPTO->CTRL = CRYPTO_CTRL_SHA_SHA1; |
mbed_official | 50:a417edff4437 | 394 | CRYPTO->SEQCTRL = 0; |
mbed_official | 50:a417edff4437 | 395 | CRYPTO->SEQCTRLB = 0; |
mbed_official | 50:a417edff4437 | 396 | |
mbed_official | 50:a417edff4437 | 397 | /* Set result width of MADD32 operation. */ |
mbed_official | 50:a417edff4437 | 398 | CRYPTO_ResultWidthSet(cryptoResult256Bits); |
mbed_official | 50:a417edff4437 | 399 | |
mbed_official | 50:a417edff4437 | 400 | /* Write init value to DDATA1. */ |
mbed_official | 50:a417edff4437 | 401 | CRYPTO_DDataWrite(cryptoRegDDATA1, shaBlock); |
mbed_official | 50:a417edff4437 | 402 | |
mbed_official | 50:a417edff4437 | 403 | /* Copy data to DDATA0 and select DDATA0 and DDATA1 for SHA operation. */ |
mbed_official | 50:a417edff4437 | 404 | CRYPTO_EXECUTE_2(CRYPTO_CMD_INSTR_DDATA1TODDATA0, |
mbed_official | 50:a417edff4437 | 405 | CRYPTO_CMD_INSTR_SELDDATA0DDATA1); |
mbed_official | 50:a417edff4437 | 406 | |
mbed_official | 50:a417edff4437 | 407 | len = msgLen; |
mbed_official | 50:a417edff4437 | 408 | |
mbed_official | 50:a417edff4437 | 409 | while (len >= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES) |
mbed_official | 50:a417edff4437 | 410 | { |
mbed_official | 50:a417edff4437 | 411 | /* Write block to QDATA1. */ |
mbed_official | 50:a417edff4437 | 412 | CRYPTO_QDataWrite(cryptoRegQDATA1BIG, (uint32_t *) msg); |
mbed_official | 50:a417edff4437 | 413 | |
mbed_official | 50:a417edff4437 | 414 | /* Execute SHA */ |
mbed_official | 50:a417edff4437 | 415 | CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA, |
mbed_official | 50:a417edff4437 | 416 | CRYPTO_CMD_INSTR_MADD32, |
mbed_official | 50:a417edff4437 | 417 | CRYPTO_CMD_INSTR_DDATA0TODDATA1); |
mbed_official | 50:a417edff4437 | 418 | |
mbed_official | 50:a417edff4437 | 419 | len -= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES; |
mbed_official | 50:a417edff4437 | 420 | msg += CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES; |
mbed_official | 50:a417edff4437 | 421 | } |
mbed_official | 50:a417edff4437 | 422 | |
mbed_official | 50:a417edff4437 | 423 | blockLen = 0; |
mbed_official | 50:a417edff4437 | 424 | |
mbed_official | 50:a417edff4437 | 425 | /* Build the last (or second to last) block */ |
mbed_official | 50:a417edff4437 | 426 | for (; len; len--) |
mbed_official | 50:a417edff4437 | 427 | p8ShaBlock[blockLen++] = *msg++; |
mbed_official | 50:a417edff4437 | 428 | |
mbed_official | 50:a417edff4437 | 429 | /* append the '1' bit */ |
mbed_official | 50:a417edff4437 | 430 | p8ShaBlock[blockLen++] = 0x80; |
mbed_official | 50:a417edff4437 | 431 | |
mbed_official | 50:a417edff4437 | 432 | /* if the length is currently above 56 bytes we append zeros |
mbed_official | 50:a417edff4437 | 433 | * then compress. Then we can fall back to padding zeros and length |
mbed_official | 50:a417edff4437 | 434 | * encoding like normal. |
mbed_official | 50:a417edff4437 | 435 | */ |
mbed_official | 50:a417edff4437 | 436 | if (blockLen > 56) |
mbed_official | 50:a417edff4437 | 437 | { |
mbed_official | 50:a417edff4437 | 438 | while (blockLen < 64) |
mbed_official | 50:a417edff4437 | 439 | p8ShaBlock[blockLen++] = 0; |
mbed_official | 50:a417edff4437 | 440 | |
mbed_official | 50:a417edff4437 | 441 | /* Write block to QDATA1BIG. */ |
mbed_official | 50:a417edff4437 | 442 | CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock); |
mbed_official | 50:a417edff4437 | 443 | |
mbed_official | 50:a417edff4437 | 444 | /* Execute SHA */ |
mbed_official | 50:a417edff4437 | 445 | CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA, |
mbed_official | 50:a417edff4437 | 446 | CRYPTO_CMD_INSTR_MADD32, |
mbed_official | 50:a417edff4437 | 447 | CRYPTO_CMD_INSTR_DDATA0TODDATA1); |
mbed_official | 50:a417edff4437 | 448 | blockLen = 0; |
mbed_official | 50:a417edff4437 | 449 | } |
mbed_official | 50:a417edff4437 | 450 | |
mbed_official | 50:a417edff4437 | 451 | /* pad upto 56 bytes of zeroes */ |
mbed_official | 50:a417edff4437 | 452 | while (blockLen < 56) |
mbed_official | 50:a417edff4437 | 453 | p8ShaBlock[blockLen++] = 0; |
mbed_official | 50:a417edff4437 | 454 | |
mbed_official | 50:a417edff4437 | 455 | /* And finally, encode the message length. */ |
mbed_official | 50:a417edff4437 | 456 | { |
mbed_official | 50:a417edff4437 | 457 | uint64_t msgLenInBits = msgLen << 3; |
mbed_official | 50:a417edff4437 | 458 | temp = msgLenInBits >> 32; |
mbed_official | 50:a417edff4437 | 459 | *(uint32_t*)&p8ShaBlock[56] = SWAP32(temp); |
mbed_official | 50:a417edff4437 | 460 | temp = msgLenInBits & 0xFFFFFFFF; |
mbed_official | 50:a417edff4437 | 461 | *(uint32_t*)&p8ShaBlock[60] = SWAP32(temp); |
mbed_official | 50:a417edff4437 | 462 | } |
mbed_official | 50:a417edff4437 | 463 | |
mbed_official | 50:a417edff4437 | 464 | /* Write block to QDATA1BIG. */ |
mbed_official | 50:a417edff4437 | 465 | CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock); |
mbed_official | 50:a417edff4437 | 466 | |
mbed_official | 50:a417edff4437 | 467 | /* Execute SHA */ |
mbed_official | 50:a417edff4437 | 468 | CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA, |
mbed_official | 50:a417edff4437 | 469 | CRYPTO_CMD_INSTR_MADD32, |
mbed_official | 50:a417edff4437 | 470 | CRYPTO_CMD_INSTR_DDATA0TODDATA1); |
mbed_official | 50:a417edff4437 | 471 | |
mbed_official | 50:a417edff4437 | 472 | /* Read resulting message digest from DDATA0BIG. */ |
mbed_official | 50:a417edff4437 | 473 | ((uint32_t*)msgDigest)[0] = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 474 | ((uint32_t*)msgDigest)[1] = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 475 | ((uint32_t*)msgDigest)[2] = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 476 | ((uint32_t*)msgDigest)[3] = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 477 | ((uint32_t*)msgDigest)[4] = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 478 | temp = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 479 | temp = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 480 | temp = CRYPTO->DDATA0BIG; |
mbed_official | 50:a417edff4437 | 481 | } |
mbed_official | 50:a417edff4437 | 482 | |
mbed_official | 50:a417edff4437 | 483 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 484 | * @brief |
mbed_official | 50:a417edff4437 | 485 | * Perform a SHA-256 hash operation on a message. |
mbed_official | 50:a417edff4437 | 486 | * |
mbed_official | 50:a417edff4437 | 487 | * @details |
mbed_official | 50:a417edff4437 | 488 | * This function performs a SHA-256 hash operation on the message specified |
mbed_official | 50:a417edff4437 | 489 | * by msg with length msgLen, and returns the message digest in msgDigest. |
mbed_official | 50:a417edff4437 | 490 | * |
mbed_official | 50:a417edff4437 | 491 | * @param[in] msg Message to hash. |
mbed_official | 50:a417edff4437 | 492 | * @param[in] msgLen Length of message in bytes. |
mbed_official | 50:a417edff4437 | 493 | * @param[out] msgDigest Message digest. |
mbed_official | 50:a417edff4437 | 494 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 495 | void CRYPTO_SHA_256(const uint8_t * msg, |
mbed_official | 50:a417edff4437 | 496 | uint64_t msgLen, |
mbed_official | 50:a417edff4437 | 497 | CRYPTO_SHA256_Digest_TypeDef msgDigest) |
mbed_official | 50:a417edff4437 | 498 | { |
mbed_official | 50:a417edff4437 | 499 | uint32_t temp; |
mbed_official | 50:a417edff4437 | 500 | int len; |
mbed_official | 50:a417edff4437 | 501 | int blockLen; |
mbed_official | 50:a417edff4437 | 502 | uint32_t shaBlock[CRYPTO_SHA256_BLOCK_SIZE_IN_32BIT_WORDS]= |
mbed_official | 50:a417edff4437 | 503 | { |
mbed_official | 50:a417edff4437 | 504 | /* Initial value */ |
mbed_official | 50:a417edff4437 | 505 | 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, |
mbed_official | 50:a417edff4437 | 506 | 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 |
mbed_official | 50:a417edff4437 | 507 | }; |
mbed_official | 50:a417edff4437 | 508 | uint8_t * p8ShaBlock = (uint8_t *) shaBlock; |
mbed_official | 50:a417edff4437 | 509 | |
mbed_official | 50:a417edff4437 | 510 | /* Initialize crypyo module to do SHA-256 (SHA-2). */ |
mbed_official | 50:a417edff4437 | 511 | CRYPTO->CTRL = CRYPTO_CTRL_SHA_SHA2; |
mbed_official | 50:a417edff4437 | 512 | CRYPTO->SEQCTRL = 0; |
mbed_official | 50:a417edff4437 | 513 | CRYPTO->SEQCTRLB = 0; |
mbed_official | 50:a417edff4437 | 514 | |
mbed_official | 50:a417edff4437 | 515 | /* Set result width of MADD32 operation. */ |
mbed_official | 50:a417edff4437 | 516 | CRYPTO_ResultWidthSet(cryptoResult256Bits); |
mbed_official | 50:a417edff4437 | 517 | |
mbed_official | 50:a417edff4437 | 518 | /* Write init value to DDATA1. */ |
mbed_official | 50:a417edff4437 | 519 | CRYPTO_DDataWrite(cryptoRegDDATA1, shaBlock); |
mbed_official | 50:a417edff4437 | 520 | |
mbed_official | 50:a417edff4437 | 521 | /* Copy data ot DDATA0 and select DDATA0 and DDATA1 for SHA operation. */ |
mbed_official | 50:a417edff4437 | 522 | CRYPTO_EXECUTE_2(CRYPTO_CMD_INSTR_DDATA1TODDATA0, |
mbed_official | 50:a417edff4437 | 523 | CRYPTO_CMD_INSTR_SELDDATA0DDATA1); |
mbed_official | 50:a417edff4437 | 524 | len = msgLen; |
mbed_official | 50:a417edff4437 | 525 | |
mbed_official | 50:a417edff4437 | 526 | while (len >= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES) |
mbed_official | 50:a417edff4437 | 527 | { |
mbed_official | 50:a417edff4437 | 528 | /* Write block to QDATA1BIG. */ |
mbed_official | 50:a417edff4437 | 529 | CRYPTO_QDataWrite(cryptoRegQDATA1BIG, (uint32_t *) msg); |
mbed_official | 50:a417edff4437 | 530 | |
mbed_official | 50:a417edff4437 | 531 | /* Execute SHA */ |
mbed_official | 50:a417edff4437 | 532 | CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA, |
mbed_official | 50:a417edff4437 | 533 | CRYPTO_CMD_INSTR_MADD32, |
mbed_official | 50:a417edff4437 | 534 | CRYPTO_CMD_INSTR_DDATA0TODDATA1); |
mbed_official | 50:a417edff4437 | 535 | |
mbed_official | 50:a417edff4437 | 536 | len -= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES; |
mbed_official | 50:a417edff4437 | 537 | msg += CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES; |
mbed_official | 50:a417edff4437 | 538 | } |
mbed_official | 50:a417edff4437 | 539 | |
mbed_official | 50:a417edff4437 | 540 | blockLen = 0; |
mbed_official | 50:a417edff4437 | 541 | |
mbed_official | 50:a417edff4437 | 542 | /* Build the last (or second to last) block */ |
mbed_official | 50:a417edff4437 | 543 | for (; len; len--) |
mbed_official | 50:a417edff4437 | 544 | p8ShaBlock[blockLen++] = *msg++; |
mbed_official | 50:a417edff4437 | 545 | |
mbed_official | 50:a417edff4437 | 546 | /* append the '1' bit */ |
mbed_official | 50:a417edff4437 | 547 | p8ShaBlock[blockLen++] = 0x80; |
mbed_official | 50:a417edff4437 | 548 | |
mbed_official | 50:a417edff4437 | 549 | /* if the length is currently above 56 bytes we append zeros |
mbed_official | 50:a417edff4437 | 550 | * then compress. Then we can fall back to padding zeros and length |
mbed_official | 50:a417edff4437 | 551 | * encoding like normal. |
mbed_official | 50:a417edff4437 | 552 | */ |
mbed_official | 50:a417edff4437 | 553 | if (blockLen > 56) |
mbed_official | 50:a417edff4437 | 554 | { |
mbed_official | 50:a417edff4437 | 555 | while (blockLen < 64) |
mbed_official | 50:a417edff4437 | 556 | p8ShaBlock[blockLen++] = 0; |
mbed_official | 50:a417edff4437 | 557 | |
mbed_official | 50:a417edff4437 | 558 | /* Write block to QDATA1BIG. */ |
mbed_official | 50:a417edff4437 | 559 | CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock); |
mbed_official | 50:a417edff4437 | 560 | |
mbed_official | 50:a417edff4437 | 561 | /* Execute SHA */ |
mbed_official | 50:a417edff4437 | 562 | CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA, |
mbed_official | 50:a417edff4437 | 563 | CRYPTO_CMD_INSTR_MADD32, |
mbed_official | 50:a417edff4437 | 564 | CRYPTO_CMD_INSTR_DDATA0TODDATA1); |
mbed_official | 50:a417edff4437 | 565 | blockLen = 0; |
mbed_official | 50:a417edff4437 | 566 | } |
mbed_official | 50:a417edff4437 | 567 | |
mbed_official | 50:a417edff4437 | 568 | /* Pad upto 56 bytes of zeroes */ |
mbed_official | 50:a417edff4437 | 569 | while (blockLen < 56) |
mbed_official | 50:a417edff4437 | 570 | p8ShaBlock[blockLen++] = 0; |
mbed_official | 50:a417edff4437 | 571 | |
mbed_official | 50:a417edff4437 | 572 | /* And finally, encode the message length. */ |
mbed_official | 50:a417edff4437 | 573 | { |
mbed_official | 50:a417edff4437 | 574 | uint64_t msgLenInBits = msgLen << 3; |
mbed_official | 50:a417edff4437 | 575 | temp = msgLenInBits >> 32; |
mbed_official | 50:a417edff4437 | 576 | *(uint32_t *)&p8ShaBlock[56] = SWAP32(temp); |
mbed_official | 50:a417edff4437 | 577 | temp = msgLenInBits & 0xFFFFFFFF; |
mbed_official | 50:a417edff4437 | 578 | *(uint32_t *)&p8ShaBlock[60] = SWAP32(temp); |
mbed_official | 50:a417edff4437 | 579 | } |
mbed_official | 50:a417edff4437 | 580 | |
mbed_official | 50:a417edff4437 | 581 | /* Write the final block to QDATA1BIG. */ |
mbed_official | 50:a417edff4437 | 582 | CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock); |
mbed_official | 50:a417edff4437 | 583 | |
mbed_official | 50:a417edff4437 | 584 | /* Execute SHA */ |
mbed_official | 50:a417edff4437 | 585 | CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA, |
mbed_official | 50:a417edff4437 | 586 | CRYPTO_CMD_INSTR_MADD32, |
mbed_official | 50:a417edff4437 | 587 | CRYPTO_CMD_INSTR_DDATA0TODDATA1); |
mbed_official | 50:a417edff4437 | 588 | |
mbed_official | 50:a417edff4437 | 589 | /* Read resulting message digest from DDATA0BIG. */ |
mbed_official | 50:a417edff4437 | 590 | CRYPTO_DDataRead(cryptoRegDDATA0BIG, (uint32_t *)msgDigest); |
mbed_official | 50:a417edff4437 | 591 | } |
mbed_official | 50:a417edff4437 | 592 | |
mbed_official | 50:a417edff4437 | 593 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 594 | * @brief |
mbed_official | 50:a417edff4437 | 595 | * Set 32bit word array to zero. |
mbed_official | 50:a417edff4437 | 596 | * |
mbed_official | 50:a417edff4437 | 597 | * @param[in] words32bits Pointer to 32bit word array |
mbed_official | 50:a417edff4437 | 598 | * @param[in] num32bitWords Number of 32bit words in array |
mbed_official | 50:a417edff4437 | 599 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 600 | __STATIC_INLINE void cryptoBigintZeroize(uint32_t * words32bits, |
mbed_official | 50:a417edff4437 | 601 | int num32bitWords) |
mbed_official | 50:a417edff4437 | 602 | { |
mbed_official | 50:a417edff4437 | 603 | while (num32bitWords--) |
mbed_official | 50:a417edff4437 | 604 | *words32bits++ = 0; |
mbed_official | 50:a417edff4437 | 605 | } |
mbed_official | 50:a417edff4437 | 606 | |
mbed_official | 50:a417edff4437 | 607 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 608 | * @brief |
mbed_official | 50:a417edff4437 | 609 | * Increment value of 32bit word array by one. |
mbed_official | 50:a417edff4437 | 610 | * |
mbed_official | 50:a417edff4437 | 611 | * @param[in] words32bits Pointer to 32bit word array |
mbed_official | 50:a417edff4437 | 612 | * @param[in] num32bitWords Number of 32bit words in array |
mbed_official | 50:a417edff4437 | 613 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 614 | __STATIC_INLINE void cryptoBigintIncrement(uint32_t * words32bits, |
mbed_official | 50:a417edff4437 | 615 | int num32bitWords) |
mbed_official | 50:a417edff4437 | 616 | { |
mbed_official | 50:a417edff4437 | 617 | int i; |
mbed_official | 50:a417edff4437 | 618 | for (i=0; i<num32bitWords; i++) |
mbed_official | 50:a417edff4437 | 619 | if (++words32bits[i] != 0) |
mbed_official | 50:a417edff4437 | 620 | break; |
mbed_official | 50:a417edff4437 | 621 | return; |
mbed_official | 50:a417edff4437 | 622 | } |
mbed_official | 50:a417edff4437 | 623 | |
mbed_official | 50:a417edff4437 | 624 | /***************************************************************************//** |
mbed_official | 50:a417edff4437 | 625 | * @brief |
mbed_official | 50:a417edff4437 | 626 | * Multiply two big integers. |
mbed_official | 50:a417edff4437 | 627 | * |
mbed_official | 50:a417edff4437 | 628 | * @details |
mbed_official | 50:a417edff4437 | 629 | * This function uses the CRYPTO unit to multiply two big integer operands. |
mbed_official | 50:a417edff4437 | 630 | * If USE_VARIABLE_SIZED_DATA_LOADS is defined, the sizes of the operands |
mbed_official | 50:a417edff4437 | 631 | * may be any multiple of 32 bits. If USE_VARIABLE_SIZED_DATA_LOADS is _not_ |
mbed_official | 50:a417edff4437 | 632 | * defined, the sizes of the operands must be a multiple of 128 bits. |
mbed_official | 50:a417edff4437 | 633 | * |
mbed_official | 50:a417edff4437 | 634 | * @param[in] A operand A |
mbed_official | 50:a417edff4437 | 635 | * @param[in] aSize size of operand A in bits |
mbed_official | 50:a417edff4437 | 636 | * @param[in] B operand B |
mbed_official | 50:a417edff4437 | 637 | * @param[in] bSize size of operand B in bits |
mbed_official | 50:a417edff4437 | 638 | * @param[out] R result of multiplication |
mbed_official | 50:a417edff4437 | 639 | * @param[in] rSize size of result buffer R in bits |
mbed_official | 50:a417edff4437 | 640 | ******************************************************************************/ |
mbed_official | 50:a417edff4437 | 641 | void CRYPTO_Mul(uint32_t * A, int aSize, |
mbed_official | 50:a417edff4437 | 642 | uint32_t * B, int bSize, |
mbed_official | 50:a417edff4437 | 643 | uint32_t * R, int rSize) |
mbed_official | 50:a417edff4437 | 644 | { |
mbed_official | 50:a417edff4437 | 645 | int i, j; |
mbed_official | 50:a417edff4437 | 646 | |
mbed_official | 50:a417edff4437 | 647 | /**************** Initializations ******************/ |
mbed_official | 50:a417edff4437 | 648 | |
mbed_official | 50:a417edff4437 | 649 | #ifdef USE_VARIABLE_SIZED_DATA_LOADS |
mbed_official | 50:a417edff4437 | 650 | int numWordsLastOperandA = (aSize&PARTIAL_OPERAND_WIDTH_MASK)>>5; |
mbed_official | 50:a417edff4437 | 651 | int numPartialOperandsA = numWordsLastOperandA ? |
mbed_official | 50:a417edff4437 | 652 | (aSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 : |
mbed_official | 50:a417edff4437 | 653 | aSize >> PARTIAL_OPERAND_WIDTH_LOG2; |
mbed_official | 50:a417edff4437 | 654 | int numWordsLastOperandB = (bSize&PARTIAL_OPERAND_WIDTH_MASK)>>5; |
mbed_official | 50:a417edff4437 | 655 | int numPartialOperandsB = numWordsLastOperandB ? |
mbed_official | 50:a417edff4437 | 656 | (bSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 : |
mbed_official | 50:a417edff4437 | 657 | bSize >> PARTIAL_OPERAND_WIDTH_LOG2; |
mbed_official | 50:a417edff4437 | 658 | int numWordsLastOperandR = (rSize&PARTIAL_OPERAND_WIDTH_MASK)>>5; |
mbed_official | 50:a417edff4437 | 659 | int numPartialOperandsR = numWordsLastOperandR ? |
mbed_official | 50:a417edff4437 | 660 | (rSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 : |
mbed_official | 50:a417edff4437 | 661 | rSize >> PARTIAL_OPERAND_WIDTH_LOG2; |
mbed_official | 50:a417edff4437 | 662 | EFM_ASSERT(numPartialOperandsA + numPartialOperandsB <= numPartialOperandsR); |
mbed_official | 50:a417edff4437 | 663 | #else |
mbed_official | 50:a417edff4437 | 664 | int numPartialOperandsA = aSize >> PARTIAL_OPERAND_WIDTH_LOG2; |
mbed_official | 50:a417edff4437 | 665 | int numPartialOperandsB = bSize >> PARTIAL_OPERAND_WIDTH_LOG2; |
mbed_official | 50:a417edff4437 | 666 | EFM_ASSERT((aSize & PARTIAL_OPERAND_WIDTH_MASK) == 0); |
mbed_official | 50:a417edff4437 | 667 | EFM_ASSERT((bSize & PARTIAL_OPERAND_WIDTH_MASK) == 0); |
mbed_official | 50:a417edff4437 | 668 | #endif |
mbed_official | 50:a417edff4437 | 669 | EFM_ASSERT(aSize + bSize <= rSize); |
mbed_official | 50:a417edff4437 | 670 | |
mbed_official | 50:a417edff4437 | 671 | /* Set R to zero. */ |
mbed_official | 50:a417edff4437 | 672 | cryptoBigintZeroize(R, rSize >> 5); |
mbed_official | 50:a417edff4437 | 673 | |
mbed_official | 50:a417edff4437 | 674 | /* Set multiplication width. */ |
mbed_official | 50:a417edff4437 | 675 | CRYPTO->WAC = CRYPTO_WAC_MULWIDTH_MUL128 | CRYPTO_WAC_RESULTWIDTH_256BIT; |
mbed_official | 50:a417edff4437 | 676 | |
mbed_official | 50:a417edff4437 | 677 | /* Setup DMA request signalling in order for MCU to run in parallel with |
mbed_official | 50:a417edff4437 | 678 | CRYPTO instruction sequence execution, and prepare data loading which |
mbed_official | 50:a417edff4437 | 679 | can take place immediately when CRYPTO is ready inside the instruction |
mbed_official | 50:a417edff4437 | 680 | sequence. */ |
mbed_official | 50:a417edff4437 | 681 | CRYPTO->CTRL = |
mbed_official | 50:a417edff4437 | 682 | CRYPTO_CTRL_DMA0RSEL_DATA0 | CRYPTO_CTRL_DMA0MODE_FULL | |
mbed_official | 50:a417edff4437 | 683 | CRYPTO_CTRL_DMA1RSEL_DATA1 | CRYPTO_CTRL_DMA1MODE_FULL; |
mbed_official | 50:a417edff4437 | 684 | |
mbed_official | 50:a417edff4437 | 685 | CRYPTO_EXECUTE_4( |
mbed_official | 50:a417edff4437 | 686 | CRYPTO_CMD_INSTR_CCLR, /* Carry = 0 */ |
mbed_official | 50:a417edff4437 | 687 | CRYPTO_CMD_INSTR_CLR, /* DDATA0 = 0 */ |
mbed_official | 50:a417edff4437 | 688 | /* clear result accumulation register */ |
mbed_official | 50:a417edff4437 | 689 | CRYPTO_CMD_INSTR_DDATA0TODDATA2, |
mbed_official | 50:a417edff4437 | 690 | CRYPTO_CMD_INSTR_SELDDATA1DDATA3); |
mbed_official | 50:a417edff4437 | 691 | /* |
mbed_official | 50:a417edff4437 | 692 | register map: |
mbed_official | 50:a417edff4437 | 693 | DDATA0: working register |
mbed_official | 50:a417edff4437 | 694 | DDATA1: B(j) |
mbed_official | 50:a417edff4437 | 695 | DDATA2: R(i+j+1) and R(i+j), combined with DMA entry for B(j) |
mbed_official | 50:a417edff4437 | 696 | DDATA3: A(i) |
mbed_official | 50:a417edff4437 | 697 | */ |
mbed_official | 50:a417edff4437 | 698 | |
mbed_official | 50:a417edff4437 | 699 | CRYPTO_SEQ_LOAD_10( |
mbed_official | 50:a417edff4437 | 700 | /* Temporarily load partial operand B(j) to DATA0. */ |
mbed_official | 50:a417edff4437 | 701 | /* R(i+j+1) is still in DATA1 */ |
mbed_official | 50:a417edff4437 | 702 | CRYPTO_CMD_INSTR_DMA0TODATA, |
mbed_official | 50:a417edff4437 | 703 | /* Move B(j) to DDATA1 */ |
mbed_official | 50:a417edff4437 | 704 | CRYPTO_CMD_INSTR_DDATA2TODDATA1, |
mbed_official | 50:a417edff4437 | 705 | |
mbed_official | 50:a417edff4437 | 706 | /* Restore previous partial result (now R(i+j)) */ |
mbed_official | 50:a417edff4437 | 707 | CRYPTO_CMD_INSTR_DATA1TODATA0, |
mbed_official | 50:a417edff4437 | 708 | |
mbed_official | 50:a417edff4437 | 709 | /* Load next partial result R(i+j+1) */ |
mbed_official | 50:a417edff4437 | 710 | CRYPTO_CMD_INSTR_DMA1TODATA, |
mbed_official | 50:a417edff4437 | 711 | |
mbed_official | 50:a417edff4437 | 712 | /* Execute partial multiplication A(i)inDDATA1 * B(j)inDDATA3*/ |
mbed_official | 50:a417edff4437 | 713 | CRYPTO_CMD_INSTR_MULO, |
mbed_official | 50:a417edff4437 | 714 | |
mbed_official | 50:a417edff4437 | 715 | /* Add the result to the previous partial result */ |
mbed_official | 50:a417edff4437 | 716 | /* AND take the previous carry value into account */ |
mbed_official | 50:a417edff4437 | 717 | /* at the right place (bit 128, ADDIC instruction */ |
mbed_official | 50:a417edff4437 | 718 | CRYPTO_CMD_INSTR_SELDDATA0DDATA2, |
mbed_official | 50:a417edff4437 | 719 | CRYPTO_CMD_INSTR_ADDIC, |
mbed_official | 50:a417edff4437 | 720 | |
mbed_official | 50:a417edff4437 | 721 | /* Save the new partial result (lower half) */ |
mbed_official | 50:a417edff4437 | 722 | CRYPTO_CMD_INSTR_DDATA0TODDATA2, |
mbed_official | 50:a417edff4437 | 723 | CRYPTO_CMD_INSTR_DATATODMA0, |
mbed_official | 50:a417edff4437 | 724 | /* Reset the operand selector for next*/ |
mbed_official | 50:a417edff4437 | 725 | CRYPTO_CMD_INSTR_SELDDATA2DDATA3 |
mbed_official | 50:a417edff4437 | 726 | ); |
mbed_official | 50:a417edff4437 | 727 | |
mbed_official | 50:a417edff4437 | 728 | /**************** End Initializations ******************/ |
mbed_official | 50:a417edff4437 | 729 | |
mbed_official | 50:a417edff4437 | 730 | for(i=0; i<numPartialOperandsA; i++) |
mbed_official | 50:a417edff4437 | 731 | { |
mbed_official | 50:a417edff4437 | 732 | /* Load partial operand #1 A>>(i*PARTIAL_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>>(i*PARTIAL_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) */ |