| /************************************************************************************** |
| * Copyright (c) 2016-2017, ARM Limited or its affiliates. All rights reserved * |
| * * |
| * This file and the related binary are licensed under the following license: * |
| * * |
| * ARM Object Code and Header Files License, v1.0 Redistribution. * |
| * * |
| * Redistribution and use of object code, header files, and documentation, without * |
| * modification, are permitted provided that the following conditions are met: * |
| * * |
| * 1) Redistributions must reproduce the above copyright notice and the * |
| * following disclaimer in the documentation and/or other materials * |
| * provided with the distribution. * |
| * * |
| * 2) Unless to the extent explicitly permitted by law, no reverse * |
| * engineering, decompilation, or disassembly of is permitted. * |
| * * |
| * 3) Redistribution and use is permitted solely for the purpose of * |
| * developing or executing applications that are targeted for use * |
| * on an ARM-based product. * |
| * * |
| * DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * |
| * CONTRIBUTORS "AS IS." ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT * |
| * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT, * |
| * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * |
| * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * |
| * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * |
| **************************************************************************************/ |
| |
| |
| |
| |
| #ifndef CRYS_COMMON_H |
| #define CRYS_COMMON_H |
| |
| #include "crys_common_error.h" |
| |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| |
| /************************ Defines ******************************/ |
| |
| #define CRYS_AES_SECRET_KEY_SIZE_IN_WORDS 4 |
| |
| /* the ROT13 definition - relevant only on SW low level engines compiled in the ROT mode */ |
| #define CRYS_COMMON_ROT_13_OFFSET 13 |
| |
| |
| |
| /************************ Enums ********************************/ |
| |
| /************************ Typedefs ****************************/ |
| |
| /************************ Structs *****************************/ |
| |
| /************************ Public Variables *********************/ |
| |
| /************************ Public Functions *********************/ |
| |
| |
| |
| /*********************************************************************** |
| ** |
| * @brief This function executes a reverse bytes copying from one buffer to another buffer. |
| * |
| * Overlapping of buffers is not allowed, excluding the case, when destination and source |
| * buffers are the same. |
| * Example of a 5 byte buffer: |
| * |
| * dst_ptr[4] = src_ptr[0] |
| * dst_ptr[3] = src_ptr[1] |
| * dst_ptr[2] = src_ptr[2] |
| * dst_ptr[1] = src_ptr[3] |
| * dst_ptr[0] = src_ptr[4] |
| * |
| * @param[in] dst_ptr - The pointer to destination buffer. |
| * @param[in] src_ptr - The pointer to source buffer. |
| * @param[in] size - The size in bytes. |
| * |
| */ |
| CRYSError_t CRYS_COMMON_ReverseMemcpy( uint8_t *dst_ptr , uint8_t *src_ptr , uint32_t size ); |
| |
| |
| /*********************************************************************** |
| ** |
| * @brief This function converts aligned words array to bytes array/ |
| * |
| * 1. Assumed, that input buffer is aligned to 4-bytes word and |
| * bytes order is set according to machine endianness. |
| * 2. Output buffer receives data as bytes stream from LSB to MSB. |
| * For increasing performance on small buffers, the output data is given |
| * by rounded down pointer and alignment. |
| * 3. This implementation is given for both Big and Little endian machines. |
| * |
| * |
| * @param[in] in32_ptr - The pointer to aligned input buffer. |
| * @param[in] out32_ptr - The 32-bits pointer to output buffer (rounded down to 4 bytes) . |
| * @param[in] outAlignBits - The actual output data alignment; |
| * @param[in] sizeWords - The size in words (sizeWords >= 1). |
| * |
| * return - no return value. |
| */ |
| void CRYS_COMMON_AlignedWordsArrayToBytes( uint32_t *in32_ptr , uint32_t *out32_ptr , |
| uint32_t outAlignBits, uint32_t sizeWords ); |
| |
| /***********************************************************************/ |
| /** |
| * @brief This function converts in place words byffer to bytes buffer with |
| * reversed endianity of output array. |
| * |
| * The function can convert: |
| * - big endian bytes array to words array with little endian order |
| * of words and backward. |
| * |
| * Note: |
| * 1. Endianness of each word in words buffer should be set allways |
| * according to processor used. |
| * 2. Implementation is given for both big and little endianness of |
| * processor. |
| * |
| * @param[in] buf_ptr - The 32-bits pointer to input/output buffer. |
| * @param[in] sizeWords - The size in words (sizeWords > 0). |
| * |
| * @return - no return value. |
| */ |
| void CRYS_COMMON_InPlaceConvertBytesWordsAndArrayEndianness( |
| uint32_t *buf_ptr, |
| uint32_t sizeWords); |
| |
| |
| /***********************************************************************/ |
| /** |
| * @brief This function converts big endianness bytes array to aligned words |
| * array with words order according to little endian / |
| * |
| * 1. Assumed, that input bytes order is set according |
| * to big endianness: MS Byte is most left, i.e. order is from |
| * Msb to Lsb. |
| * 2. Output words array should set according to |
| * little endianness words order: LSWord is most left, i.e. order |
| * is from Lsw to Msw. Order bytes in each word - according to |
| * 3. Implementation is given for both big and little |
| * endianness of processor. |
| * |
| * @param[out] out32_ptr - The 32-bits pointer to output buffer. |
| * @param[in] sizeOutBuffBytes - The size in bytes of output buffer, must be |
| * aligned to 4 bytes and not less than sizeInBytes. |
| * @param[in] in8_ptr - The pointer to input buffer. |
| * @param[in] sizeInBytes - The size in bytes of input data(sizeBytes >= 1). |
| * |
| * @return CRYSError_t - On success CRYS_OK is returned, on failure a |
| * value MODULE_* as defined in . |
| */ |
| CRYSError_t CRYS_COMMON_ConvertMsbLsbBytesToLswMswWords( |
| uint32_t *out32_ptr, |
| uint32_t sizeOutBuffBytes, |
| const uint8_t *in8_ptr, |
| uint32_t sizeInBytes); |
| |
| |
| /***********************************************************************/ |
| /** |
| * @brief This function converts LE 32bit-words array to BE bytes array. |
| * |
| * Note: The function allows output full size of the data and also output |
| * without leading zeros, if the user gives appropriate exact output |
| * size < input size. |
| * |
| * Assuming: |
| * 1. Output bytes order is according to big endianness: |
| * MS Byte is most left, i.e. order is from Msb to Lsb. |
| * 2. Input array words order is set according to |
| * little endianness words order: LSWord is most left, i.e. order |
| * is from Lsw to Msw. Bytes order in each word - according to |
| * processor endianness. |
| * 3. Owerlapping of buffers is not allowed, besides in |
| * place operation and size aligned to full words. |
| * 4. Implementation is given for both big and little |
| * endianness of processor. |
| * |
| * @param[in] out8_ptr - The bytes pointer to the output buffer. |
| * @param[in] sizeOutBuffBytes - The size of the data in bytes to output; must |
| * be not less, than sizeInBytes. |
| * @param[out] in32_ptr - The pointer to the input buffer. |
| * @param[in] sizeInpBytes - The size of the input data in bytes. The size must |
| * be > 0 and aligned to 4 bytes. |
| * |
| * @return CRYSError_t - On success CRYS_OK is returned, on failure a |
| * value MODULE_* as defined in . |
| */ |
| CRYSError_t CRYS_COMMON_ConvertLswMswWordsToMsbLsbBytes( |
| uint8_t *out8_ptr, |
| uint32_t sizeOutBytes, |
| uint32_t *in32_ptr, |
| uint32_t sizeInpBytes); |
| |
| |
| /***********************************************************************/ |
| /** |
| * @brief VOS_GetGlobalData get the global random key hidden inside the function |
| * the global data implemented for now are random key buffer and AES secret key buffer |
| * |
| * When no_rtos is declared then we allow a global data. The random key/AES secret key are hidden as static inside the function |
| * |
| * |
| * @param[in] Globalid select the buffer |
| * @param[in] GlobalDataSizeWords - the global data buffer size needed in words - this value must be a predetermined value |
| * @param[out] GlobalData_ptr - Pointer to the global buffer returned. The buffer must be at least GlobalDataSizeWords size |
| * |
| * @return CRYSError_t - On success CRYS_OK is returned, on failure an Error as defined in VOS_error |
| */ |
| CRYSError_t CRYS_COMMON_GetGlobalData(uint16_t Globalid, uint32_t *GlobalData_ptr, uint16_t GlobalDataSizeWords); |
| |
| |
| /***********************************************************************/ |
| /** |
| * @brief CRYS_COMMON_StoreGlobalData store the global random key into the global buffer hidden inside the function |
| * the global data implemented for now are random key buffer and AES secret key buffer |
| * |
| * |
| * @param[in] Globalid - random key / AES secret key |
| * @param[in] GlobalDataSizeWords - the global data buffer size needed in words - this value must be a predetermined value |
| * @param[in] GlobalData_ptr - Pointer to the global buffer to be saved. The buffer must be at least GlobalDataSizeWords size |
| * |
| * Return Value: |
| */ |
| CRYSError_t CRYS_COMMON_StoreGlobalData(uint16_t Globalid, uint32_t *GlobalData_ptr, uint16_t GlobalDataSizeWords); |
| |
| |
| /***********************************************************************/ |
| /** |
| * @brief The CRYS_COMMON_CutAndSaveEndOfLliData() function saves the data from end of source |
| * memory, pointed by LLI table, to destination memory, and decreases the LLI table accordingly. |
| * |
| * The function executes the following major steps: |
| * |
| * 1. Starts copy bytes from last byte of last chunk of source LLI table into |
| * last byte of destination memory. |
| * 2. Continues copy bytes in reverse order while not completes copying of all amount of data. |
| * 3. If last chunk of source or destination data is not enough, the function crosses |
| * to next chunk of LLI table. |
| * 4. Decreases the Data size of last updated LLI entry and sets the LAST bit. |
| * 5. Exits with the OK code. |
| * |
| * |
| * @param[in] SrcLliTab_ptr - The pointer to the LLI table, containing pointers and sizes of |
| * chunks of source data. The table need to be aligned and placed |
| * in SEP SRAM. |
| * @param[in] SrcLliTabSize_ptr - The pointer to buffer, containing th size of the LLI table in words. |
| * @param[in] Dest_ptr - The destination address for copying the data. |
| * @param[in] DataSize - The count of bytes to copy. |
| * |
| * @return CRYSError_t - On success CRYS_OK is returned, |
| * - CRYS_COMMON_ERROR_IN_SAVING_LLI_DATA_ERROR |
| * |
| * NOTE: 1. Because the function is intended for internal using, it is presumed that all input parameters |
| * are valid. |
| * 2. Assumed, that copied source not may to take more than two last chunks of source memory. |
| */ |
| CRYSError_t CRYS_COMMON_CutAndSaveEndOfLliData( |
| uint32_t *SrcLliTab_ptr, |
| uint32_t *SrcLliTabSize_ptr, |
| uint8_t *Dst_ptr, |
| uint32_t DataSize); |
| |
| /***********************************************************************/ |
| /** |
| * @brief The CRYS_COMMON_CutAndSaveBeginOfLliData() function saves the data from beginning of source |
| * memory, pointed by LLI table, to destination memory, and decreases the LLI table accordingly. |
| * |
| * The function executes the following major steps: |
| * |
| * 1. Starts copy bytes from first byte of first chunk of source LLI table into |
| * destination memory. |
| * 2. If first chunk of source is not enough, the function crosses |
| * to next chunk of LLI table. |
| * 3. Updates LLI table pointer and size according to copied amount of data. |
| * 5. Exits with the OK code. |
| * |
| * @param[in/out] SrcLliTab_ptr_ptr - The pointer to pointer to the LLI table, containing pointers and |
| * sizes of the chunks of source data. The table need to be aligned and |
| * placed in SRAM. |
| * @param[in/out] SrcLliTabSize_ptr - The pointer to buffer, containing th size of the LLI table in words. |
| * @param[in] Dest_ptr - The destination address for copying the data. |
| * @param[in] DataSize - The count of bytes to copy. |
| * |
| * @return - no return value. |
| * |
| * NOTE: 1. Because the function is intended for internal using, it is presumed that all input parameters |
| * are valid. |
| * 2. Assumed, that copied source not may to take more than two first chunks of source memory. |
| */ |
| void CRYS_COMMON_CutAndSaveBeginOfLliData( |
| uint32_t **SrcLliTab_ptr_ptr, |
| uint32_t *SrcLliTabSize_ptr, |
| uint8_t *Dst_ptr, |
| uint32_t DataSize); |
| |
| /***********************************************************************/ |
| /** |
| * @brief This function converts 32-bit words array with little endian |
| * order of words to bytes array with little endian (LE) order of bytes. |
| * |
| * Assuming: no buffers overlapping, in/out pointers and sizes not equall to NULL, |
| the buffer size must be not less, than input data size. |
| * |
| * @param[out] out8Le - The bytes pointer to output buffer. |
| * @param[in] in32Le - The pointer to input 32-bit words buffer. |
| * @param[in] sizeInWords - The size in words of input data (sizeWords >= 0). |
| * |
| * @return CRYSError_t - On success CRYS_OK is returned, on failure a |
| * value MODULE_* as defined in . |
| */ |
| void CRYS_COMMON_ConvertLswMswWordsToLsbMsbBytes( |
| uint8_t *out8Le, |
| const uint32_t *in32Le, |
| size_t sizeInWords); |
| |
| |
| /***********************************************************************/ |
| /** |
| * @brief This function converts bytes array with little endian (LE) order of |
| * bytes to 32-bit words array with little endian order of words and bytes. |
| * |
| * Assuming: No owerlapping of buffers; in/out pointers and sizes are not equall to NULL. |
| * If is in-place conversion, then the size must be multiple of 4 bytes. |
| * @param[out] out32Le - The 32-bits pointer to output buffer. The buffer size must be |
| * not less, than input data size. |
| * @param[in] in8Le - The pointer to input buffer. |
| * @param[in] sizeInBytes - The size in bytes of input data(sizeBytes > 0). |
| * |
| * @return CRYSError_t - On success CRYS_OK is returned, on failure a |
| * value MODULE_* as defined in . |
| */ |
| void CRYS_COMMON_ConvertLsbMsbBytesToLswMswWords( |
| uint32_t *out32Le, |
| const uint8_t *in8Le, |
| size_t sizeInBytes); |
| |
| |
| /** |
| * The function compares value of byte vector to null. |
| * |
| * @author reuvenl (6/20/2016) |
| * |
| * @param vect - a pointer to bytes vector. |
| * @param sizeBytes - size of the vector. |
| * |
| * @return uint32_t - if vector's value iz zero, then returns 1, else - 0; |
| */ |
| uint32_t CRYS_COMMON_CheckIsVectorZero(uint8_t *vect, uint32_t sizeBytes); |
| |
| |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif |
| |
| |
