ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

PSOC6: update PDL to the latest version

pull/9762/head
Volodymyr Medvid 2019-02-15 14:33:59 +02:00
parent 400fd82972
commit edb944abf0
59 changed files with 3237 additions and 3110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_ble_clk.h
View File

@ -1,6 +1,6 @@
/***************************************************************************//**
* \file cy_ble_clk.h
* \version 3.0
* \version 3.10
*
* The header file of the BLE ECO clock driver.
*
@ -70,7 +70,14 @@
* <table class="doxtable">
* <tr><th>Version</th><th>Changes</th><th>Reason of Change</th></tr>
* <tr>
* <td>3.0.0</td>
* <td>3.10</td>
* <td>Updated the Cy_BLE_EcoConfigure() use case, when the voltageReg parameter is CY_BLE_ECO_VOLTAGE_REG_BLESSLDO
* and the Buck core regulator is enabled.</td>
* <td>Defect fixing: Before, when the Cy_BLE_EcoConfigure() function included the BLE LDO regulator option, the function returned CY_BLE_ECO_HARDWARE_ERROR if
* the Buck core regulator had been enabled.</td>
* </tr>
* <tr>
* <td>3.0</td>
* <td>The initial version. \n The functionality of the BLE ECO clock is migrated from the BLE Middleware to the separated driver (ble_clk).</td>
* <td>Independent usage of BLE ECO clock without BLE Middleware.</td>
* </tr>

313
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto.h
View File

@ -26,18 +26,51 @@
* \addtogroup group_crypto
* \{
* The Crypto driver provides a public API to perform cryptographic and hash
* operations, as well as generate both true and pseudo random numbers
* (TRNG, PRNG).
* operations, as well as generate both true and pseudo random numbers.
*
* It uses a hardware IP block to accelerate operations.
*
* The functions and other declarations used in this driver are in cy_crypto.h,
* cy_crypto_core.h, and cy_crypto_server.h. You can also include cy_pdl.h
* cy_crypto_core.h, and cy_crypto_server.h. You can also include cy_pdl.h
* (ModusToolbox only) to get access to all functions and declarations in the PDL.
*
* The driver
* supports these standards: DES, TDES, AES (128, 192, 256 bits), CMAC-AES, SHA,
* HMAC, PRNG, TRNG, CRC, and RSA.
* The driver implements two usage models:
* * \ref group_crypto_cli_srv
* * \ref group_crypto_lld_api
*
* Mixing these usage models will result in undefined behaviour.
*
* The Crypto driver supports these standards: DES, TDES, AES (128, 192, 256 bits), CMAC-AES, SHA,
* HMAC, PRNG, TRNG, CRC, RSA, ECP, and ECDSA.
* \note ECP and ECDSA are only implemented for the \ref group_crypto_lld_api model.
*
* \section group_crypto_configuration_considerations Configuration Considerations
*
* Firmware sets up a cryptographic operation by passing in the required data as
* parameters in the function calls.
*
* All Crypto functions require a context. A context is a data
* structure that the driver uses for its operations. Firmware declares a
* context (allocates memory) but does not write or read the values in that
* context. In effect, the context is a scratch pad you provide to the driver.
* The driver uses the context to store and manipulate data during cryptographic
* operations.
*
* Several methods require an additional context unique to the particular
* cryptographic technique.
* The Crypto driver header files declare all the required structures for both
* configuration and context.
*
* Some encryption techniques require additional initialization specific to the
* technique. If there is an Init function, you must call it before using any
* other function for that technique, and re-initialize after you use a different
* encryption technique.
*
* For example, use \ref Cy_Crypto_Aes_Init to configure an AES encryption
* operation with the encryption key, and key length.
* Provide pointers to two context structures. You can then call the AES Run functions.
* If you use DES after that, you must re-initialize the AES encryption before using
* it again.
*
* \section group_crypto_definitions Definitions
*
@ -63,16 +96,16 @@
* This function takes a fixed-size key and a block of plaintext data from
* the message and encrypts it to generate ciphertext. Block ciphers are
* reversible. The function performed on a block of encrypted data will
* decrypt it.</td>
* decrypt that data.</td>
* </tr>
*
* <tr>
* <td>Block Cipher Mode</td>
* <td>A mode of encrypting a message using block ciphers for messages of
* <td>A mode of encrypting a message using block ciphers for messages of an
* arbitrary length. The message is padded so that its length is an integer
* multiple of the block size. ECB (Electronic Code Book), CBC (Cipher Block
* Chaining), and CFB (Cipher Feedback) are all modes of using block ciphers
* to create an encrypted message of arbitrary length.
* to create an encrypted message of an arbitrary length.
* </td>
* </tr>
*
@ -80,8 +113,8 @@
* <td>Data Encryption Standard (DES)</td>
* <td>The [DES standard]
* (https://csrc.nist.gov/csrc/media/publications/fips/46/3/archive/1999-10-25/documents/fips46-3.pdf)
* specifies a symmetric-key algorithm for the encryption of electronic data.
* It uses a 56-bit key and a 64-bit message block size.
* specifies a symmetric-key algorithm for encryption of electronic data.
* It uses a 56-bit key. The block size is 64-bits.
* </td>
* </tr>
*
@ -89,7 +122,7 @@
* <td>Triple DES (3DES or TDES)</td>
* <td>The [TDES standard]
* (https://csrc.nist.gov/csrc/media/publications/fips/46/3/archive/1999-10-25/documents/fips46-3.pdf)
* specifies a symmetric-key block cipher, which applies the Data Encryption
* specifies a symmetric-key block cipher that applies the Data Encryption
* Standard (DES) cipher algorithm three times to each data block.
* It uses three 56-bit keys. The block size is 64-bits.
* </td>
@ -99,17 +132,17 @@
* <td>Advanced Encryption Standard (AES)</td>
* <td>The [AES standard] (https://nvlpubs.nist.gov/nistpubs/fips/nist.fips.197.pdf)
* specifies the Rijndael algorithm, a symmetric block
* cipher that can process data blocks of 128 bits, using cipher keys with
* lengths of 128, 192, and 256 bits. Rijndael was designed to handle
* additional block sizes and key lengths, however they are not adopted in
* cipher that can process 128-bit data blocks, using cipher keys with
* 128-, 192-, and 256-bit lengths. Rijndael was designed to handle
* additional block sizes and key lengths. However, they are not adopted in
* this standard. AES is also used for message authentication.
* </td>
* </tr>
*
* <tr>
* <td>Secure Hash Algorithm (SHA)</td>
* <td>Is a cryptographic hash function.
* This function takes a message of the arbitrary length and reduces it to a
* <td>A cryptographic hash function.
* This function takes a message of an arbitrary length and reduces it to a
* fixed-length residue or message digest after performing a series of
* mathematically defined operations that practically guarantee that any
* change in the message will change the hash value. It is used for message
@ -136,7 +169,7 @@
*
* <tr>
* <td>Cipher-based Message Authentication Code (CMAC)</td>
* <td>This is a block cipher-based message authentication code algorithm.
* <td>A block cipher-based message authentication code algorithm.
* It computes the MAC value using the AES block cipher algorithm.</td>
* For more information see [Recommendation for Block Cipher Modes of Operation]
* (https://nvlpubs.nist.gov/nistpubs/specialpublications/nist.sp.800-38b.pdf).
@ -144,7 +177,7 @@
*
* <tr>
* <td>Hash Message Authentication Code (HMAC)</td>
* <td>Is a specific type of message authentication code (MAC) involving a
* <td>A specific type of message authentication code (MAC) that involves a
* cryptographic hash function and a secret cryptographic key.
* It computes the MAC value using a Hash algorithm.
* For more information see [The Keyed-Hash Message Authentication Code standard]
@ -154,7 +187,7 @@
*
* <tr>
* <td>Pseudo Random Number Generator (PRNG)</td>
* <td>Is a Linear Feedback Shift Registers-based algorithm for generating a
* <td>A Linear Feedback Shift Registers-based algorithm for generating a
* sequence of numbers starting from a non-zero seed.</td>
* </tr>
*
@ -176,15 +209,15 @@
*
* <tr>
* <td>Asymmetric Key Cryptography</td>
* <td>Also referred to as Public Key encryption. Someone who wishes to
* receive a message, publishes a very large public key (up to 4096 bits
* currently), which is one of two prime factors of a very large number. The
* other prime factor is the private key of the recipient and a secret.
* Someone wishing to send a message to the publisher of the public key
* encrypts the message with the public key. This message can now be
* decrypted only with the private key (the other prime factor held secret by
* <td>Also referred to as Public Key encryption. To receive a message,
* you publish a very large public key (up to 4096 bits currently).
* That key is one of the two prime factors of a very large number. The
* other prime factor is the recipient's private (secret) key.
* To send a message to the publisher of the public key, you
* encrypt the message with the public key. This message can now be
* decrypted only with the private key (the other prime factor held in secret by
* the recipient). The message is now sent over any channel to the recipient
* who can decrypt it with the private, secret, key. The same process is used
* who can decrypt it with the private (secret) key. The same process is used
* to send messages to the sender of the original message. The asymmetric
* cryptography relies on the mathematical impracticality (usually related to
* the processing power available at any given time) of factoring the keys.
@ -192,7 +225,7 @@
* The public key is described by the pair (n, e) where n is a product of two
* randomly chosen primes p and q. The exponent e is a random integer
* 1 < e < Q where Q = (p-1) (q-1). The private key d is uniquely defined
* by the integer 1 < d < Q such that ed congruent to 1 (mod Q ).
* by the integer 1 < d < Q so that ed congruent with 1 (mod Q ).
* </td>
* </tr>
* </table>
@ -202,10 +235,51 @@
* RSASSA-PKCS1-v1_5 described here, page 31:
* http://www.emc.com/collateral/white-papers/h11300-pkcs-1v2-2-rsa-cryptography-standard-wp.pdf
*
* See the Cryptographic Function Block chapter of the Technical Reference Manual.
* See the "Cryptographic Function Block" chapter of the Technical Reference Manual.
*
* \section group_crypto_MISRA MISRA-C Compliance
* This driver does not contains any driver-specific MISRA violations.
* The Crypto driver has the following specific deviations:
*
* <table class="doxtable">
* <tr>
* <th>MISRA Rule</th>
* <th>Rule Class (Required/Advisory)</th>
* <th>Rule Description</th>
* <th>Description of Deviation(s)</th>
* </tr>
* <tr>
* <td>8.8</td>
* <td>A</td>
* <td>An external object or function shall be declared in one and only
* one file.</td>
* <td>The pointer to the operation context memory can not be public
* accessible (can not be defined in the header file) but it should be
* extarnally accessed, because it is used by other Cypress software
* resources.</td>
* </tr>
* <tr>
* <td>11.4</td>
* <td>A</td>
* <td>A cast should not be performed between a pointer to object type and
* a different pointer to object type.</td>
* <td>The pointers to the context memory are void to allow handling of
* different data types for different operations.
* The cast operation is safe because the configuration is verified
* before operation is performed.
* </td>
* </tr>
* <tr>
* <td>16.7</td>
* <td>A</td>
* <td>A pointer parameter in a function prototype should be declared as
* pointer to const if the pointer is not used to modify the addressed
* object.</td>
* <td>The objects pointed to by the base addresses of the CRYPTO are not
* always modified. While a const qualifier can be used in select
* scenarios, it brings little benefit in adding this to the affected
* functions. </td>
* </tr>
* </table>
*
* \section group_crypto_changelog Changelog
* <table class="doxtable">
@ -214,15 +288,16 @@
* <td>2.20</td>
* <td>
* <ul>
* <li>Moved from pre-compiled library to Open Source under
* <li>Moved from a pre-compiled library to Open Source under
* Apache 2.0 license.</li>
* <li>Added ECP and ECDSA support for NIST P curves:
* <li>Core (server) This API is now available.</li>
* <li>Added ECP and ECDSA support for the NIST P curves:
* SECP192R1, SECP224R1, SECP256R1, SECP384R1, SECP521R1.</li>
* <li>ECP and ECDSA only supported with direct calls to Crypto APIs,
* no client interface functions present.</li>
* <li>Added chunk mode for CRC.</li>
* <li>Added chunk mode for SHA, chunk size is limited to
* SHA block size.</li>
* no client interface functions are present.</li>
* <li>Added Chunk mode for CRC.</li>
* <li>Added Chunk mode for SHA, the chunk size is limited to
* the SHA block size.</li>
* </ul>
* </td>
* <td>ECC support added.<br>
@ -232,22 +307,22 @@
* </tr>
* <tr>
* <td>2.11b</td>
* <td>Same as production 2.10; only newly added Elliptic Curve point
* <td>The same as production 2.10; only the newly-added Elliptic Curve point
* multiplication functionality (NIST P256) is pre-production.
* Open source under Apache version 2.0 license.</td>
* <td></td>
* </tr>
* <tr>
* <td>2.11</td>
* <td>Based on pre-production 2.10, except newly added Elliptic Curve point
* <td>Based on pre-production 2.10, except the newly-added Elliptic Curve point
* multiplication functionality (NIST P256).
* Does not incorporate production level documentation.
* Does not incorporate the production level documentation.
* Open source under Apache version 2.0 license.</td>
* <td>ECC support.</td>
* </tr>
* <tr>
* <td>2.10b</td>
* <td>Same as production 2.10. Open source under Apache version 2.0 license.</td>
* <td>The same as production 2.10. Open source under Apache version 2.0 license.</td>
* <td></td>
* </tr>
* <tr>
@ -267,7 +342,7 @@
* <td></td>
* </tr>
* <tr>
* <td>Added register access layer. Use register access macros instead
* <td>Added the register access layer. Use register access macros instead
* of direct register access using dereferenced pointers.</td>
* <td>Makes register access device-independent, so that the PDL does
* not need to be recompiled for each supported part number.</td>
@ -278,7 +353,7 @@
* </tr>
* <tr>
* <td>2.0b</td>
* <td>Same as production 2.0. Open source under Apache version 2.0 license.</td>
* <td>The same as production 2.0. Open source under Apache version 2.0 license.</td>
* <td></td>
* </tr>
* <tr>
@ -289,15 +364,15 @@
* \ref Cy_Crypto_Trng_Generate, \ref Cy_Crypto_Des_Run,
* \ref Cy_Crypto_Tdes_Run, \ref Cy_Crypto_Rsa_Proc
* </td>
* <td>Documentation update and clarification</td>
* <td>Documentation update and clarification.</td>
* </tr>
* <tr>
* <td>
* Changed crypto IP power control<br>
* Enhanced Vector Unit functionality for RSA crypto algorithm<br>
* Added support of the single-core devices
* Changed crypto IP power control.<br>
* Enhanced Vector Unit functionality for RSA crypto algorithm.<br>
* Added support of the single-core devices.
* </td>
* <td>New device support</td>
* <td>New device support.</td>
* </tr>
* <tr>
* <td>1.0</td>
@ -306,29 +381,24 @@
* </tr>
* </table>
*
* \defgroup group_crypto_cli_srv Client-Server API
* \defgroup group_crypto_cli_srv Client-Server Model
* \{
* \defgroup group_crypto_client Client
* \defgroup group_crypto_cli_srv_macros Macros
* \defgroup group_crypto_cli_srv_functions Functions
* \{
* Client part of the Crypto.
* \defgroup group_crypto_macros Macros
* \defgroup group_crypto_cli_functions Functions
* \defgroup group_crypto_cli_data_structures Data Structures
* \defgroup group_crypto_enums Enumerated Types
* \defgroup group_crypto_cli_functions Client Functions
* \defgroup group_crypto_srv_functions Server Functions
* \}
* \defgroup group_crypto_server Server
* \defgroup group_crypto_cli_srv_data_structures Data Structures
* \{
* Server part of the Crypto.
* \defgroup group_crypto_srv_functions Functions
* \defgroup group_crypto_srv_data_structures Data Structures
* \}
* \defgroup group_crypto_config_structure Configuration Structure
* \{
* Crypto initialization configuration.
* \note Should be the same for Crypto Server and Crypto Client initializations.
* \defgroup group_crypto_config_structure Common Data Structures
* \defgroup group_crypto_cli_data_structures Client Data Structures
* \defgroup group_crypto_srv_data_structures Server Data Structures
* \}
* \}
* \defgroup group_crypto_lld_api Low-Level API
* \defgroup group_crypto_lld_api Direct Crypto Core Access
* \defgroup group_crypto_data_structures Common Data Structures
* \defgroup group_crypto_enums Common Enumerated Types
*/
/**
@ -339,23 +409,22 @@
*
* The functions and other declarations used in this part of the driver are in
* cy_crypto.h and cy_crypto_server.h. You can also include cy_pdl.h
* (ModusToolbox only) to get access to all functions and declarations in the
* (ModusToolbox only) to get access to all functions and declarations in the
* PDL.
*
* Firmware initializes and starts the Crypto server. The server can run on any
* The firmware initializes and starts the Crypto server. The server can run on any
* core and works with the Crypto hardware. The Crypto server is implemented as
* a secure block. It performs all cryptographic operations for the client.
* Access to the server is through the Inter Process Communication (IPC) driver.
* Direct access is not allowed.
*
* The Crypto client can run on any core too. Firmware initializes and starts
* the client. The firmware then provides the configuration data required for
* the desired cryptographic technique, and requests that the server run the
* The Crypto client can run on any core too. The firmware initializes and starts
* the client. The firmware then provides configuration data required for
* the desired cryptographic technique and a request that the server run the
* cryptographic operation.
*
* This document contains the following topics:
* - \ref group_crypto_architecture
* - \ref group_crypto_configuration_considerations
* - \ref group_crypto_configuration_structure
* - \ref group_crypto_server_init
* - \ref group_crypto_client_init
@ -396,23 +465,6 @@
* Using IPC for communication provides a simple synchronization mechanism to
* handle concurrent requests from different cores.
*
* \section group_crypto_configuration_considerations Configuration Considerations
*
* Firmware sets up a cryptographic operation by passing in required data as
* parameters in function calls.
*
* All Crypto functions require a context. A context is a data
* structure that the driver uses for its operations. Firmware declares the
* context (allocates memory) but does not write or read the values in the
* context. In effect the context is a scratch pad you provide to the driver.
* The driver uses the context to store and manipulate data during cryptographic
* operations.
*
* Several methods require an additional context unique to the particular
* cryptographic technique.
* The Crypto driver header files declare all the required structures for both
* configuration and context.
*
* \section group_crypto_configuration_structure Configuration Structure
*
* IPC communication for the Crypto driver is handled transparently. User should
@ -527,17 +579,6 @@
*
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoInit
*
* Some encryption techniques require additional initialization specific to the
* technique. If there is an Init function, you must call it before using any
* other function for that technique, and reinitialize after you use a different
* encryption technique.
*
* For example, use \ref Cy_Crypto_Aes_Init to configure an AES encryption
* operation with the encryption key, and key length.
* Provide pointers to two context structures. You can then call AES Run functions.
* If later on you use DES, you must re-initialize AES encryption before using
* it again.
*
* \section group_crypto_common_use_cases Common Use Cases
*
* \subsection group_crypto_Use_CRC CRC Calculation
@ -667,9 +708,9 @@
* (2^moduloLength mod modulo). These fields are optional, and can be set to NULL.
*
* Calculate these coefficients with \ref Cy_Crypto_Rsa_CalcCoefs.
* Pass in the address of the key structure with the modulus and exponent values
* for the key. The function returns the coefficients for the key in the key
* structure, replacing any previous values.
* Pass them in the address of the key structure with the modulus and exponent
* values for the key. The function returns the coefficients for the key in the
* key structure, replacing any previous values.
*
* The RSA functionality also implements functions to decrypt a signature using
* a public key. This signature must follow the RSASSA-PKCS-v1_5 standard.
@ -786,7 +827,7 @@ cy_en_crypto_status_t Cy_Crypto_GetLibraryInfo(cy_en_crypto_lib_info_t *cryptoIn
* that stores the Crypto driver common context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoInit
@ -801,7 +842,7 @@ cy_en_crypto_status_t Cy_Crypto_Init(cy_stc_crypto_config_t const *config, cy_st
* This function de-initializes the Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_DeInit(void);
@ -813,7 +854,7 @@ cy_en_crypto_status_t Cy_Crypto_DeInit(void);
* This function enables (turns on) the Crypto hardware.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Enable(void);
@ -825,7 +866,7 @@ cy_en_crypto_status_t Cy_Crypto_Enable(void);
* This function disables (turns off) the Crypto hardware.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Disable(void);
@ -843,7 +884,7 @@ cy_en_crypto_status_t Cy_Crypto_Disable(void);
* False - is not blocking.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Sync(bool isBlocking);
@ -859,7 +900,7 @@ cy_en_crypto_status_t Cy_Crypto_Sync(bool isBlocking);
* \ref cy_stc_crypto_hw_error_t.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_GetErrorStatus(cy_stc_crypto_hw_error_t *hwErrorCause);
@ -890,7 +931,7 @@ cy_en_crypto_status_t Cy_Crypto_GetErrorStatus(cy_stc_crypto_hw_error_t *hwError
* the Crypto function context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoPrngUse
@ -920,7 +961,7 @@ cy_en_crypto_status_t Cy_Crypto_Prng_Init(uint32_t lfsr32InitState,
* the Crypto function context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoPrngUse
@ -953,7 +994,7 @@ cy_en_crypto_status_t Cy_Crypto_Prng_Generate(uint32_t max,
* internal variables the Crypto driver requires.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoAesEcbUse
@ -986,7 +1027,7 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Init(uint32_t *key,
* that stores all AES internal variables.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoAesEcbUse
@ -1025,7 +1066,7 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Ecb_Run(cy_en_crypto_dir_mode_t dirMode,
* internal variables the Crypto driver requires.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Aes_Cbc_Run(cy_en_crypto_dir_mode_t dirMode,
@ -1053,17 +1094,17 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Cbc_Run(cy_en_crypto_dir_mode_t dirMode,
* The pointer to the initial vector. __Must be 4-byte aligned.__
*
* \param dst
* The pointer to a destination cipher text. __Must be 4-byte aligned.__
* The pointer to the destination cipher text. __Must be 4-byte aligned.__
*
* \param src
* The pointer to a source plain text. __Must be 4-byte aligned.__
* The pointer to the source plain text. __Must be 4-byte aligned.__
*
* \param cfContext
* The pointer to the \ref cy_stc_crypto_context_aes_t structure that stores all
* internal variables the Crypto driver requires.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Aes_Cfb_Run(cy_en_crypto_dir_mode_t dirMode,
@ -1102,17 +1143,17 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Cfb_Run(cy_en_crypto_dir_mode_t dirMode,
* __Must be 4-byte aligned.__
*
* \param dst
* The pointer to a destination cipher text. __Must be 4-byte aligned.__
* The pointer to the destination cipher text. __Must be 4-byte aligned.__
*
* \param src
* The pointer to a source plain text. __Must be 4-byte aligned.__
* The pointer to the source plain text. __Must be 4-byte aligned.__
*
* \param cfContext
* The pointer to the \ref cy_stc_crypto_context_aes_t structure that stores all
* internal variables the Crypto driver requires.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Aes_Ctr_Run(cy_en_crypto_dir_mode_t dirMode,
@ -1134,7 +1175,7 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Ctr_Run(cy_en_crypto_dir_mode_t dirMode,
* the context structure when making this function call.
*
* \param src
* The pointer to a source plain text. __Must be 4-byte aligned.__
* The pointer to the source plain text. __Must be 4-byte aligned.__
*
* \param srcSize
* The size of a source plain text.
@ -1153,7 +1194,7 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Ctr_Run(cy_en_crypto_dir_mode_t dirMode,
* internal variables the Crypto driver requires.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoCmacUse
@ -1189,7 +1230,7 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Cmac_Run(uint32_t *src,
* The size of a message.
*
* \param digest
* The pointer to the hash digest. Hash size depends to selected SHA mode
* The pointer to the hash digest. The hash size depends on the selected SHA mode
* (from 20 to 64 bytes, see \ref CY_CRYPTO_SHA_MAX_DIGEST_SIZE).
* __Must be 4-byte aligned.__
*
@ -1198,7 +1239,7 @@ cy_en_crypto_status_t Cy_Crypto_Aes_Cmac_Run(uint32_t *src,
* internal variables for Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoSha256Use
@ -1246,7 +1287,7 @@ cy_en_crypto_status_t Cy_Crypto_Sha_Run(uint32_t *message,
* internal variables for the Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoHmacUse
@ -1288,7 +1329,7 @@ cy_en_crypto_status_t Cy_Crypto_Hmac_Run(uint32_t *hmac,
* internal variables for the Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Str_MemCpy(void *dst,
@ -1320,7 +1361,7 @@ cy_en_crypto_status_t Cy_Crypto_Str_MemCpy(void *dst,
* internal variables for the Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Str_MemSet(void *dst,
@ -1357,7 +1398,7 @@ cy_en_crypto_status_t Cy_Crypto_Str_MemSet(void *dst,
* internal variables for the Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Str_MemCmp(void const *src0,
@ -1395,7 +1436,7 @@ cy_en_crypto_status_t Cy_Crypto_Str_MemCmp(void const *src0,
* internal variables for the Crypto driver.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Str_MemXor(void const *src0,
@ -1508,7 +1549,7 @@ cy_en_crypto_status_t Cy_Crypto_Str_MemXor(void const *src0,
* the Crypto driver context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t
* \ref cy_en_crypto_status_t
*
* \note
* The polynomial, initial seed and remainder XOR values are <b>always</b>
@ -1551,7 +1592,7 @@ cy_en_crypto_status_t Cy_Crypto_Crc_Init(uint32_t polynomial,
* the Crypto driver context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \note
* The polynomial, initial seed and remainder XOR values are <b>always</b>
@ -1594,7 +1635,7 @@ cy_en_crypto_status_t Cy_Crypto_Crc_Run(void *data,
* the Crypto driver context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoTrngUse
@ -1636,7 +1677,7 @@ cy_en_crypto_status_t Cy_Crypto_Trng_Generate(uint32_t GAROPol,
* the Crypto driver context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Des_Run(cy_en_crypto_dir_mode_t dirMode,
@ -1673,7 +1714,7 @@ cy_en_crypto_status_t Cy_Crypto_Des_Run(cy_en_crypto_dir_mode_t dirMode,
* the Crypto driver context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoTdesUse
@ -1735,7 +1776,7 @@ cy_en_crypto_status_t Cy_Crypto_Tdes_Run(cy_en_crypto_dir_mode_t dirMode,
* the RSA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Rsa_Proc(cy_stc_crypto_rsa_pub_key_t const *pubKey,
@ -1774,7 +1815,7 @@ cy_en_crypto_status_t Cy_Crypto_Rsa_Proc(cy_stc_crypto_rsa_pub_key_t const *pubK
* the RSA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Rsa_CalcCoefs(cy_stc_crypto_rsa_pub_key_t const *pubKey,
@ -1818,7 +1859,7 @@ cy_en_crypto_status_t Cy_Crypto_Rsa_CalcCoefs(cy_stc_crypto_rsa_pub_key_t const
* the RSA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Rsa_Verify(cy_en_crypto_rsa_ver_result_t *verResult,

291
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_common.h
View File

@ -60,7 +60,7 @@
#define CY_CRYPTO_DRV_VERSION_MINOR 20
/**
* \addtogroup group_crypto_macros
* \addtogroup group_crypto_cli_srv_macros
* \{
*/
@ -70,7 +70,7 @@
/** Defines Crypto_Sync non-blocking execution type parameter */
#define CY_CRYPTO_SYNC_NON_BLOCKING (false)
/** Defines the Crypto DES block size (in bytes) */
/** Defines the Crypto DES block size (in bytes). */
#define CY_CRYPTO_DES_BLOCK_SIZE (8u)
/** Defines the Crypto DES key size (in bytes) */
@ -114,7 +114,7 @@
#define CY_CRYPTO_SHA512_224_DIGEST_SIZE (28u)
/** Hash size for the SHA512_256 mode (in bytes) */
#define CY_CRYPTO_SHA512_256_DIGEST_SIZE (32u)
/** Maximal hash size for the SHA modes (in bytes) */
/** The maximal Hash size for the SHA modes (in bytes). */
#define CY_CRYPTO_SHA_MAX_DIGEST_SIZE (CY_CRYPTO_SHA512_DIGEST_SIZE)
/** Block size for the SHA1 mode (in bytes) */
@ -141,6 +141,9 @@
#define CY_CRYPTO_SHA512_ROUND_MEM_SIZE (640uL)
#define CY_CRYPTO_SHA_MAX_ROUND_MEM_SIZE (CY_CRYPTO_SHA512_ROUND_MEM_SIZE)
/* The width of the Crypto hardware registers values in bits. */
#define CY_CRYPTO_HW_REGS_WIDTH (32UL)
/** \endcond */
#endif /* #if (CPUSS_CRYPTO_SHA == 1) */
@ -161,11 +164,13 @@
/** Crypto Driver PDL ID */
#define CY_CRYPTO_ID CY_PDL_DRV_ID(0x0Cu)
/** \} group_crypto_macros */
/** \} group_crypto_cli_srv_macros */
/**
* \addtogroup group_crypto_config_structure
* \{
The Crypto initialization configuration.
* \note Should be the same for the Crypto Server and Crypto Client initialization.
*/
/** The Crypto user callback function type.
@ -231,32 +236,37 @@ typedef struct
/** \} group_crypto_config_structure */
/**
* \addtogroup group_crypto_cli_data_structures
* \addtogroup group_crypto_data_structures
* \{
*/
#if (CPUSS_CRYPTO_VU == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the RSA public key and
* additional coefficients to accelerate RSA calculation.
*
* RSA key contained from two fields:
* - n - modulus part of the key
* - e - exponent part of the key.
*
* Other fields are accelerating coefficients and can be calculated by
* \ref Cy_Crypto_Rsa_CalcCoefs.
*
* \note The <b>modulus</b> and <b>exponent</b> values in the
* \ref cy_stc_crypto_rsa_pub_key_t must also be in little-endian order.<br>
* Use \ref Cy_Crypto_Rsa_InvertEndianness function to convert to or from
* little-endian order.
*
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*
* The driver uses this structure to store and manipulate the RSA public key and
* additional coefficients to accelerate RSA calculation.
*
* RSA key contained from two fields:
* - n - modulus part of the key
* - e - exponent part of the key.
*
* Other fields are accelerating coefficients and can be calculated by
* \ref Cy_Crypto_Rsa_CalcCoefs.
*
* \note The <b>modulus</b> and <b>exponent</b> values in the
* \ref cy_stc_crypto_rsa_pub_key_t must also be in little-endian order.<br>
* Use \ref Cy_Crypto_Rsa_InvertEndianness function to convert to or from
* little-endian order.
*/
typedef struct
{
/** \cond INTERNAL */
/** The pointer to the modulus part of public key. */
uint8_t *moduloPtr;
/** The modulus length, in bits, maximum supported size is 2048Bit */
@ -278,10 +288,18 @@ typedef struct
/** The pointer to the (2^moduloLength mod modulo). Memory for it should
be allocated by user with size moduloLength */
uint8_t *rBarPtr;
/** \endcond */
} cy_stc_crypto_rsa_pub_key_t;
#endif /* #if (CPUSS_CRYPTO_VU == 1) */
/** \} group_crypto_data_structures */
/**
* \addtogroup group_crypto_cli_data_structures
* \{
*/
/** Structure for storing a description of a Crypto hardware error */
typedef struct
{
@ -484,17 +502,25 @@ typedef enum
/** \endcond */
/**
* \addtogroup group_crypto_cli_data_structures
* \addtogroup group_crypto_data_structures
* \{
*/
#if (CPUSS_CRYPTO_AES == 1)
/** Structure for storing the AES state */
/** The structure for storing the AES state.
* All fields for this structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** Pointer to AES key */
uint8_t *key;
/** Pointer to AES inversed key */
/** Pointer to AES inverse key */
uint8_t *invKey;
/** AES key length */
cy_en_crypto_aes_key_length_t keyLength;
@ -502,10 +528,39 @@ typedef struct
uint32_t *buffers;
/** AES processed block index (for CMAC, SHA operations) */
uint32_t blockIdx;
/** \endcond */
} cy_stc_crypto_aes_state_t;
#endif /* #if (CPUSS_CRYPTO_AES == 1) */
/** \} group_crypto_cli_data_structures */
#if (CPUSS_CRYPTO_SHA == 1)
/** The structure for storing the SHA state.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
uint32_t mode;
uint8_t *block;
uint32_t blockSize;
uint8_t *hash;
uint32_t hashSize;
uint8_t *roundMem;
uint32_t roundMemSize;
uint32_t messageSize;
uint32_t digestSize;
uint32_t blockIdx;
uint8_t const *initialHash;
/** \endcond */
} cy_stc_crypto_sha_state_t;
#endif /* (CPUSS_CRYPTO_SHA == 1) */
/** \} group_crypto_data_structures */
/*************************************************************
* Structures used for communication between Client and Server
@ -516,14 +571,16 @@ typedef struct
* \{
*/
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the server
* context.
*/
/** The structure for storing the crypto server context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** IPC communication channel number */
uint32_t ipcChannel;
/** IPC acquire interrupt channel number */
@ -540,6 +597,7 @@ typedef struct
bool isHwErrorOccured;
/** Hardware processing errors */
cy_stc_crypto_hw_error_t hwErrorStatus;
/** \endcond */
} cy_stc_crypto_server_context_t;
/** \} group_crypto_srv_data_structures */
@ -549,14 +607,16 @@ typedef struct
* \{
*/
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the global
* context.
*/
/** The structure for storing the crypto client context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** Operation instruction code */
cy_en_crypto_comm_instr_t instr;
/** Response from executed crypto function */
@ -575,18 +635,21 @@ typedef struct
cy_stc_sysint_t releaseNotifierConfig;
/** Pointer to the crypto function specific context data */
void *xdata;
/** \endcond */
} cy_stc_crypto_context_t;
#if (CPUSS_CRYPTO_DES == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the DES operational
* context.
*/
/** The structure for storing the DES context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** Operation direction (Encrypt / Decrypt) */
cy_en_crypto_dir_mode_t dirMode;
/** Pointer to key data */
@ -595,18 +658,21 @@ typedef struct
uint32_t *dst;
/** Pointer to data source block */
uint32_t *src;
/** \endcond */
} cy_stc_crypto_context_des_t;
#endif /* #if (CPUSS_CRYPTO_DES == 1) */
#if (CPUSS_CRYPTO_AES == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the AES operational
* context.
*/
/** The structure for storing the AES context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** AES state data */
cy_stc_crypto_aes_state_t aesState;
/** Operation direction (Encrypt / Decrypt) */
@ -627,38 +693,22 @@ typedef struct
uint32_t *dst;
/** Pointer to data source block */
uint32_t *src;
/** \endcond */
} cy_stc_crypto_context_aes_t;
#endif /* #if (CPUSS_CRYPTO_AES == 1) */
#if (CPUSS_CRYPTO_SHA == 1)
/** \cond INTERNAL */
/* The structure for storing the SHA context */
typedef struct
{
uint32_t mode;
uint8_t *block;
uint32_t blockSize;
uint8_t *hash;
uint32_t hashSize;
uint8_t *roundMem;
uint32_t roundMemSize;
uint32_t messageSize;
uint32_t digestSize;
uint32_t blockIdx;
uint8_t const *initialHash;
} cy_stc_crypto_sha_state_t;
/** \endcond */
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the SHA operational
* context.
*/
/** The structure for storing the SHA context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** Pointer to data source block */
uint32_t *message;
/** Operation data size */
@ -671,35 +721,41 @@ typedef struct
uint32_t *key;
/** Key data length (for HMAC only) */
uint32_t keyLength;
/** \endcond */
} cy_stc_crypto_context_sha_t;
#endif /* #if (CPUSS_CRYPTO_SHA == 1) */
#if (CPUSS_CRYPTO_PR == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the PRNG operational
* context.
*/
/** The structure for storing the PRNG context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
uint32_t lfsr32InitState; /**< lfsr32 initialization data */
uint32_t lfsr31InitState; /**< lfsr31 initialization data */
uint32_t lfsr29InitState; /**< lfsr29 initialization data */
uint32_t max; /**< Maximum of the generated value */
uint32_t *prngNum; /**< Pointer to generated value */
/** \endcond */
} cy_stc_crypto_context_prng_t;
#endif /* #if (CPUSS_CRYPTO_PR == 1) */
#if (CPUSS_CRYPTO_TR == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the TRNG operational
* context.
*/
/** The structure for storing the TRNG context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/**
The polynomial for the programmable Galois ring oscillator (TR_GARO_CTL).
The polynomial is represented WITHOUT the high order bit (this bit is
@ -721,35 +777,41 @@ typedef struct
uint32_t max;
/** Pointer to generated value */
uint32_t *trngNum;
/** \endcond */
} cy_stc_crypto_context_trng_t;
#endif /* #if (CPUSS_CRYPTO_TR == 1) */
#if (CPUSS_CRYPTO_STR == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the STR operational
* context.
*/
/** The structure for storing the string context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
void const *src0; /**< Pointer to 1-st string source */
void const *src1; /**< Pointer to 2-nd string source */
void *dst; /**< Pointer to string destination */
uint32_t dataSize; /**< Operation data size */
uint32_t data; /**< Operation data value (for memory setting) */
/** \endcond */
} cy_stc_crypto_context_str_t;
#endif /* #if (CPUSS_CRYPTO_STR == 1) */
#if (CPUSS_CRYPTO_CRC == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the CRC operational
* context.
*/
/** The structure for storing the CRC context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
void* data; /**< Pointer to data source block */
uint32_t dataSize; /**< Operation data size */
uint32_t *crc; /**< Pointer to CRC destination variable */
@ -759,20 +821,23 @@ typedef struct
uint32_t dataXor; /**< Input data XOR flag */
uint32_t remReverse; /**< Output data reverse flag */
uint32_t remXor; /**< Output data XOR flag */
/** \endcond */
} cy_stc_crypto_context_crc_t;
#endif /* #if (CPUSS_CRYPTO_CRC == 1) */
#if (CPUSS_CRYPTO_VU == 1)
#if (CPUSS_CRYPTO_SHA == 1)
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the RSA verifying
* context.
*/
/** The structure for storing the RSA verification context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in the function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** Pointer to verification result /ref cy_en_crypto_rsa_ver_result_t */
cy_en_crypto_rsa_ver_result_t *verResult;
/** SHA digest type, used with SHA calculation of the message */
@ -783,17 +848,20 @@ typedef struct
uint32_t const *decryptedSignature;
/** Length of the decrypted RSA signature */
uint32_t decryptedSignatureLength;
/** \endcond */
} cy_stc_crypto_context_rsa_ver_t;
#endif /* #if (CPUSS_CRYPTO_SHA == 1) */
/**
* Firmware allocates memory and provides a pointer to this structure in
* function calls. Firmware does not write or read values in this structure.
* The driver uses this structure to store and manipulate the RSA operational
* context.
*/
/** The structure for storing the RSA context.
* All fields for the context structure are internal. Firmware never reads or
* writes these values. Firmware allocates the structure and provides the
* address of the structure to the driver in function calls. Firmware must
* ensure that the defined instance of this structure remains in scope
* while the drive is in use.
*/
typedef struct
{
/** \cond INTERNAL */
/** Pointer to key data */
cy_stc_crypto_rsa_pub_key_t const *key;
/** Pointer to data source block */
@ -802,6 +870,7 @@ typedef struct
uint32_t messageSize;
/** Pointer to data destination block */
uint32_t *result;
/** \endcond */
} cy_stc_crypto_context_rsa_t;
#endif /* #if (CPUSS_CRYPTO_VU == 1) */

41
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core.h
View File

@ -36,10 +36,43 @@
* provides the configuration data required for the desired cryptographic
* technique.
*
* \defgroup group_crypto_llc_macros Macros
* \defgroup group_crypto_llc_functions Functions
* \defgroup group_crypto_llc_data_structures Data Structures
* \defgroup group_crypto_llc_enums Enumerated Types
* \defgroup group_crypto_lld_hw Control and Status
* \{
* \defgroup group_crypto_lld_hw_functions Functions
* \}
* \defgroup group_crypto_lld_symmetric Symmetric Key Algorithms (AES, DES, TDES)
* \{
* \defgroup group_crypto_lld_symmetric_functions Functions
* \}
* \defgroup group_crypto_lld_asymmetric Asymmetric Key Algorithms (RSA, ECP, ECDSA)
* \{
* \defgroup group_crypto_lld_asymmetric_functions Functions
* \defgroup group_crypto_lld_asymmetric_enums Enumerated Types
* \}
* \defgroup group_crypto_lld_sha Hash Operations (SHA)
* \{
* \defgroup group_crypto_lld_sha_functions Functions
* \}
* \defgroup group_crypto_lld_mac Message Authentication Code (CMAC, HMAC)
* \{
* \defgroup group_crypto_lld_mac_functions Functions
* \}
* \defgroup group_crypto_lld_crc Cyclic Redundancy Code (CRC)
* \{
* \defgroup group_crypto_lld_crc_functions Functions
* \}
* \defgroup group_crypto_lld_rng Random Number Generation (TRNG, PRNG)
* \{
* \defgroup group_crypto_lld_rng_functions Functions
* \}
* \defgroup group_crypto_lld_vu Vector Unit (VU)
* \{
* \defgroup group_crypto_lld_vu_functions Functions
* \}
* \defgroup group_crypto_lld_mem Memory Streaming Functions
* \{
* \defgroup group_crypto_lld_mem_functions Functions
* \}
* \} */
#if !defined(CY_CRYPTO_CORE_H)

125
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_aes.h
View File

@ -72,15 +72,19 @@ typedef cy_en_crypto_status_t (*cy_crypto_aes_ctr_func_t)(CRYPTO_Type *base,
uint8_t const *src,
cy_stc_crypto_aes_state_t *aesState);
/**
* \addtogroup group_crypto_lld_symmetric_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Aes_Init
****************************************************************************//**
*
* Sets Aes mode and prepare inversed key.
* Initializes AES mode of operation and prepares an inverse key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param key
* The pointer to the encryption/decryption key.
@ -89,10 +93,11 @@ typedef cy_en_crypto_status_t (*cy_crypto_aes_ctr_func_t)(CRYPTO_Type *base,
* \ref cy_en_crypto_aes_key_length_t
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Init(CRYPTO_Type *base,
@ -100,44 +105,45 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Init(CRYPTO_Type *base,
cy_en_crypto_aes_key_length_t keyLength,
cy_stc_crypto_aes_state_t *aesState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Aes_Init(base, key, keyLength, aesState);
tmpResult = Cy_Crypto_Core_V1_Aes_Init(base, key, keyLength, aesState);
}
else
{
myResult = Cy_Crypto_Core_V2_Aes_Init(base, key, keyLength, aesState);
tmpResult = Cy_Crypto_Core_V2_Aes_Init(base, key, keyLength, aesState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Aes_Ecb
****************************************************************************//**
*
* Performs AES operation on one Block.
* Performs the AES operation on a single block.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
* (\ref cy_en_crypto_dir_mode_t).
*
* \param dst
* The pointer to a destination cipher block.
* The pointer to the destination cipher block.
*
* \param src
* The pointer to a source block.
* The pointer to the source block.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Ecb(CRYPTO_Type *base,
@ -146,28 +152,29 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Ecb(CRYPTO_Type *base,
uint8_t const *src,
cy_stc_crypto_aes_state_t *aesState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Aes_Ecb(base, dirMode, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V1_Aes_Ecb(base, dirMode, dst, src, aesState);
}
else
{
myResult = Cy_Crypto_Core_V2_Aes_Ecb(base, dirMode, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V2_Aes_Ecb(base, dirMode, dst, src, aesState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Aes_Cbc
****************************************************************************//**
*
* Performs AES operation on a plain text with Cipher Block Chaining (CBC).
* Performs the AES-CBC operation defined in the dirMode parameter on a plain text
* defined in the src parameter.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -180,16 +187,17 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Ecb(CRYPTO_Type *base,
* The pointer to the initial vector.
*
* \param dst
* The pointer to a destination cipher text.
* The pointer to the destination cipher text.
*
* \param src
* The pointer to a source plain text.
* The pointer to the source plain text.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Cbc(CRYPTO_Type *base,
@ -200,28 +208,29 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Cbc(CRYPTO_Type *base,
uint8_t const *src,
cy_stc_crypto_aes_state_t *aesState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Aes_Cbc(base, dirMode, srcSize, ivPtr, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V1_Aes_Cbc(base, dirMode, srcSize, ivPtr, dst, src, aesState);
}
else
{
myResult = Cy_Crypto_Core_V2_Aes_Cbc(base, dirMode, srcSize, ivPtr, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V2_Aes_Cbc(base, dirMode, srcSize, ivPtr, dst, src, aesState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Aes_Cfb
********************************************************************************
****************************************************************************//**
*
* Performs AES operation on a plain text with the Cipher Feedback Block method (CFB).
* Performs the AES-CFB operation defined in the dirMode parameter on a plain text
* defined in the SRC parameter.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -234,16 +243,17 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Cbc(CRYPTO_Type *base,
* The pointer to the initial vector.
*
* \param dst
* The pointer to a destination cipher text.
* The pointer to the destination cipher text.
*
* \param src
* The pointer to a source plain text.
* The pointer to the source plain text.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Cfb(CRYPTO_Type *base,
@ -254,31 +264,31 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Cfb(CRYPTO_Type *base,
uint8_t const *src,
cy_stc_crypto_aes_state_t *aesState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Aes_Cfb(base, dirMode, srcSize, ivPtr, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V1_Aes_Cfb(base, dirMode, srcSize, ivPtr, dst, src, aesState);
}
else
{
myResult = Cy_Crypto_Core_V2_Aes_Cfb(base, dirMode, srcSize, ivPtr, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V2_Aes_Cfb(base, dirMode, srcSize, ivPtr, dst, src, aesState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Aes_Ctr
********************************************************************************
****************************************************************************//**
*
* Performs AES operation on a plain text using the counter method (CTR).
* Performs the AES-CTR operation on a plain text defined in the src parameter.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcSize
* The size of a source plain text.
* The size of the source plain text.
*
* \param srcOffset
* The size of an offset within the current block stream for resuming within the
@ -291,16 +301,17 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Cfb(CRYPTO_Type *base,
* The saved stream-block for resuming. Is over-written by the function.
*
* \param dst
* The pointer to a destination cipher text.
* The pointer to the destination cipher text.
*
* \param src
* The pointer to a source plain text. Must be 4-Byte aligned.
* The pointer to the source plain text. Must be 4-Byte aligned.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Ctr(CRYPTO_Type *base,
@ -312,20 +323,22 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Aes_Ctr(CRYPTO_Type *base,
uint8_t const *src,
cy_stc_crypto_aes_state_t *aesState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Aes_Ctr(base, srcSize, srcOffset, ivPtr, streamBlock, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V1_Aes_Ctr(base, srcSize, srcOffset, ivPtr, streamBlock, dst, src, aesState);
}
else
{
myResult = Cy_Crypto_Core_V2_Aes_Ctr(base, srcSize, srcOffset, ivPtr, streamBlock, dst, src, aesState);
tmpResult = Cy_Crypto_Core_V2_Aes_Ctr(base, srcSize, srcOffset, ivPtr, streamBlock, dst, src, aesState);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_symmetric_functions */
#endif /* #if (CPUSS_CRYPTO_AES == 1) */
#endif /* CY_IP_MXCRYPTO */

32
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_cmac.h
View File

@ -47,21 +47,26 @@ typedef cy_en_crypto_status_t (*cy_crypto_cmac_func_t)(CRYPTO_Type *base,
cy_stc_crypto_aes_state_t *aesState);
/** \endcond */
/**
* \addtogroup group_crypto_lld_mac_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Cmac
****************************************************************************//**
*
* Performs CMAC(Cipher-based Message Authentication Code) operation
* on a message to produce message authentication code using AES.
* Calculates the AES Cipher-based Message Authentication Code (CMAC) on the input
* message with the provided key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param message
* The pointer to a source plain text. Must be 4-byte aligned.
* The pointer to the source plain text. Must be 4-byte aligned.
*
* \param messageSize
* The size of a source plain text.
* The size of the source plain text in bytes.
*
* \param key
* The pointer to the encryption key. Must be 4-byte aligned.
@ -73,10 +78,11 @@ typedef cy_en_crypto_status_t (*cy_crypto_cmac_func_t)(CRYPTO_Type *base,
* The pointer to the calculated CMAC.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Cmac(CRYPTO_Type *base,
@ -87,20 +93,22 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Cmac(CRYPTO_Type *base,
uint8_t *cmac,
cy_stc_crypto_aes_state_t *aesState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Cmac(base, message, messageSize, key, keyLength, cmac, aesState);
tmpResult = Cy_Crypto_Core_V1_Cmac(base, message, messageSize, key, keyLength, cmac, aesState);
}
else
{
myResult = Cy_Crypto_Core_V2_Cmac(base, message, messageSize, key, keyLength, cmac, aesState);
tmpResult = Cy_Crypto_Core_V2_Cmac(base, message, messageSize, key, keyLength, cmac, aesState);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_mac_functions */
#endif /* (CPUSS_CRYPTO_AES == 1) */
#endif /* CY_IP_MXCRYPTO */

127
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_crc.h
View File

@ -49,14 +49,19 @@ typedef cy_en_crypto_status_t (*cy_crypto_crc_func_t)(CRYPTO_Type *base,
uint32_t dataSize,
uint32_t lfsrInitState);
/**
* \addtogroup group_crypto_lld_crc_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc_Init
****************************************************************************//**
*
* Initializes CRC calculation.
* Initializes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param polynomial
* The polynomial (specified using 32 bits) used in the computing CRC.
@ -65,16 +70,16 @@ typedef cy_en_crypto_status_t (*cy_crypto_crc_func_t)(CRYPTO_Type *base,
* The order in which data bytes are processed. 0 - MSB first; 1- LSB first.
*
* \param dataXor
* The byte mask for XORing data
* The byte mask for XORing data.
*
* \param remReverse
* A remainder reverse: 0 means the remainder is not reversed. 1 means reversed.
*
* \param remXor
* Specifies a mask with which the LFSR32 register is XORed to produce a remainder.
* Specifies the mask with which the LFSR32 register is XORed to produce a remainder.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_Init(CRYPTO_Type *base,
@ -84,28 +89,28 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_Init(CRYPTO_Type *base,
uint32_t remReverse,
uint32_t remXor)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc_Init(base, polynomial, dataReverse, dataXor, remReverse, remXor);
tmpResult = Cy_Crypto_Core_V1_Crc_Init(base, polynomial, dataReverse, dataXor, remReverse, remXor);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc_Init(base, polynomial, dataReverse, dataXor, remReverse, remXor);
tmpResult = Cy_Crypto_Core_V2_Crc_Init(base, polynomial, dataReverse, dataXor, remReverse, remXor);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc
****************************************************************************//**
*
* Performs CRC calculation on a message.
* Performs the CRC calculation on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param crc
* The pointer to a computed CRC value. Must be 4-byte aligned.
@ -120,7 +125,7 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_Init(CRYPTO_Type *base,
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc(CRYPTO_Type *base,
@ -129,28 +134,28 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc(CRYPTO_Type *base,
uint32_t dataSize,
uint32_t lfsrInitState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc(base, crc, data, dataSize, lfsrInitState);
tmpResult = Cy_Crypto_Core_V1_Crc(base, crc, data, dataSize, lfsrInitState);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc(base, crc, data, dataSize, lfsrInitState);
tmpResult = Cy_Crypto_Core_V2_Crc(base, crc, data, dataSize, lfsrInitState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc_CalcInit
****************************************************************************//**
*
* Initializes CRC calculation.
* Initializes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -159,7 +164,7 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc(CRYPTO_Type *base,
* The polynomial (specified using 32 bits) used in the computing CRC.
*
* \param dataReverse
* The order in which data bytes are processed. 0 - MSB first; 1- LSB first.
* The order in which data bytes are processed. 0 - MSB first; 1 - LSB first.
*
* \param dataXor
* The byte mask for XORing data
@ -168,13 +173,13 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc(CRYPTO_Type *base,
* A remainder reverse: 0 means the remainder is not reversed. 1 means reversed.
*
* \param remXor
* Specifies a mask with which the LFSR32 register is XORed to produce a remainder.
* Specifies the mask with which the LFSR32 register is XORed to produce a remainder.
*
* \param lfsrInitState
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcInit(CRYPTO_Type *base,
@ -186,30 +191,30 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcInit(CRYPTO_Type *b
uint32_t remXor,
uint32_t lfsrInitState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc_CalcInit(base, width, polynomial, dataReverse, dataXor,
tmpResult = Cy_Crypto_Core_V1_Crc_CalcInit(base, width, polynomial, dataReverse, dataXor,
remReverse, remXor, lfsrInitState);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc_CalcInit(base, width, polynomial, dataReverse, dataXor,
tmpResult = Cy_Crypto_Core_V2_Crc_CalcInit(base, width, polynomial, dataReverse, dataXor,
remReverse, remXor, lfsrInitState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc_CalcStart
****************************************************************************//**
*
* Prepares CRC calculation by setting an initial seeds value.
* Prepares the CRC calculation by setting an initial seed value.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -218,34 +223,34 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcInit(CRYPTO_Type *b
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcStart(CRYPTO_Type *base,
uint32_t width, uint32_t lfsrInitState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc_CalcStart(base, width, lfsrInitState);
tmpResult = Cy_Crypto_Core_V1_Crc_CalcStart(base, width, lfsrInitState);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc_CalcStart(base, width, lfsrInitState);
tmpResult = Cy_Crypto_Core_V2_Crc_CalcStart(base, width, lfsrInitState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc_CalcPartial
****************************************************************************//**
*
* Performs CRC calculation of a message part.
* Performs the CRC calculation of a message part.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data
* The pointer to the message whose CRC is being computed.
@ -254,34 +259,34 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcStart(CRYPTO_Type *
* The size of a message in bytes.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcPartial(CRYPTO_Type *base,
void const *data, uint32_t dataSize)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc_CalcPartial(base, data, dataSize);
tmpResult = Cy_Crypto_Core_V1_Crc_CalcPartial(base, data, dataSize);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc_CalcPartial(base, data, dataSize);
tmpResult = Cy_Crypto_Core_V2_Crc_CalcPartial(base, data, dataSize);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc_CalcFinish
****************************************************************************//**
*
* Finalizes CRC calculation.
* Finalizes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -290,33 +295,33 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcPartial(CRYPTO_Type
* The pointer to a computed CRC value. Must be 4-byte aligned.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcFinish(CRYPTO_Type *base, uint32_t width, uint32_t *crc)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc_CalcFinish(base, width, crc);
tmpResult = Cy_Crypto_Core_V1_Crc_CalcFinish(base, width, crc);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc_CalcFinish(base, width, crc);
tmpResult = Cy_Crypto_Core_V2_Crc_CalcFinish(base, width, crc);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Crc_Calc
****************************************************************************//**
*
* Performs CRC calculation on a message.
* Performs the CRC calculation on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -331,27 +336,29 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_CalcFinish(CRYPTO_Type
* The size of a message in bytes.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Crc_Calc(CRYPTO_Type *base,
uint32_t width, uint32_t *crc,
void const *data, uint32_t dataSize)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Crc_Calc(base, width, crc, data, dataSize);
tmpResult = Cy_Crypto_Core_V1_Crc_Calc(base, width, crc, data, dataSize);
}
else
{
myResult = Cy_Crypto_Core_V2_Crc_Calc(base, width, crc, data, dataSize);
tmpResult = Cy_Crypto_Core_V2_Crc_Calc(base, width, crc, data, dataSize);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_crc_functions */
#endif /* #if (CPUSS_CRYPTO_CRC == 1) */
#endif /* CY_IP_MXCRYPTO */

2
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_crc_v1.h
View File

@ -48,7 +48,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc(CRYPTO_Type *base,
uint32_t dataSize,
uint32_t lfsrInitState);
/* New Partial calculation interface */
/* The new partial calculation interface. */
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcInit(CRYPTO_Type *base,
uint32_t width,
uint32_t polynomial,

2
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_crc_v2.h
View File

@ -48,7 +48,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc(CRYPTO_Type *base,
uint32_t dataSize,
uint32_t lfsrInitState);
/* New Partial calculation interface */
/* The new partial calculation interface. */
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcInit(CRYPTO_Type *base,
uint32_t width,
uint32_t polynomial,

51
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_des.h
View File

@ -42,16 +42,21 @@ typedef cy_en_crypto_status_t (*cy_crypto_des_func_t)(CRYPTO_Type *base,
uint8_t *dst,
uint8_t const *src);
/**
* \addtogroup group_crypto_lld_symmetric_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Des
****************************************************************************//**
*
* Performs DES operation on a Single Block. All addresses must be 4-Byte aligned.
* Ciphertext (dstBlock) may overlap with plaintext (srcBlock)
* Performs the DES operation on a single block. All addresses must be 4-byte aligned.
* Ciphertext (dst) may overlap with plaintext (src).
* This function is independent from the previous Crypto state.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -61,13 +66,13 @@ typedef cy_en_crypto_status_t (*cy_crypto_des_func_t)(CRYPTO_Type *base,
* The pointer to the encryption/decryption key.
*
* \param dst
* The pointer to a destination cipher block.
* The pointer to the destination cipher block.
*
* \param src
* The pointer to a source block.
* The pointer to the source block.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Des(CRYPTO_Type *base,
@ -76,30 +81,30 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Des(CRYPTO_Type *base,
uint8_t *dst,
uint8_t const *src)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Des(base, dirMode, key, dst, src);
tmpResult = Cy_Crypto_Core_V1_Des(base, dirMode, key, dst, src);
}
else
{
myResult = Cy_Crypto_Core_V2_Des(base, dirMode, key, dst, src);
tmpResult = Cy_Crypto_Core_V2_Des(base, dirMode, key, dst, src);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Tdes
****************************************************************************//**
*
* Performs TDES operation on a Single Block. All addresses must be 4-Byte aligned.
* Ciphertext (dstBlock) may overlap with plaintext (srcBlock)
* Performs the TDES operation on a single block. All addresses must be 4-byte aligned.
* Ciphertext (dst) may overlap with plaintext (src).
* This function is independent from the previous Crypto state.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -109,13 +114,13 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Des(CRYPTO_Type *base,
* The pointer to the encryption/decryption keys.
*
* \param dst
* The pointer to a destination cipher block.
* The pointer to the destination cipher block.
*
* \param src
* The pointer to a source data block.
* The pointer to the source data block.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Tdes(CRYPTO_Type *base,
@ -124,20 +129,22 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Tdes(CRYPTO_Type *base,
uint8_t *dst,
uint8_t const *src)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Tdes(base, dirMode, key, dst, src);
tmpResult = Cy_Crypto_Core_V1_Tdes(base, dirMode, key, dst, src);
}
else
{
myResult = Cy_Crypto_Core_V2_Tdes(base, dirMode, key, dst, src);
tmpResult = Cy_Crypto_Core_V2_Tdes(base, dirMode, key, dst, src);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_symmetric_functions */
#endif /* #if (CPUSS_CRYPTO_DES == 1) */
#endif /* CY_IP_MXCRYPTO */

47
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_ecc.h
View File

@ -34,6 +34,12 @@
#if (CPUSS_CRYPTO_VU == 1)
/**
* \addtogroup group_crypto_lld_asymmetric_enums
* \{
*/
/** List of supported elliptic curve IDs */
typedef enum {
CY_CRYPTO_ECC_ECP_NONE = 0,
CY_CRYPTO_ECC_ECP_SECP192R1,
@ -45,6 +51,8 @@ typedef enum {
CY_CRYPTO_ECC_ECP_CURVES_CNT
} cy_en_crypto_ecc_curve_id_t;
/** \} group_crypto_lld_asymmetric_enums */
typedef enum cy_en_red_mul_algs {
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG = 0,
CY_CRYPTO_NIST_P_SHIFT_MUL_RED_ALG,
@ -60,7 +68,7 @@ typedef struct {
uint32_t size;
/** name of curve */
const char *name;
const char_t *name;
/** ECC calculation default algorithm */
cy_en_crypto_ecc_red_mul_algs_t algo;
@ -118,7 +126,14 @@ typedef struct {
} cy_stc_crypto_ecc_key;
typedef int (*cy_func_get_random_data_t)(void *, unsigned char *, size_t);
/**
* \addtogroup group_crypto_lld_asymmetric_functions
* \{
*/
/** Pointer to a random number supplier function */
typedef int (*cy_func_get_random_data_t)(void *rndInfo, uint8_t *rndData, size_t rndSize);
cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakeKeyPair(CRYPTO_Type *base,
cy_en_crypto_ecc_curve_id_t curveID,
cy_stc_crypto_ecc_key *key,
@ -127,22 +142,24 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base,
const uint8_t *hash,
uint32_t hashlen,
uint8_t *sig,
cy_stc_crypto_ecc_key *key,
uint8_t *messageKey);
const cy_stc_crypto_ecc_key *key,
const uint8_t *messageKey);
cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
const uint8_t *sig,
const uint8_t *hash,
uint32_t hashlen,
uint8_t *status,
cy_stc_crypto_ecc_key *key);
const uint8_t *sig,
const uint8_t *hash,
uint32_t hashlen,
uint8_t *stat,
const cy_stc_crypto_ecc_key *key);
cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakePrivateKey(CRYPTO_Type *base,
cy_en_crypto_ecc_curve_id_t curveID, uint8_t *key,
cy_func_get_random_data_t GetRandomDataFunc, void *randomDataInfo);
cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakePublicKey(CRYPTO_Type *base,
cy_en_crypto_ecc_curve_id_t curveID,
uint8_t *privateKey,
const uint8_t *privateKey,
cy_stc_crypto_ecc_key *publicKey);
/** \} group_crypto_lld_asymmetric_functions */
/** Calculates the actual size in bytes of the bits value */
#define CY_CRYPTO_BYTE_SIZE_OF_BITS(x) (uint32_t)(((x) + 7u) >> 3u)
@ -166,11 +183,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakePublicKey(CRYPTO_Type *base,
#define CY_CRYPTO_ECC_MAX_BYTE_SIZE (CY_CRYPTO_ECC_P521_BYTE_SIZE)
/* "Global" vector unit registers. */
#define VR_D 10
#define VR_S_X 11
#define VR_S_Y 12
#define VR_BARRETT 13
#define VR_P 14 /* polynomial */
#define VR_D 10u
#define VR_S_X 11u
#define VR_S_Y 12u
#define VR_BARRETT 13u
#define VR_P 14u /* polynomial */
#endif /* #if (CPUSS_CRYPTO_VU == 1) */

59
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_ecc_nist_p.h
View File

@ -33,38 +33,39 @@
#if (CPUSS_CRYPTO_VU == 1)
void Cy_Crypto_Core_EC_NistP_SetMode(int bitsize);
void Cy_Crypto_Core_EC_NistP_SetMode(uint32_t bitsize);
void Cy_Crypto_Core_EC_NistP_SetRedAlg(cy_en_crypto_ecc_red_mul_algs_t alg);
void Cy_Crypto_Core_EC_NistP_PointMul(CRYPTO_Type *base, int p_x, int p_y, int p_d, int p_order, int bitsize);
/**
* \addtogroup group_crypto_lld_asymmetric_functions
* \{
*/
cy_en_crypto_status_t Cy_Crypto_Core_EC_NistP_PointMultiplication(CRYPTO_Type *base,
cy_en_crypto_ecc_curve_id_t curveID,
uint8_t* ecpGX,
uint8_t* ecpGY,
uint8_t* ecpD,
uint8_t* ecpQX,
uint8_t* ecpQY);
void Cy_Crypto_Core_EC_MulMod( CRYPTO_Type *base,
int z,
int a,
int b,
int size);
void Cy_Crypto_Core_EC_DivMod( CRYPTO_Type *base,
int z,
int a,
int b,
int size);
void Cy_Crypto_Core_EC_SquareMod( CRYPTO_Type *base,
int z,
int a,
int size);
void Cy_Crypto_Core_EC_Bar_MulRed(CRYPTO_Type *base,
int z,
int x,
int size
);
void Cy_Crypto_Core_EC_AddMod( CRYPTO_Type *base, int z, int a, int b);
void Cy_Crypto_Core_EC_SubMod( CRYPTO_Type *base, int z, int a, int b);
void Cy_Crypto_Core_EC_HalfMod( CRYPTO_Type *base, int z, int a);
const uint8_t *ecpGX,
const uint8_t *ecpGY,
const uint8_t *ecpD,
uint8_t *ecpQX,
uint8_t *ecpQY);
/** \} group_crypto_lld_asymmetric_functions */
void Cy_Crypto_Core_EC_MulMod( CRYPTO_Type *base, uint32_t z, uint32_t a, uint32_t b, uint32_t size);
void Cy_Crypto_Core_EC_DivMod( CRYPTO_Type *base, uint32_t z, uint32_t a, uint32_t b, uint32_t size);
void Cy_Crypto_Core_EC_SquareMod( CRYPTO_Type *base, uint32_t z, uint32_t a, uint32_t size);
void Cy_Crypto_Core_EC_Bar_MulRed(CRYPTO_Type *base, uint32_t z, uint32_t x, uint32_t size);
void Cy_Crypto_Core_EC_AddMod( CRYPTO_Type *base, uint32_t z, uint32_t a, uint32_t b);
void Cy_Crypto_Core_EC_SubMod( CRYPTO_Type *base, uint32_t z, uint32_t a, uint32_t b);
void Cy_Crypto_Core_EC_HalfMod( CRYPTO_Type *base, uint32_t z, uint32_t a);
void Cy_Crypto_Core_JacobianEcAdd(CRYPTO_Type *base, uint32_t s_x, uint32_t s_y, uint32_t s_z, uint32_t t_x, uint32_t t_y, uint32_t size);
void Cy_Crypto_Core_JacobianEcDouble(CRYPTO_Type *base, uint32_t s_x, uint32_t s_y, uint32_t s_z, uint32_t size);
void Cy_Crypto_Core_JacobianEcScalarMul(CRYPTO_Type *base, uint32_t s_x, uint32_t s_y, uint32_t d, uint32_t size);
void Cy_Crypto_Core_JacobianTransform(CRYPTO_Type *base, uint32_t s_x, uint32_t s_y, uint32_t s_z);
void Cy_Crypto_Core_JacobianInvTransform(CRYPTO_Type *base, uint32_t s_x, uint32_t s_y, uint32_t s_z, uint32_t size);
void Cy_Crypto_Core_EC_NistP_PointMul(CRYPTO_Type *base, uint32_t p_x, uint32_t p_y, uint32_t p_d, uint32_t p_order, uint32_t bitsize);
#endif /* #if (CPUSS_CRYPTO_VU == 1) */

27
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_hmac.h
View File

@ -44,23 +44,28 @@ typedef cy_en_crypto_status_t (*cy_crypto_hmac_func_t)(CRYPTO_Type *base,
uint32_t keyLength,
cy_en_crypto_sha_mode_t mode);
/**
* \addtogroup group_crypto_lld_mac_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Hmac
****************************************************************************//**
*
* Performs HMAC calculation.
* Performs the HMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmac
* The pointer to the calculated HMAC. Must be 4-byte aligned.
*
* \param message
* The pointer to a message whose hash value is being computed.
* The pointer to the message whose hash value is being computed.
*
* \param messageSize
* The size of a message.
* The size of the message.
*
* \param key
* The pointer to the key.
@ -72,7 +77,7 @@ typedef cy_en_crypto_status_t (*cy_crypto_hmac_func_t)(CRYPTO_Type *base,
* \ref cy_en_crypto_sha_mode_t
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Hmac(CRYPTO_Type *base,
@ -83,20 +88,22 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Hmac(CRYPTO_Type *base,
uint32_t keyLength,
cy_en_crypto_sha_mode_t mode)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Hmac(base, hmac, message, messageSize, key, keyLength, mode);
tmpResult = Cy_Crypto_Core_V1_Hmac(base, hmac, message, messageSize, key, keyLength, mode);
}
else
{
myResult = Cy_Crypto_Core_V2_Hmac(base, hmac, message, messageSize, key, keyLength, mode);
tmpResult = Cy_Crypto_Core_V2_Hmac(base, hmac, message, messageSize, key, keyLength, mode);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_mac_functions */
#endif /* #if (CPUSS_CRYPTO_SHA == 1) */
#endif /* CY_IP_MXCRYPTO */

34
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_hw.h
View File

@ -108,9 +108,9 @@
#define REG_CRYPTO_DEV_KEY_CTL0(base) (((CRYPTO_V2_Type*)(base))->DEV_KEY_CTL0)
#define REG_CRYPTO_DEV_KEY_CTL1(base) (((CRYPTO_V2_Type*)(base))->DEV_KEY_CTL1)
/* CRYPTO internal memory buffer size IN BYTES */
/* The CRYPTO internal-memory buffer-size in bytes. */
#define CY_CRYPTO_MEM_BUFF_SIZE ((cy_device->cryptoMemSize) * 4u)
/* CRYPTO internal memory buffer size IN 32 bit WORDS */
/* The CRYPTO internal-memory buffer-size in 32-bit words. */
#define CY_CRYPTO_MEM_BUFF_SIZE_U32 (cy_device->cryptoMemSize)
/* Device Crypto IP descriptor type */
@ -220,6 +220,11 @@ typedef enum
/** \endcond */
/**
* \addtogroup group_crypto_lld_hw_functions
* \{
*/
void Cy_Crypto_Core_HwInit(void);
cy_en_crypto_status_t Cy_Crypto_Core_Enable(CRYPTO_Type *base);
@ -239,10 +244,10 @@ void Cy_Crypto_Core_InvertEndianness(void *inArrPtr, uint32_t byteSize);
* The function checks whether the Crypto hardware is enabled.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \return
* Crypto status \ref cy_en_crypto_status_t.
* Crypto status \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE bool Cy_Crypto_Core_IsEnabled(CRYPTO_Type *base)
@ -265,7 +270,7 @@ __STATIC_INLINE bool Cy_Crypto_Core_IsEnabled(CRYPTO_Type *base)
* - from 0 to 16 for MXCRYPTO_ver2 IP block
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
__STATIC_INLINE uint8_t Cy_Crypto_Core_GetFIFODepth(CRYPTO_Type *base)
@ -281,7 +286,7 @@ __STATIC_INLINE uint8_t Cy_Crypto_Core_GetFIFODepth(CRYPTO_Type *base)
* The value of this field ranges from 0 to 8
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
__STATIC_INLINE uint8_t Cy_Crypto_Core_GetFIFOUsed(CRYPTO_Type *base)
@ -299,7 +304,7 @@ __STATIC_INLINE uint8_t Cy_Crypto_Core_GetFIFOUsed(CRYPTO_Type *base)
* By default EVENT_LEVEL = 0;
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
__STATIC_INLINE void Cy_Crypto_Core_WaitForFifoAvailable(CRYPTO_Type *base)
@ -316,7 +321,7 @@ __STATIC_INLINE void Cy_Crypto_Core_WaitForFifoAvailable(CRYPTO_Type *base)
* Waits until all instruction in FIFO will be completed
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
__STATIC_INLINE void Cy_Crypto_Core_WaitForReady(CRYPTO_Type *base)
@ -333,7 +338,7 @@ __STATIC_INLINE void Cy_Crypto_Core_WaitForReady(CRYPTO_Type *base)
* Masks / unmasks multiple interrupt sources.
*
* \param base
* Pointer to Crypto instance address
* The pointer to the CRYPTO instance.
*
* \param interrupts
* Mask bits. See definitions above.
@ -351,7 +356,7 @@ __STATIC_INLINE void Cy_Crypto_Core_SetInterruptMask(CRYPTO_Type *base, uint32_t
* Reports mask / unmask multiple interrupt sources.
*
* \param base
* Pointer to Crypto instance address
* The pointer to the CRYPTO instance.
*
* \return
* Mask bits. See definitions above.
@ -369,7 +374,7 @@ __STATIC_INLINE uint32_t Cy_Crypto_Core_GetInterruptMask(CRYPTO_Type const *base
* Reports states of multiple enabled interrupt sources.
*
* \param base
* Pointer to Crypto instance address
* The pointer to the CRYPTO instance.
*
* \return
* Source bits. See definitions above.
@ -387,7 +392,7 @@ __STATIC_INLINE uint32_t Cy_Crypto_Core_GetInterruptStatusMasked(CRYPTO_Type con
* Reports states of multiple interrupt sources.
*
* \param base
* Pointer to Crypto instance address
* The pointer to the CRYPTO instance.
*
* \return
* Source bits. See definitions above.
@ -405,7 +410,7 @@ __STATIC_INLINE uint32_t Cy_Crypto_Core_GetInterruptStatus(CRYPTO_Type *base)
* Sets one of more interrupt sources
*
* \param base
* Pointer to Crypto instance address
* The pointer to the CRYPTO instance.
*
* \param interrupts
* Source bit(s)
@ -423,7 +428,7 @@ __STATIC_INLINE void Cy_Crypto_Core_SetInterrupt(CRYPTO_Type *base, uint32_t in
* Clears multiple interrupt sources.
*
* \param base
* Pointer to Crypto instance address
* The pointer to the CRYPTO instance.
*
* \param interrupts
* Source bit(s). See definitions above.
@ -435,6 +440,7 @@ __STATIC_INLINE void Cy_Crypto_Core_ClearInterrupt(CRYPTO_Type *base, uint32_t
(void) REG_CRYPTO_INTR(base);
}
/** \} group_crypto_lld_hw_functions */
#endif /* CY_IP_MXCRYPTO */

38
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_hw_v2.h
View File

@ -151,8 +151,8 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_FFStart(CRYPTO_Type *base,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (CY_CRYPTO_V2_FF_START_OPC << CY_CRYPTO_OPCODE_POS)
| (ff_idx << CY_CRYPTO_RSRC0_SHIFT);
REG_CRYPTO_INSTR_FF_WR(base) = ((uint32_t)CY_CRYPTO_V2_FF_START_OPC << CY_CRYPTO_OPCODE_POS) |
(ff_idx << CY_CRYPTO_RSRC0_SHIFT);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t) p_mem;
REG_CRYPTO_INSTR_FF_WR(base) = size;
}
@ -168,8 +168,8 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_FFContinue(CRYPTO_Type *base,
/* Wait for previous loading has been completed. */
(CY_CRYPTO_V2_RB_FF_LOAD0 == ff_idx) ? Cy_Crypto_Core_V2_FFLoad0Sync(base) : Cy_Crypto_Core_V2_FFLoad1Sync(base);
REG_CRYPTO_INSTR_FF_WR(base) = (CY_CRYPTO_V2_FF_CONTINUE_OPC << CY_CRYPTO_OPCODE_POS)
| (ff_idx << CY_CRYPTO_RSRC0_SHIFT);
REG_CRYPTO_INSTR_FF_WR(base) = ((uint32_t)CY_CRYPTO_V2_FF_CONTINUE_OPC << CY_CRYPTO_OPCODE_POS) |
(ff_idx << CY_CRYPTO_RSRC0_SHIFT);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t) p_mem;
REG_CRYPTO_INSTR_FF_WR(base) = size;
}
@ -181,7 +181,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_FFStop(CRYPTO_Type *base, uint32_t ff_idx
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_FF_STOP_OPC << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_FF_STOP_OPC << CY_CRYPTO_OPCODE_POS) |
(ff_idx << CY_CRYPTO_RSRC0_SHIFT));
}
@ -193,7 +193,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_BlockMov(CRYPTO_Type *base,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_BLOCK_MOV_OPC << CY_CRYPTO_OPCODE_POS)
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_BLOCK_MOV_OPC << CY_CRYPTO_OPCODE_POS)
| (size << CY_CRYPTO_RSRC16_SHIFT)
| (dst_idx << CY_CRYPTO_RSRC12_SHIFT)
| (src_idx << CY_CRYPTO_RSRC0_SHIFT));
@ -207,8 +207,8 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_BlockMov_Reflect(CRYPTO_Type *base,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_BLOCK_MOV_OPC << CY_CRYPTO_OPCODE_POS)
| (1u << CY_CRYPTO_RSRC23_SHIFT)
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_BLOCK_MOV_OPC << CY_CRYPTO_OPCODE_POS)
| (1UL << CY_CRYPTO_RSRC23_SHIFT)
| (size << CY_CRYPTO_RSRC16_SHIFT)
| (dst_idx << CY_CRYPTO_RSRC12_SHIFT)
| (src_idx << CY_CRYPTO_RSRC0_SHIFT));
@ -222,7 +222,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_BlockSet(CRYPTO_Type *base,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_BLOCK_SET_OPC << CY_CRYPTO_OPCODE_POS)
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_BLOCK_SET_OPC << CY_CRYPTO_OPCODE_POS)
| (size << CY_CRYPTO_RSRC16_SHIFT)
| (dst_idx << CY_CRYPTO_RSRC12_SHIFT)
| ((uint32_t)(data) << CY_CRYPTO_RSRC0_SHIFT));
@ -236,7 +236,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_BlockCmp(CRYPTO_Type *base,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_BLOCK_CMP_OPC << CY_CRYPTO_OPCODE_POS)
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_BLOCK_CMP_OPC << CY_CRYPTO_OPCODE_POS)
| (size << CY_CRYPTO_RSRC16_SHIFT)
| (src1_idx << CY_CRYPTO_RSRC4_SHIFT)
| (src0_idx << CY_CRYPTO_RSRC0_SHIFT));
@ -250,7 +250,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_BlockXor(CRYPTO_Type *base,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_BLOCK_XOR_OPC << CY_CRYPTO_OPCODE_POS)
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_BLOCK_XOR_OPC << CY_CRYPTO_OPCODE_POS)
| (size << CY_CRYPTO_RSRC16_SHIFT)
| (dst_idx << CY_CRYPTO_RSRC12_SHIFT)
| (src1_idx << CY_CRYPTO_RSRC4_SHIFT)
@ -264,7 +264,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_BlockGcm(CRYPTO_Type *base)
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(CY_CRYPTO_V2_BLOCK_GCM_OPC << CY_CRYPTO_OPCODE_POS);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((uint32_t)CY_CRYPTO_V2_BLOCK_GCM_OPC << CY_CRYPTO_OPCODE_POS);
}
__STATIC_INLINE void Cy_Crypto_Core_V2_Run(CRYPTO_Type *base, uint32_t opc)
@ -284,7 +284,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RBClear(CRYPTO_Type *base)
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(CY_CRYPTO_V2_RB_CLEAR_OPC << CY_CRYPTO_OPCODE_POS);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((uint32_t)CY_CRYPTO_V2_RB_CLEAR_OPC << CY_CRYPTO_OPCODE_POS);
}
__STATIC_INLINE void Cy_Crypto_Core_V2_RBSwap(CRYPTO_Type *base)
@ -294,7 +294,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RBSwap(CRYPTO_Type *base)
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(CY_CRYPTO_V2_RB_SWAP_OPC << CY_CRYPTO_OPCODE_POS);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((uint32_t)CY_CRYPTO_V2_RB_SWAP_OPC << CY_CRYPTO_OPCODE_POS);
}
__STATIC_INLINE void Cy_Crypto_Core_V2_RBXor(CRYPTO_Type *base, uint32_t offset, uint32_t size)
@ -304,7 +304,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RBXor(CRYPTO_Type *base, uint32_t offset,
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_RB_XOR_OPC << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_RB_XOR_OPC << CY_CRYPTO_OPCODE_POS) |
(offset << CY_CRYPTO_RSRC8_SHIFT) |
(size << CY_CRYPTO_RSRC0_SHIFT));
}
@ -316,7 +316,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RBStore(CRYPTO_Type *base, uint32_t offse
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_RB_STORE_OPC << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_RB_STORE_OPC << CY_CRYPTO_OPCODE_POS) |
(offset << CY_CRYPTO_RSRC8_SHIFT) |
(size << CY_CRYPTO_RSRC0_SHIFT));}
@ -327,7 +327,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RBSetByte(CRYPTO_Type *base, uint32_t off
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((CY_CRYPTO_V2_RB_BYTE_SET_OPC << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(((uint32_t)CY_CRYPTO_V2_RB_BYTE_SET_OPC << CY_CRYPTO_OPCODE_POS) |
(offset << CY_CRYPTO_RSRC8_SHIFT) |
((uint32_t)(byte) << CY_CRYPTO_RSRC0_SHIFT));
}
@ -339,7 +339,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RunAes(CRYPTO_Type *base)
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(CY_CRYPTO_V2_AES_OPC << CY_CRYPTO_OPCODE_POS);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((uint32_t)CY_CRYPTO_V2_AES_OPC << CY_CRYPTO_OPCODE_POS);
}
__STATIC_INLINE void Cy_Crypto_Core_V2_RunAesInv(CRYPTO_Type *base)
@ -349,7 +349,7 @@ __STATIC_INLINE void Cy_Crypto_Core_V2_RunAesInv(CRYPTO_Type *base)
{
}
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)(CY_CRYPTO_V2_AES_INV_OPC << CY_CRYPTO_OPCODE_POS);
REG_CRYPTO_INSTR_FF_WR(base) = (uint32_t)((uint32_t)CY_CRYPTO_V2_AES_INV_OPC << CY_CRYPTO_OPCODE_POS);
}
__STATIC_INLINE void Cy_Crypto_Core_V2_RunChacha(CRYPTO_Type *base, uint8_t roundNum)

172
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_hw_vu.h
View File

@ -191,8 +191,8 @@
#define CY_CRYPTO_VU2_INV_BIT_IMM_OPC (0x2Eu)
__STATIC_INLINE void CY_CRYPTO_VU_SAVE_REG (CRYPTO_Type *base, uint32_t rsrc, uint32_t *ddata);
__STATIC_INLINE void CY_CRYPTO_VU_RESTORE_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t ddata);
__STATIC_INLINE void CY_CRYPTO_VU_SAVE_REG (CRYPTO_Type *base, uint32_t rsrc, uint32_t *data);
__STATIC_INLINE void CY_CRYPTO_VU_RESTORE_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t data);
__STATIC_INLINE void CY_CRYPTO_VU_SET_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t data, uint32_t size);
@ -200,7 +200,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_MOV_REG_TO_STATUS (CRYPTO_Type *base, uin
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_MOV_REG_TO_STATUS_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
(uint32_t)rsrc);
((uint32_t)rsrc));
}
__STATIC_INLINE void CY_CRYPTO_VU_MOV_REG_TO_STATUS (CRYPTO_Type *base, uint32_t rsrc)
@ -222,18 +222,19 @@ __STATIC_INLINE void CY_CRYPTO_VU_MOV_STATUS_TO_REG (CRYPTO_Type *base, uint32_t
__STATIC_INLINE void CY_CRYPTO_VU_COND_MOV_IMM_TO_STATUS (CRYPTO_Type *base, uint32_t cc, uint32_t imm4)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******* V1 *********/
int tmp_reg = CY_CRYPTO_VU_HW_REG14;
uint32_t tmp_data;
uint32_t tmpReg = CY_CRYPTO_VU_HW_REG14;
uint32_t tmpData;
CY_CRYPTO_VU_SAVE_REG(base, tmp_reg, &tmp_data);
CY_CRYPTO_VU_SAVE_REG(base, tmpReg, &tmpData);
CY_CRYPTO_VU_SET_REG(base, tmp_reg, imm4, 4);
CY_CRYPTO_VU_COND_MOV_REG_TO_STATUS(base, cc, tmp_reg);
/* Load 4 bit immediate value */
CY_CRYPTO_VU_SET_REG(base, tmpReg, imm4, 4u);
CY_CRYPTO_VU_COND_MOV_REG_TO_STATUS(base, cc, tmpReg);
CY_CRYPTO_VU_RESTORE_REG(base, tmp_reg, tmp_data);
CY_CRYPTO_VU_RESTORE_REG(base, tmpReg, tmpData);
}
else
{
@ -255,8 +256,8 @@ __STATIC_INLINE void CY_CRYPTO_VU_SET_REG (CRYPTO_Type *base, uint32_t rdst, uin
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_SET_REG_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)rdst << CY_CRYPTO_RSRC26_SHIFT) |
((uint32_t)data << ((cy_device->cryptoVersion == 1) ? CY_CRYPTO_RSRC12_SHIFT : CY_CRYPTO_RSRC13_SHIFT)) |
(((uint32_t)size - 1) << CY_CRYPTO_RSRC0_SHIFT));
((uint32_t)data << ((CY_CRYPTO_HW_V1) ? CY_CRYPTO_RSRC12_SHIFT : CY_CRYPTO_RSRC13_SHIFT)) |
(((uint32_t)size - 1u) << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_COND_LD_REG (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc)
@ -317,7 +318,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_ADD_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_ADD_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -331,7 +332,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_SUB_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_SUB_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -345,7 +346,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_OR_REG (CRYPTO_Type *base, uint32_t cc, u
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_OR_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -359,7 +360,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_AND_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_AND_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -373,7 +374,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_XOR_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_XOR_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -387,7 +388,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_NOR_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_NOR_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -401,7 +402,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_NAND_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_NAND_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -415,7 +416,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_MIN_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_MIN_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -429,7 +430,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_MAX_REG (CRYPTO_Type *base, uint32_t cc,
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_MAX_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -464,8 +465,8 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_ALLOC_MEM (CRYPTO_Type *base, uint32_t cc
REG_CRYPTO_INSTR_FF_WR(base) =
(((uint32_t)CY_CRYPTO_VU_ALLOC_MEM_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << ((cy_device->cryptoVersion == 1) ? CY_CRYPTO_RSRC12_SHIFT : CY_CRYPTO_RSRC16_SHIFT)) |
(((uint32_t)size - 1) << CY_CRYPTO_RSRC0_SHIFT));
((uint32_t)rdst << ((CY_CRYPTO_HW_V1) ? CY_CRYPTO_RSRC12_SHIFT : CY_CRYPTO_RSRC16_SHIFT)) |
(((uint32_t)size - 1u) << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_ALLOC_MEM (CRYPTO_Type *base, uint32_t rdst, uint32_t size)
@ -477,7 +478,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_FREE_MEM (CRYPTO_Type *base, uint32_t cc,
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_FREE_MEM_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
(uint32_t)reg_mask);
((uint32_t)reg_mask));
}
__STATIC_INLINE void CY_CRYPTO_VU_FREE_MEM (CRYPTO_Type *base, uint32_t reg_mask)
@ -491,7 +492,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_LSL (CRYPTO_Type *base, uint32_t cc, uint
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_LSL (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -501,7 +502,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_LSL (CRYPTO_Type *base, uint32_t rdst, uint32_
__STATIC_INLINE void CY_CRYPTO_VU_COND_LSL1 (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******* V1 *********/
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_LSL1_OPC << CY_CRYPTO_OPCODE_POS) |
@ -527,7 +528,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_LSL1 (CRYPTO_Type *base, uint32_t rdst, uint32
__STATIC_INLINE void CY_CRYPTO_VU_COND_LSL1_WITH_CARRY (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******* V1 *********/
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_LSL1_WITH_CARRY_OPC << CY_CRYPTO_OPCODE_POS) |
@ -553,11 +554,11 @@ __STATIC_INLINE void CY_CRYPTO_VU_LSL1_WITH_CARRY (CRYPTO_Type *base, uint32_t r
__STATIC_INLINE void CY_CRYPTO_VU_COND_LSR (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_LSR_OPC : CY_CRYPTO_VU2_LSR_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_LSR_OPC : CY_CRYPTO_VU2_LSR_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_LSR (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -567,7 +568,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_LSR (CRYPTO_Type *base, uint32_t rdst, uint32_
__STATIC_INLINE void CY_CRYPTO_VU_COND_LSR1 (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******* V1 *********/
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)(CY_CRYPTO_VU1_LSR1_OPC) << CY_CRYPTO_OPCODE_POS) |
@ -593,7 +594,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_LSR1 (CRYPTO_Type *base, uint32_t rdst, uint32
__STATIC_INLINE void CY_CRYPTO_VU_COND_LSR1_WITH_CARRY (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******* V1 *********/
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)(CY_CRYPTO_VU1_LSR1_WITH_CARRY_OPC) << CY_CRYPTO_OPCODE_POS) |
@ -619,11 +620,11 @@ __STATIC_INLINE void CY_CRYPTO_VU_LSR1_WITH_CARRY (CRYPTO_Type *base, uint32_t r
__STATIC_INLINE void CY_CRYPTO_VU_COND_CLSAME (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_CLSAME_OPC : CY_CRYPTO_VU2_CLSAME_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_CLSAME_OPC : CY_CRYPTO_VU2_CLSAME_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_CLSAME (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -633,11 +634,11 @@ __STATIC_INLINE void CY_CRYPTO_VU_CLSAME (CRYPTO_Type *base, uint32_t rdst, uint
__STATIC_INLINE void CY_CRYPTO_VU_COND_CTSAME (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_CTSAME_OPC : CY_CRYPTO_VU2_CTSAME_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_CTSAME_OPC : CY_CRYPTO_VU2_CTSAME_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_CTSAME (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -647,10 +648,10 @@ __STATIC_INLINE void CY_CRYPTO_VU_CTSAME (CRYPTO_Type *base, uint32_t rdst, uint
__STATIC_INLINE void CY_CRYPTO_VU_COND_SET_BIT (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_SET_BIT_OPC : CY_CRYPTO_VU2_SET_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_SET_BIT_OPC : CY_CRYPTO_VU2_SET_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_SET_BIT (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc)
@ -660,10 +661,10 @@ __STATIC_INLINE void CY_CRYPTO_VU_SET_BIT (CRYPTO_Type *base, uint32_t rdst, uin
__STATIC_INLINE void CY_CRYPTO_VU_COND_CLR_BIT (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_CLR_BIT_OPC : CY_CRYPTO_VU2_CLR_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_CLR_BIT_OPC : CY_CRYPTO_VU2_CLR_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_CLR_BIT (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc)
@ -673,10 +674,10 @@ __STATIC_INLINE void CY_CRYPTO_VU_CLR_BIT (CRYPTO_Type *base, uint32_t rdst, uin
__STATIC_INLINE void CY_CRYPTO_VU_COND_INV_BIT (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_INV_BIT_OPC : CY_CRYPTO_VU2_INV_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_INV_BIT_OPC : CY_CRYPTO_VU2_INV_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_INV_BIT (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc)
@ -686,11 +687,11 @@ __STATIC_INLINE void CY_CRYPTO_VU_INV_BIT (CRYPTO_Type *base, uint32_t rdst, uin
__STATIC_INLINE void CY_CRYPTO_VU_COND_GET_BIT (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((cy_device->cryptoVersion == 1) ? CY_CRYPTO_VU1_GET_BIT_OPC : CY_CRYPTO_VU2_GET_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)((CY_CRYPTO_HW_V1) ? CY_CRYPTO_VU1_GET_BIT_OPC : CY_CRYPTO_VU2_GET_BIT_OPC) << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_GET_BIT (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -701,17 +702,18 @@ __STATIC_INLINE void CY_CRYPTO_VU_GET_BIT (CRYPTO_Type *base, uint32_t rdst, uin
/******************************************************************************/
__STATIC_INLINE void CY_CRYPTO_VU_COND_SET_BIT_IMM (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t imm13)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******** V1 ********/
int tmp_reg = (rdst != CY_CRYPTO_VU_HW_REG14) ? CY_CRYPTO_VU_HW_REG14 : CY_CRYPTO_VU_HW_REG13;
uint32_t tmp_data;
CY_CRYPTO_VU_SAVE_REG(base, tmp_reg, &tmp_data);
uint32_t tmpReg = (rdst != CY_CRYPTO_VU_HW_REG14) ? CY_CRYPTO_VU_HW_REG14 : CY_CRYPTO_VU_HW_REG13;
uint32_t tmpData;
CY_CRYPTO_VU_SAVE_REG(base, tmpReg, &tmpData);
CY_CRYPTO_VU_SET_REG(base, tmp_reg, imm13, 13);
CY_CRYPTO_VU_COND_SET_BIT(base, cc, rdst, tmp_reg);
/* Load 13 bit immediate value */
CY_CRYPTO_VU_SET_REG(base, tmpReg, imm13, 13u);
CY_CRYPTO_VU_COND_SET_BIT(base, cc, rdst, tmpReg);
CY_CRYPTO_VU_RESTORE_REG(base, tmp_reg, tmp_data);
CY_CRYPTO_VU_RESTORE_REG(base, tmpReg, tmpData);
}
else
{
@ -719,7 +721,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_SET_BIT_IMM (CRYPTO_Type *base, uint32_t
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU2_SET_BIT_IMM_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC16_SHIFT) |
(uint32_t)imm13 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)imm13 << CY_CRYPTO_RSRC0_SHIFT));
}
}
@ -730,17 +732,18 @@ __STATIC_INLINE void CY_CRYPTO_VU_SET_BIT_IMM (CRYPTO_Type *base, uint32_t rdst,
__STATIC_INLINE void CY_CRYPTO_VU_COND_CLR_BIT_IMM (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t imm13)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******** V1 ********/
int tmp_reg = (rdst != CY_CRYPTO_VU_HW_REG14) ? CY_CRYPTO_VU_HW_REG14 : CY_CRYPTO_VU_HW_REG13;
uint32_t tmp_data;
CY_CRYPTO_VU_SAVE_REG(base, tmp_reg, &tmp_data);
uint32_t tmpReg = (rdst != CY_CRYPTO_VU_HW_REG14) ? CY_CRYPTO_VU_HW_REG14 : CY_CRYPTO_VU_HW_REG13;
uint32_t tmpData;
CY_CRYPTO_VU_SAVE_REG(base, tmpReg, &tmpData);
CY_CRYPTO_VU_SET_REG(base, tmp_reg, imm13, 13);
CY_CRYPTO_VU_COND_CLR_BIT(base, cc, rdst, tmp_reg);
/* Load 13 bit immediate value */
CY_CRYPTO_VU_SET_REG(base, tmpReg, imm13, 13u);
CY_CRYPTO_VU_COND_CLR_BIT(base, cc, rdst, tmpReg);
CY_CRYPTO_VU_RESTORE_REG(base, tmp_reg, tmp_data);
CY_CRYPTO_VU_RESTORE_REG(base, tmpReg, tmpData);
}
else
{
@ -748,7 +751,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_CLR_BIT_IMM (CRYPTO_Type *base, uint32_t
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU2_CLR_BIT_IMM_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC16_SHIFT) |
(uint32_t)imm13 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)imm13 << CY_CRYPTO_RSRC0_SHIFT));
}
}
@ -759,17 +762,18 @@ __STATIC_INLINE void CY_CRYPTO_VU_CLR_BIT_IMM (CRYPTO_Type *base, uint32_t rdst,
__STATIC_INLINE void CY_CRYPTO_VU_COND_INV_BIT_IMM (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t imm13)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/******** V1 ********/
int tmp_reg = (rdst != CY_CRYPTO_VU_HW_REG14) ? CY_CRYPTO_VU_HW_REG14 : CY_CRYPTO_VU_HW_REG13;
uint32_t tmp_data;
CY_CRYPTO_VU_SAVE_REG(base, tmp_reg, &tmp_data);
uint32_t tmpReg = (rdst != CY_CRYPTO_VU_HW_REG14) ? CY_CRYPTO_VU_HW_REG14 : CY_CRYPTO_VU_HW_REG13;
uint32_t tmpData;
CY_CRYPTO_VU_SAVE_REG(base, tmpReg, &tmpData);
CY_CRYPTO_VU_SET_REG(base, tmp_reg, imm13, 13);
CY_CRYPTO_VU_COND_INV_BIT(base, cc, rdst, tmp_reg);
/* Load 13 bit immediate value */
CY_CRYPTO_VU_SET_REG(base, tmpReg, imm13, 13u);
CY_CRYPTO_VU_COND_INV_BIT(base, cc, rdst, tmpReg);
CY_CRYPTO_VU_RESTORE_REG(base, tmp_reg, tmp_data);
CY_CRYPTO_VU_RESTORE_REG(base, tmpReg, tmpData);
}
else
{
@ -777,7 +781,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_INV_BIT_IMM (CRYPTO_Type *base, uint32_t
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU2_INV_BIT_IMM_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC16_SHIFT) |
(uint32_t)imm13 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)imm13 << CY_CRYPTO_RSRC0_SHIFT));
}
}
@ -791,7 +795,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_TST (CRYPTO_Type *base, uint32_t cc, uint
{
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_TST_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_TST (CRYPTO_Type *base, uint32_t rsrc)
@ -804,7 +808,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_MOV (CRYPTO_Type *base, uint32_t cc, uint
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_MOV_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_MOV (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc)
@ -817,7 +821,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_XSQUARE (CRYPTO_Type *base, uint32_t cc,
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_XSQUARE_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_XSQUARE (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc)
@ -831,7 +835,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_XMUL (CRYPTO_Type *base, uint32_t cc, uin
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_XMUL (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -846,7 +850,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_UMUL (CRYPTO_Type *base, uint32_t cc, uin
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_UMUL (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -856,7 +860,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_UMUL (CRYPTO_Type *base, uint32_t rdst, uint32
__STATIC_INLINE void CY_CRYPTO_VU_COND_USQUARE (CRYPTO_Type *base, uint32_t cc, uint32_t rdst, uint32_t rsrc)
{
if (cy_device->cryptoVersion == 1)
if (CY_CRYPTO_HW_V1)
{
/***** V1 *******/
CY_CRYPTO_VU_COND_UMUL(base, cc, rdst, rsrc, rsrc);
@ -867,7 +871,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_USQUARE (CRYPTO_Type *base, uint32_t cc,
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU2_USQUARE_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
(uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc << CY_CRYPTO_RSRC0_SHIFT));
}
}
@ -906,7 +910,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_ADD (CRYPTO_Type *base, uint32_t cc, uint
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_ADD (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -920,7 +924,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_SUB (CRYPTO_Type *base, uint32_t cc, uint
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_SUB (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -934,7 +938,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_OR (CRYPTO_Type *base, uint32_t cc, uint3
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_OR (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -948,7 +952,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_AND (CRYPTO_Type *base, uint32_t cc, uint
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_AND (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -962,7 +966,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_XOR (CRYPTO_Type *base, uint32_t cc, uint
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_XOR (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -976,7 +980,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_NOR (CRYPTO_Type *base, uint32_t cc, uint
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_NOR (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -990,7 +994,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_NAND (CRYPTO_Type *base, uint32_t cc, uin
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rdst << CY_CRYPTO_RSRC12_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_NAND (CRYPTO_Type *base, uint32_t rdst, uint32_t rsrc1, uint32_t rsrc0)
@ -1003,7 +1007,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_CMP_SUB (CRYPTO_Type *base, uint32_t cc,
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_CMP_SUB_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_CMP_SUB (CRYPTO_Type *base, uint32_t rsrc1, uint32_t rsrc0)
@ -1016,7 +1020,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_COND_CMP_DEGREE (CRYPTO_Type *base, uint32_t c
REG_CRYPTO_INSTR_FF_WR(base) = (((uint32_t)CY_CRYPTO_VU_CMP_DEGREE_OPC << CY_CRYPTO_OPCODE_POS) |
((uint32_t)cc << CY_CRYPTO_RSRC20_SHIFT) |
((uint32_t)rsrc1 << CY_CRYPTO_RSRC4_SHIFT) |
(uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT);
((uint32_t)rsrc0 << CY_CRYPTO_RSRC0_SHIFT));
}
__STATIC_INLINE void CY_CRYPTO_VU_CMP_DEGREE (CRYPTO_Type *base, uint32_t rsrc1, uint32_t rsrc0)
@ -1031,7 +1035,7 @@ __STATIC_INLINE void CY_CRYPTO_VU_SAVE_REG (CRYPTO_Type *base, uint32_t rsrc, ui
__STATIC_INLINE void CY_CRYPTO_VU_RESTORE_REG (CRYPTO_Type *base, uint32_t rdst, uint32_t data)
{
CY_CRYPTO_VU_SET_REG(base, rdst, CY_CRYPTO_VU_GET_REG_DATA(data), CY_CRYPTO_VU_GET_REG_SIZE(data) + 1);
CY_CRYPTO_VU_SET_REG(base, rdst, CY_CRYPTO_VU_GET_REG_DATA(data), CY_CRYPTO_VU_GET_REG_SIZE(data) + 1u);
}

30
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_mem.h
View File

@ -44,6 +44,11 @@ typedef uint32_t (*cy_crypto_memcmp_func_t)(CRYPTO_Type *base,
typedef void (*cy_crypto_memxor_func_t)(CRYPTO_Type *base, void* dst,
void const *src0, void const *src1, uint16_t size);
/**
* \addtogroup group_crypto_lld_mem_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_MemCpy
****************************************************************************//**
@ -53,7 +58,7 @@ typedef void (*cy_crypto_memxor_func_t)(CRYPTO_Type *base, void* dst,
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dst
* The pointer to the destination of MemCpy.
@ -67,7 +72,7 @@ typedef void (*cy_crypto_memxor_func_t)(CRYPTO_Type *base, void* dst,
*******************************************************************************/
__STATIC_INLINE void Cy_Crypto_Core_MemCpy(CRYPTO_Type *base, void* dst, void const *src, uint16_t size)
{
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
Cy_Crypto_Core_V1_MemCpy(base, dst, src, size);
}
@ -85,7 +90,7 @@ __STATIC_INLINE void Cy_Crypto_Core_MemCpy(CRYPTO_Type *base, void* dst, void co
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dst
* The pointer to the destination of MemSet.
@ -99,7 +104,7 @@ __STATIC_INLINE void Cy_Crypto_Core_MemCpy(CRYPTO_Type *base, void* dst, void co
*******************************************************************************/
__STATIC_INLINE void Cy_Crypto_Core_MemSet(CRYPTO_Type *base, void* dst, uint8_t data, uint16_t size)
{
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
Cy_Crypto_Core_V1_MemSet(base, dst, data, size);
}
@ -117,7 +122,7 @@ __STATIC_INLINE void Cy_Crypto_Core_MemSet(CRYPTO_Type *base, void* dst, uint8_t
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src0
* The pointer to the first source of MemCmp.
@ -134,17 +139,17 @@ __STATIC_INLINE void Cy_Crypto_Core_MemSet(CRYPTO_Type *base, void* dst, uint8_t
*******************************************************************************/
__STATIC_INLINE uint32_t Cy_Crypto_Core_MemCmp(CRYPTO_Type *base, void const *src0, void const *src1, uint16_t size)
{
uint32_t result;
if (cy_device->cryptoVersion == 1u)
uint32_t tmpResult;
if (CY_CRYPTO_HW_V1)
{
result = Cy_Crypto_Core_V1_MemCmp(base, src0, src1, size);
tmpResult = Cy_Crypto_Core_V1_MemCmp(base, src0, src1, size);
}
else
{
result = Cy_Crypto_Core_V2_MemCmp(base, src0, src1, size);
tmpResult = Cy_Crypto_Core_V2_MemCmp(base, src0, src1, size);
}
return (result);
return (tmpResult);
}
/*******************************************************************************
@ -156,7 +161,7 @@ __STATIC_INLINE uint32_t Cy_Crypto_Core_MemCmp(CRYPTO_Type *base, void const *sr
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dst
* The pointer to the destination of MemXor.
@ -174,7 +179,7 @@ __STATIC_INLINE uint32_t Cy_Crypto_Core_MemCmp(CRYPTO_Type *base, void const *sr
__STATIC_INLINE void Cy_Crypto_Core_MemXor(CRYPTO_Type *base, void* dst,
void const *src0, void const *src1, uint16_t size)
{
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
Cy_Crypto_Core_V1_MemXor(base, dst, src0, src1, size);
}
@ -184,6 +189,7 @@ __STATIC_INLINE void Cy_Crypto_Core_MemXor(CRYPTO_Type *base, void* dst,
}
}
/** \} group_crypto_lld_mem_functions */
#endif /* CY_IP_MXCRYPTO */

35
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_prng.h
View File

@ -45,6 +45,11 @@ typedef cy_en_crypto_status_t (*cy_crypto_prng_func_t)(CRYPTO_Type *base,
uint32_t max,
uint32_t *randomNum);
/**
* \addtogroup group_crypto_lld_rng_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Prng_Init
****************************************************************************//**
@ -53,7 +58,7 @@ typedef cy_en_crypto_status_t (*cy_crypto_prng_func_t)(CRYPTO_Type *base,
* Invoking this function causes a restart of the pseudo-random sequence.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param lfsr32InitState
* A non-zero seed value for the first LFSR.
@ -65,7 +70,7 @@ typedef cy_en_crypto_status_t (*cy_crypto_prng_func_t)(CRYPTO_Type *base,
* A non-zero seed value for the third LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Prng_Init(CRYPTO_Type *base,
@ -73,18 +78,18 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Prng_Init(CRYPTO_Type *base
uint32_t lfsr31InitState,
uint32_t lfsr29InitState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Prng_Init(base, lfsr32InitState, lfsr31InitState, lfsr29InitState);
tmpResult = Cy_Crypto_Core_V1_Prng_Init(base, lfsr32InitState, lfsr31InitState, lfsr29InitState);
}
else
{
myResult = Cy_Crypto_Core_V2_Prng_Init(base, lfsr32InitState, lfsr31InitState, lfsr29InitState);
tmpResult = Cy_Crypto_Core_V2_Prng_Init(base, lfsr32InitState, lfsr31InitState, lfsr29InitState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
@ -94,7 +99,7 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Prng_Init(CRYPTO_Type *base
* Generates a Pseudo Random Number.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param max
* The maximum value of a random number.
@ -103,27 +108,29 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Prng_Init(CRYPTO_Type *base
* The pointer to a variable to store the generated pseudo random number.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Prng(CRYPTO_Type *base,
uint32_t max,
uint32_t *randomNum)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Prng(base, max, randomNum);
tmpResult = Cy_Crypto_Core_V1_Prng(base, max, randomNum);
}
else
{
myResult = Cy_Crypto_Core_V2_Prng(base, max, randomNum);
tmpResult = Cy_Crypto_Core_V2_Prng(base, max, randomNum);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_rng_functions */
#endif /* #if (CPUSS_CRYPTO_PR == 1) */
#endif /* CY_IP_MXCRYPTO */

110
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_sha.h
View File

@ -42,6 +42,11 @@ typedef cy_en_crypto_status_t (*cy_crypto_sha_func_t)(CRYPTO_Type *base,
uint8_t *digest,
cy_en_crypto_sha_mode_t mode);
/**
* \addtogroup group_crypto_lld_sha_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Sha
****************************************************************************//**
@ -49,22 +54,22 @@ typedef cy_en_crypto_status_t (*cy_crypto_sha_func_t)(CRYPTO_Type *base,
* Performs the SHA Hash function.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param mode
* \ref cy_en_crypto_sha_mode_t
*
* \param message
* The pointer to a message whose hash value is being computed.
* The pointer to the message whose hash value is being computed.
*
* \param messageSize
* The size of a message.
* The size of the message.
*
* \param digest
* The pointer to the hash digest.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha(CRYPTO_Type *base,
@ -73,41 +78,41 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha(CRYPTO_Type *base,
uint8_t *digest,
cy_en_crypto_sha_mode_t mode)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Sha(base, message, messageSize, digest, mode);
tmpResult = Cy_Crypto_Core_V1_Sha(base, message, messageSize, digest, mode);
}
else
{
myResult = Cy_Crypto_Core_V2_Sha(base, message, messageSize, digest, mode);
tmpResult = Cy_Crypto_Core_V2_Sha(base, message, messageSize, digest, mode);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Sha_Init
****************************************************************************//**
*
* The function to initialize SHA operation.
* The function to initialize the SHA operation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param shaHashState
* The pointer to a Hash State.
* The pointer to a Hash state.
*
* \param mode
* One of these: CY_CRYPTO_SHA256, CY_CRYPTO_SHA1, CY_CRYPTO_SHA256_224,
* CY_CRYPTO_SHA512, CY_CRYPTO_SHA384, CY_CRYPTO_SHA512_224, CY_CRYPTO_SHA512_256
*
* \param shaBuffers
* The pointer to memory buffers storage
* The pointer to the memory buffers storage.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Init(CRYPTO_Type *base,
@ -115,50 +120,50 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Init(CRYPTO_Type *base,
cy_en_crypto_sha_mode_t mode,
void *shaBuffers)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Sha_Init(base, shaHashState, mode, shaBuffers);
tmpResult = Cy_Crypto_Core_V1_Sha_Init(base, shaHashState, mode, shaBuffers);
}
else
{
myResult = Cy_Crypto_Core_V2_Sha_Init(base, shaHashState, mode, shaBuffers);
tmpResult = Cy_Crypto_Core_V2_Sha_Init(base, shaHashState, mode, shaBuffers);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Sha_Start
****************************************************************************//**
*
* Initializes the initial hash vector.
* Initializes the initial Hash vector.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Start(CRYPTO_Type *base, cy_stc_crypto_sha_state_t *hashState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Sha_Start(base, hashState);
tmpResult = Cy_Crypto_Core_V1_Sha_Start(base, hashState);
}
else
{
myResult = Cy_Crypto_Core_V2_Sha_Start(base, hashState);
tmpResult = Cy_Crypto_Core_V2_Sha_Start(base, hashState);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
@ -168,7 +173,7 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Start(CRYPTO_Type *base
* Performs the SHA calculation on one message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
@ -180,12 +185,12 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Start(CRYPTO_Type *base
* The size of the message whose Hash is being computed.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \note
* This function can be called several times only with message lengths dividable
* by block size. Only the last call to the function can process a message with
* the not dividable size.
* by the block size. Only the last call to the function can process a message with
* a not-dividable size.
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Update(CRYPTO_Type *base,
@ -193,55 +198,55 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Update(CRYPTO_Type *bas
uint8_t const *message,
uint32_t messageSize)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Sha_Update(base, hashState, message, messageSize);
tmpResult = Cy_Crypto_Core_V1_Sha_Update(base, hashState, message, messageSize);
}
else
{
myResult = Cy_Crypto_Core_V2_Sha_Update(base, hashState, message, messageSize);
tmpResult = Cy_Crypto_Core_V2_Sha_Update(base, hashState, message, messageSize);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_V1_Sha_Finish
****************************************************************************//**
*
* Completes SHA calculation.
* Completes the SHA calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \param digest
* The pointer to the calculated hash digest.
* The pointer to the calculated Hash digest.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Finish(CRYPTO_Type *base,
cy_stc_crypto_sha_state_t *hashState,
uint8_t *digest)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Sha_Finish(base, hashState, digest);
tmpResult = Cy_Crypto_Core_V1_Sha_Finish(base, hashState, digest);
}
else
{
myResult = Cy_Crypto_Core_V2_Sha_Finish(base, hashState, digest);
tmpResult = Cy_Crypto_Core_V2_Sha_Finish(base, hashState, digest);
}
return myResult;
return tmpResult;
}
/*******************************************************************************
@ -251,31 +256,32 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Finish(CRYPTO_Type *bas
* Clears the used memory buffers.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Sha_Free(CRYPTO_Type *base, cy_stc_crypto_sha_state_t *hashState)
{
cy_en_crypto_status_t myResult;
cy_en_crypto_status_t tmpResult;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
myResult = Cy_Crypto_Core_V1_Sha_Free(base, hashState);
tmpResult = Cy_Crypto_Core_V1_Sha_Free(base, hashState);
}
else
{
myResult = Cy_Crypto_Core_V2_Sha_Free(base, hashState);
tmpResult = Cy_Crypto_Core_V2_Sha_Free(base, hashState);
}
return myResult;
return tmpResult;
}
/** \} group_crypto_lld_sha_functions */
#endif /* #if (CPUSS_CRYPTO_SHA == 1) */

18
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_sha_v1.h
View File

@ -38,37 +38,37 @@
typedef struct
{
/* Allocate CRYPTO_MAX_BLOCK_SIZE Bytes for block */
/* Allocates CRYPTO_MAX_BLOCK_SIZE Bytes for the block. */
uint32_t block[CY_CRYPTO_SHA1_BLOCK_SIZE / 4u];
/* Allocate CRYPTO_MAX_HASH_SIZE Bytes for hash */
/* Allocates CRYPTO_MAX_HASH_SIZE Bytes for the hash. */
uint32_t hash[CY_CRYPTO_SHA1_HASH_SIZE / 4u];
/* Allocate CRYPTO_MAX_ROUND_MEM_SIZE Bytes for roundMem */
/* Allocates CRYPTO_MAX_ROUND_MEM_SIZE Bytes for roundMem. */
uint32_t roundMem[CY_CRYPTO_SHA1_ROUND_MEM_SIZE / 4u];
} cy_stc_crypto_v1_sha1_buffers_t;
typedef struct
{
/* Allocate CRYPTO_MAX_BLOCK_SIZE Bytes for block */
/* Allocates CRYPTO_MAX_BLOCK_SIZE Bytes for the block. */
uint32_t block[CY_CRYPTO_SHA256_BLOCK_SIZE / 4u];
/* Allocate CRYPTO_MAX_HASH_SIZE Bytes for hash */
/* Allocates CRYPTO_MAX_HASH_SIZE Bytes for the hash. */
uint32_t hash[CY_CRYPTO_SHA256_HASH_SIZE / 4u];
/* Allocate CRYPTO_MAX_ROUND_MEM_SIZE Bytes for roundMem */
/* Allocates CRYPTO_MAX_ROUND_MEM_SIZE Bytes for roundMem. */
uint32_t roundMem[CY_CRYPTO_SHA256_ROUND_MEM_SIZE / 4u];
} cy_stc_crypto_v1_sha256_buffers_t;
typedef struct
{
/* Allocate CRYPTO_MAX_BLOCK_SIZE Bytes for block */
/* Allocates CRYPTO_MAX_BLOCK_SIZE Bytes for the block. */
uint32_t block[CY_CRYPTO_SHA512_BLOCK_SIZE / 4u];
/* Allocate CRYPTO_MAX_HASH_SIZE Bytes for hash */
/* Allocates CRYPTO_MAX_HASH_SIZE Bytes for the hash. */
uint32_t hash[CY_CRYPTO_SHA512_HASH_SIZE / 4u];
/* Allocate CRYPTO_MAX_ROUND_MEM_SIZE Bytes for roundMem */
/* Allocates CRYPTO_MAX_ROUND_MEM_SIZE Bytes for roundMem. */
uint32_t roundMem[CY_CRYPTO_SHA512_ROUND_MEM_SIZE / 4u];
} cy_stc_crypto_v1_sha512_buffers_t;

2
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_sha_v2.h
View File

@ -38,7 +38,7 @@
/** \cond INTERNAL */
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Init(CRYPTO_Type *base,
cy_stc_crypto_sha_state_t *shaHashState,
cy_stc_crypto_sha_state_t *hashState,
cy_en_crypto_sha_mode_t mode,
void *shaBuffers);

25
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_trng.h
View File

@ -42,15 +42,19 @@ typedef cy_en_crypto_status_t (*cy_crypto_trng_func_t)(CRYPTO_Type *base,
uint32_t max,
uint32_t *randomNum);
/**
* \addtogroup group_crypto_lld_rng_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Trng
****************************************************************************//**
*
* Generates a True Random Number and returns it in the
* cfContext->trngNumPtr.
* Generates a True Random Number.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param GAROPol
* The polynomial for the programmable Galois ring oscillator.
@ -59,13 +63,13 @@ typedef cy_en_crypto_status_t (*cy_crypto_trng_func_t)(CRYPTO_Type *base,
* The polynomial for the programmable Fibonacci ring oscillator.
*
* \param max
* The maximum length of a random number, in the range [0, 32] bits.
* The maximum length of a random number, in the range of [0, 32] bits.
*
* \param randomNum
* The pointer to a generated true random number. Must be 4-byte aligned.
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
__STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Trng(CRYPTO_Type *base,
@ -74,18 +78,19 @@ __STATIC_INLINE cy_en_crypto_status_t Cy_Crypto_Core_Trng(CRYPTO_Type *base,
uint32_t max,
uint32_t *randomNum)
{
cy_en_crypto_status_t result;
if (cy_device->cryptoVersion == 1u)
cy_en_crypto_status_t tmpResult;
if (CY_CRYPTO_HW_V1)
{
result = Cy_Crypto_Core_V1_Trng(base, GAROPol, FIROPol, max, randomNum);
tmpResult = Cy_Crypto_Core_V1_Trng(base, GAROPol, FIROPol, max, randomNum);
}
else
{
result = Cy_Crypto_Core_V2_Trng(base, GAROPol, FIROPol, max, randomNum);
tmpResult = Cy_Crypto_Core_V2_Trng(base, GAROPol, FIROPol, max, randomNum);
}
return (result);
return (tmpResult);
}
/** \} group_crypto_lld_rng_functions */
#endif /* #if (CPUSS_CRYPTO_TR == 1) */

14
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_trng_config_v1.h
View File

@ -182,11 +182,11 @@
#define CY_CRYPTO_V1_TR_CUTOFF_COUNT8 (1UL)
/**
Cut-off count (legal range is [1, 65535]).
"0": Illegal.
"1": 1 occurrence.
...
"65535": 65535 occurrences.
* Cut-off count (legal range is [1, 65535]).
* "0": Illegal.
* "1": 1 occurrence.
* ...
* "65535": 65535 occurrences.
*/
#define CY_CRYPTO_V1_TR_CUTOFF_COUNT16 (1UL)
@ -196,9 +196,9 @@ Cut-off count (legal range is [1, 65535]).
* ...
* "65535": 65536 bits.
*/
#define CY_CRYPTO_V1_TR_WINDOW_SIZE (1uL)
#define CY_CRYPTO_V1_TR_WINDOW_SIZE (1UL)
/** the composed value for the TR_CTL0 register */
/** The composed value for the TR_CTL0 register */
#define CY_CRYPTO_V1_TR_CTL0_VAL (_VAL2FLD(CRYPTO_TR_CTL0_SAMPLE_CLOCK_DIV, CY_CRYPTO_V1_TR_SAMPLE_CLOCK_DIV) | \
_VAL2FLD(CRYPTO_TR_CTL0_RED_CLOCK_DIV, CY_CRYPTO_V1_TR_RED_CLOCK_DIV) | \
_VAL2FLD(CRYPTO_TR_CTL0_INIT_DELAY, CY_CRYPTO_V1_TR_INIT_DELAY) | \

14
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_trng_config_v2.h
View File

@ -182,11 +182,11 @@
#define CY_CRYPTO_V2_TR_CUTOFF_COUNT8 (1UL)
/**
Cut-off count (legal range is [1, 65535]).
"0": Illegal.
"1": 1 occurrence.
...
"65535": 65535 occurrences.
* Cut-off count (legal range is [1, 65535]).
* "0": Illegal.
* "1": 1 occurrence.
* ...
* "65535": 65535 occurrences.
*/
#define CY_CRYPTO_V2_TR_CUTOFF_COUNT16 (1UL)
@ -196,9 +196,9 @@ Cut-off count (legal range is [1, 65535]).
* ...
* "65535": 65536 bits.
*/
#define CY_CRYPTO_V2_TR_WINDOW_SIZE (1uL)
#define CY_CRYPTO_V2_TR_WINDOW_SIZE (1UL)
/** the composed value for the TR_CTL0 register */
/** The composed value for the TR_CTL0 register */
#define CY_CRYPTO_V2_TR_CTL0_VAL (_VAL2FLD(CRYPTO_TR_CTL0_SAMPLE_CLOCK_DIV, CY_CRYPTO_V2_TR_SAMPLE_CLOCK_DIV) | \
_VAL2FLD(CRYPTO_TR_CTL0_RED_CLOCK_DIV, CY_CRYPTO_V2_TR_RED_CLOCK_DIV) | \
_VAL2FLD(CRYPTO_TR_CTL0_INIT_DELAY, CY_CRYPTO_V2_TR_INIT_DELAY) | \

2
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_trng_v1.h
View File

@ -46,7 +46,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Trng(CRYPTO_Type *base,
#endif /* CY_IP_MXCRYPTO */
#endif /* #if !defined(CY_CRYPTO_CORE_TRNG_H) */
#endif /* #if !defined(CY_CRYPTO_CORE_TRNG_V1_H) */
/* [] END OF FILE */

62
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_core_vu.h
View File

@ -41,17 +41,22 @@
#define CY_CRYPTO_VU_DATA_FLD_MASK (0x00003fffuL)
#define CY_CRYPTO_VU_DATA_FLD_POS (16u)
/**
* \addtogroup group_crypto_lld_vu_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Cleanup
****************************************************************************//**
*
* Cleanup the the CRYPTO block.
* Cleans up the Crypto block.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_Cleanup(CRYPTO_Type *base);
@ -60,10 +65,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_Cleanup(CRYPTO_Type *base);
* Function Name: Cy_Crypto_Core_Vu_SetMemValue
****************************************************************************//**
*
* Sets the value in the crypto memory allocated by destination VU register.
* Sets the value in the Crypto memory allocated by the destination VU register.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dstReg
* The destination vector unit register.
@ -84,7 +89,7 @@ void Cy_Crypto_Core_Vu_SetMemValue(CRYPTO_Type *base, uint32_t dstReg, uint8_t c
* Gets the value located in the crypto memory and pointed by source VU register.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dst
* The pointer to the destination value.
@ -102,10 +107,10 @@ void Cy_Crypto_Core_Vu_GetMemValue(CRYPTO_Type *base, uint8_t *dst, uint32_t src
* Function Name: Cy_Crypto_Core_Vu_IsRegZero
****************************************************************************//**
*
* Returns TRUE if srcReg contains 0. FALSE otherwise.
* Returns TRUE if srcReg contains 0. FALSE - otherwise.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -120,10 +125,10 @@ bool Cy_Crypto_Core_Vu_IsRegZero(CRYPTO_Type *base, uint32_t srcReg);
* Function Name: Cy_Crypto_Core_Vu_IsRegEqual
****************************************************************************//**
*
* Returns TRUE if srcReg0 contains the same value as srcReg1. FALSE otherwise.
* Returns TRUE if srcReg0 contains the same value as srcReg1. FALSE - otherwise.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg0
* The source 0 vector unit register.
@ -142,10 +147,10 @@ bool Cy_Crypto_Core_Vu_IsRegEqual(CRYPTO_Type *base, uint32_t srcReg0, uint32_t
****************************************************************************//**
*
* Returns TRUE if srcReg0 contains the value less than value of srcReg1.
* FALSE otherwise.
* FALSE - otherwise.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg0
* The source 0 vector unit register.
@ -163,10 +168,10 @@ bool Cy_Crypto_Core_Vu_IsRegLess(CRYPTO_Type *base, uint32_t srcReg0, uint32_t s
* Function Name: Cy_Crypto_Core_Vu_RegRead
****************************************************************************//**
*
* Returns the data pointed in given register
* Returns the data pointed in a given register.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -185,7 +190,7 @@ __STATIC_INLINE uint32_t Cy_Crypto_Core_Vu_RegRead(CRYPTO_Type *base, uint32_t s
* it is lower 12Bit of the 32Bit word
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -204,7 +209,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegSizeRead(CRYPTO_Type *base, uint32
* It is lower 12Bit of the 32Bit word
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -223,7 +228,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegBitSizeRead(CRYPTO_Type *base, uin
* It is lower 12Bit of the 32Bit word
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -242,7 +247,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegByteSizeRead(CRYPTO_Type *base, ui
* It is lower 12Bit of the 32Bit word
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -261,7 +266,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegWordSizeRead(CRYPTO_Type *base, ui
* it is upper 16Bit of the 32Bir word. Pointer is in words (uint32_t).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -269,7 +274,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegWordSizeRead(CRYPTO_Type *base, ui
*******************************************************************************/
__STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegDataPtrRead(CRYPTO_Type *base, uint32_t srcReg)
{
return ((uint16_t)(_FLD2VAL(CRYPTO_RF_DATA_DATA32, REG_CRYPTO_VU_RF_DATA(base, srcReg)) >> CY_CRYPTO_VU_DATA_FLD_POS)
return (uint16_t)((_FLD2VAL(CRYPTO_RF_DATA_DATA32, REG_CRYPTO_VU_RF_DATA(base, srcReg)) >> CY_CRYPTO_VU_DATA_FLD_POS)
& CY_CRYPTO_VU_DATA_FLD_MASK);
}
@ -280,7 +285,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegDataPtrRead(CRYPTO_Type *base, uin
* Returns the memory address of the data pointed in given register.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcReg
* The source vector unit register.
@ -288,7 +293,7 @@ __STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_RegDataPtrRead(CRYPTO_Type *base, uin
*******************************************************************************/
__STATIC_INLINE uint32_t * Cy_Crypto_Core_Vu_RegMemPointer(CRYPTO_Type *base, uint32_t srcReg)
{
return (uint32_t *)((uint32_t)REG_CRYPTO_MEM_BUFF(base) + 4u * (uint32_t)Cy_Crypto_Core_Vu_RegDataPtrRead(base, srcReg));
return (uint32_t *)((uint32_t)REG_CRYPTO_MEM_BUFF(base) + (4u * (uint32_t)Cy_Crypto_Core_Vu_RegDataPtrRead(base, srcReg)));
}
/*******************************************************************************
@ -298,13 +303,13 @@ __STATIC_INLINE uint32_t * Cy_Crypto_Core_Vu_RegMemPointer(CRYPTO_Type *base, ui
* Waits until VU instruction will be completed
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
__STATIC_INLINE void Cy_Crypto_Core_Vu_WaitForComplete(CRYPTO_Type *base)
{
/* Wait until the VU instruction is complete */
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
while (0uL != _FLD2VAL(CRYPTO_STATUS_VU_BUSY, REG_CRYPTO_STATUS(base)))
{
@ -322,19 +327,20 @@ __STATIC_INLINE void Cy_Crypto_Core_Vu_WaitForComplete(CRYPTO_Type *base)
* Function Name: Cy_Crypto_Core_Vu_StatusRead
****************************************************************************//**
*
* Returns value of the VU status register
* Returns the value of the VU status register.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
__STATIC_INLINE uint16_t Cy_Crypto_Core_Vu_StatusRead(CRYPTO_Type *base)
__STATIC_INLINE uint32_t Cy_Crypto_Core_Vu_StatusRead(CRYPTO_Type *base)
{
Cy_Crypto_Core_Vu_WaitForComplete(base);
return((uint16_t)REG_CRYPTO_VU_STATUS(base));
return((uint32_t)REG_CRYPTO_VU_STATUS(base));
}
/** \} group_crypto_lld_vu_functions */
#endif /* #if (CPUSS_CRYPTO_VU == 1) */

8
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_crypto_server.h
View File

@ -63,7 +63,7 @@ extern "C" {
* the Crypto server context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \funcusage
* \snippet crypto/2.10/snippet/main.c snippet_myCryptoServerStartBase
@ -94,7 +94,7 @@ cy_en_crypto_status_t Cy_Crypto_Server_Start_Base(cy_stc_crypto_config_t const *
* the Crypto server context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* Refer to \ref Cy_Crypto_Server_Start_Base for the function usage example.
*
@ -124,7 +124,7 @@ cy_en_crypto_status_t Cy_Crypto_Server_Start_Extra(cy_stc_crypto_config_t const
* the Crypto server context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* Refer to \ref Cy_Crypto_Server_Start_Base for the function usage example.
*
@ -142,7 +142,7 @@ cy_en_crypto_status_t Cy_Crypto_Server_Start_Full(cy_stc_crypto_config_t const *
* This function available for Server side only.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Server_Stop(void);

2
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_device.h
View File

@ -189,6 +189,8 @@ void Cy_PDL_Init(const cy_stc_device_t * device);
* Register Access Helper Macros
*******************************************************************************/
#define CY_CRYPTO_HW_V1 (1U == cy_device->cryptoVersion) /* true if the mxcrypto version is 1 */
#define CY_SRSS_NUM_CLKPATH ((uint32_t)(cy_device->srssNumClkpath))
#define CY_SRSS_NUM_PLL ((uint32_t)(cy_device->srssNumPll))
#define CY_SRSS_NUM_HFROOT ((uint32_t)(cy_device->srssNumHfroot))

3
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_pdl.h
View File

@ -36,6 +36,7 @@
#include "cy_ctb.h"
#include "cy_ctdac.h"
#include "cy_dma.h"
#include "cy_dmac.h"
#include "cy_efuse.h"
#include "cy_flash.h"
#include "cy_gpio.h"
@ -55,8 +56,10 @@
#include "cy_scb_i2c.h"
#include "cy_scb_spi.h"
#include "cy_scb_uart.h"
#include "cy_sd_host.h"
#include "cy_smartio.h"
#include "cy_smif.h"
#include "cy_smif_memslot.h"
#include "cy_sysanalog.h"
#include "cy_sysclk.h"
#include "cy_sysint.h"

1
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/include/cy_sysclk.h
View File

@ -112,6 +112,7 @@
* <td>Updated the following functions implementation: \ref Cy_SysClk_EcoEnable, \ref Cy_SysClk_EcoGetStatus, \ref Cy_SysClk_FllGetConfiguration \n
* and \ref Cy_SysClk_DeepSleepCallback. \n
* The \ref Cy_SysClk_DeepSleepCallback now implements all four SysPm callback modes \ref cy_en_syspm_callback_mode_t. \n
* The actions that were done in \ref CY_SYSPM_CHECK_READY case are moved to \ref CY_SYSPM_BEFORE_TRANSITION. \n
* So the \ref cy_stc_syspm_callback_t::skipMode must be set to 0UL.</td>
* <td>Defect fixing.</td>
* </tr>

10
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_ble_clk.c
View File

@ -1,6 +1,6 @@
/***************************************************************************//**
* \file cy_ble_clk.c
* \version 3.0
* \version 3.10
*
* \brief
* This driver provides the source code for API BLE ECO clock.
@ -138,8 +138,8 @@ static cy_en_ble_eco_status_t Cy_BLE_HAL_MxdRadioEnableClocks(cy_en_ble_eco_freq
/* Range for inputs parameters */
#define CY_BLE_ECO_XTAL_SRART_UP_TIME_MAX ((uint8_t) (4593.75 / 31.25))
#define CY_BLE_ECO_XTAL_SRART_UP_TIME_MIN ((uint8_t) (400 / 31.25))
#define CY_BLE_ECO_XTAL_START_UP_TIME_MAX ((uint8_t) (4593.75 / 31.25))
#define CY_BLE_ECO_XTAL_START_UP_TIME_MIN ((uint8_t) (400 / 31.25))
#define CY_BLE_ECO_CLOAD_MIN ((uint8_t) ((7.5 - 7.5)/0.075))
#define CY_BLE_ECO_CLOAD_MAX ((uint8_t) ((26.325 - 7.5)/0.075))
@ -220,7 +220,7 @@ cy_en_ble_eco_status_t Cy_BLE_EcoConfigure(cy_en_ble_eco_freq_t freq, cy_en_ble_
uint32_t temp = 0UL;
if( (freq > CY_BLE_BLESS_ECO_FREQ_32MHZ) || (sysClkDiv > CY_BLE_SYS_ECO_CLK_DIV_8) ||
(xtalStartUpTime > CY_BLE_ECO_XTAL_SRART_UP_TIME_MAX) || (xtalStartUpTime < CY_BLE_ECO_XTAL_SRART_UP_TIME_MIN) ||
(xtalStartUpTime > CY_BLE_ECO_XTAL_START_UP_TIME_MAX) || (xtalStartUpTime < CY_BLE_ECO_XTAL_START_UP_TIME_MIN) ||
(cLoad > CY_BLE_ECO_CLOAD_MAX))
{
status = CY_BLE_ECO_BAD_PARAM;
@ -355,7 +355,7 @@ cy_en_ble_eco_status_t Cy_BLE_EcoConfigure(cy_en_ble_eco_freq_t freq, cy_en_ble_
/* Clear the BLERD_ACTIVE_INTR */
BLE_BLESS_INTR_STAT |= BLE_BLESS_INTR_STAT_BLERD_ACTIVE_INTR_Msk;
if(!Cy_SysPm_SimoBuckOutputIsEnabled(CY_SYSPM_BUCK_VRF))
if((!Cy_SysPm_SimoBuckOutputIsEnabled(CY_SYSPM_BUCK_VRF)) || (voltageReg == CY_BLE_ECO_VOLTAGE_REG_BLESSLDO))
{
temp |= BLE_BLESS_MT_CFG_ACT_LDO_NOT_BUCK_Msk;
}

4
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto.c
View File

@ -171,7 +171,7 @@ cy_en_crypto_status_t Cy_Crypto_Sync(bool isBlocking)
* This function is internal and should not to be called directly by user software.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
static cy_en_crypto_status_t Cy_Crypto_Client_Send(void)
@ -309,7 +309,7 @@ cy_en_crypto_status_t Cy_Crypto_Enable(void)
* The pointer to a variable to store gathered crypto library information.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_GetLibraryInfo(cy_en_crypto_lib_info_t *cryptoInfo)

100
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_aes_v1.c
View File

@ -44,10 +44,11 @@ static void Cy_Crypto_Core_V1_Aes_InvKey(CRYPTO_Type *base, cy_stc_crypto_aes_st
* Performs the AES block cipher.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \param dirMode
* One of CRYPTO_ENCRYPT or CRYPTO_DECRYPT.
@ -90,10 +91,11 @@ void Cy_Crypto_Core_V1_Aes_ProcessBlock(CRYPTO_Type *base,
* All addresses must be 4-Byte aligned!
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \param dstBlock
* The pointer to the memory structure with the XOR results.
@ -136,10 +138,11 @@ void Cy_Crypto_Core_V1_Aes_Xor(CRYPTO_Type *base,
* Calculates an inverse block cipher key from the block cipher key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
*******************************************************************************/
static void Cy_Crypto_Core_V1_Aes_InvKey(CRYPTO_Type *base, cy_stc_crypto_aes_state_t const *aesState)
@ -162,10 +165,10 @@ static void Cy_Crypto_Core_V1_Aes_InvKey(CRYPTO_Type *base, cy_stc_crypto_aes_st
* Function Name: Cy_Crypto_Core_V1_Aes_Init
****************************************************************************//**
*
* Sets Aes mode and prepare inversed key.
* Sets AES mode and prepares an inverse key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param key
* The pointer to the encryption/decryption key.
@ -174,10 +177,11 @@ static void Cy_Crypto_Core_V1_Aes_InvKey(CRYPTO_Type *base, cy_stc_crypto_aes_st
* \ref cy_en_crypto_aes_key_length_t
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Init(CRYPTO_Type *base,
@ -212,10 +216,10 @@ void Cy_Crypto_Core_V1_Aes_Free(CRYPTO_Type *base)
* Function Name: Cy_Crypto_Core_V1_Aes_Ecb
****************************************************************************//**
*
* Performs AES operation on one Block.
* Performs an AES operation on one block.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -228,10 +232,11 @@ void Cy_Crypto_Core_V1_Aes_Free(CRYPTO_Type *base)
* The pointer to a source block.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Ecb(CRYPTO_Type *base,
@ -258,7 +263,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Ecb(CRYPTO_Type *base,
* Performs AES operation on a plain text with Cipher Block Chaining (CBC).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -277,10 +282,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Ecb(CRYPTO_Type *base,
* The pointer to a source plain text.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cbc(CRYPTO_Type *base,
@ -298,17 +304,17 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cbc(CRYPTO_Type *base,
uint32_t *srcBuff = (uint32_t*)(&aesBuffers->block0);
uint32_t *dstBuff = (uint32_t*)(&aesBuffers->block1);
cy_en_crypto_status_t myResult = CY_CRYPTO_SIZE_NOT_X16;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SIZE_NOT_X16;
/* Check whether the data size is multiple of CY_CRYPTO_AES_BLOCK_SIZE */
if (0uL == (uint32_t)(size & (CY_CRYPTO_AES_BLOCK_SIZE - 1u)))
if (0UL == (uint32_t)(size & (CY_CRYPTO_AES_BLOCK_SIZE - 1U)))
{
/* Copy the Initialization Vector to the local buffer because it changes during calculation */
Cy_Crypto_Core_V1_MemCpy(base, tempBuff, ivPtr, CY_CRYPTO_AES_BLOCK_SIZE);
if (CY_CRYPTO_DECRYPT == dirMode)
{
while (size > 0uL)
while (size != 0UL)
{
/* source message block */
Cy_Crypto_Core_V1_MemCpy(base, srcBuff, src, CY_CRYPTO_AES_BLOCK_SIZE);
@ -329,7 +335,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cbc(CRYPTO_Type *base,
}
else
{
while (size > 0uL)
while (size != 0UL)
{
/* source message block */
Cy_Crypto_Core_V1_MemCpy(base, srcBuff, src, CY_CRYPTO_AES_BLOCK_SIZE);
@ -349,10 +355,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cbc(CRYPTO_Type *base,
}
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -362,7 +368,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cbc(CRYPTO_Type *base,
* Performs AES operation on a plain text with the Cipher Feedback Block method (CFB).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -381,10 +387,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cbc(CRYPTO_Type *base,
* The pointer to a source plain text.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user must
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cfb(CRYPTO_Type *base,
@ -396,7 +403,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cfb(CRYPTO_Type *base,
cy_stc_crypto_aes_state_t *aesState)
{
uint32_t size = srcSize;
cy_en_crypto_status_t myResult = CY_CRYPTO_SIZE_NOT_X16;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SIZE_NOT_X16;
cy_stc_crypto_aes_buffers_t *aesBuffers = (cy_stc_crypto_aes_buffers_t*)aesState->buffers;
@ -406,17 +413,17 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cfb(CRYPTO_Type *base,
uint32_t *encBuff = dstBuff; /* Default operation is ENCRYPT */
/* Check whether the data size is multiple of CY_CRYPTO_AES_BLOCK_SIZE */
if (0uL == (size & (CY_CRYPTO_AES_BLOCK_SIZE - 1u)))
if (0UL == (size & (CY_CRYPTO_AES_BLOCK_SIZE - 1U)))
{
if (CY_CRYPTO_DECRYPT == dirMode)
{
encBuff = srcBuff;
}
/* Copy the Initialization Vector to local encode buffer */
/* Copies the Initialization Vector to the local encode buffer. */
Cy_Crypto_Core_V1_MemCpy(base, encBuff, ivPtr, CY_CRYPTO_AES_BLOCK_SIZE);
while (size > 0uL)
while (size != 0UL)
{
/* In this mode, (CFB) is always an encryption! */
Cy_Crypto_Core_V1_Aes_ProcessBlock(base, aesState, CY_CRYPTO_ENCRYPT, dstBuff, encBuff);
@ -435,20 +442,20 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cfb(CRYPTO_Type *base,
size -= CY_CRYPTO_AES_BLOCK_SIZE;
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_V1_Aes_Ctr
********************************************************************************
*
* Performs AES operation on a plain text using the counter method (CTR).
* Performs an AES operation on a plain text using the counter method (CTR).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcSize
* The size of a source plain text.
@ -458,7 +465,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cfb(CRYPTO_Type *base,
* current cipher stream.
*
* \param ivPtr
* The 128-bit nonce and counter.
* The 128-bit initial vector and counter.
*
* \param streamBlock
* The saved stream-block for resuming. Is over-written by the function.
@ -470,13 +477,14 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Cfb(CRYPTO_Type *base,
* The pointer to a source plain text. Must be 4-Byte aligned.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user must
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
#define CY_CRYPTO_AES_CTR_CNT_POS (0x02u)
#define CY_CRYPTO_AES_CTR_CNT_POS (0x02U)
cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Ctr(CRYPTO_Type *base,
uint32_t srcSize,
uint32_t *srcOffset,
@ -491,28 +499,28 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Ctr(CRYPTO_Type *base,
uint64_t counter;
cy_stc_crypto_aes_buffers_t *aesBuffers = (cy_stc_crypto_aes_buffers_t*)aesState->buffers;
uint32_t *nonceCounter = (uint32_t*)(&aesBuffers->iv);
uint32_t *blockCounter = (uint32_t*)(&aesBuffers->iv);
uint32_t *srcBuff = (uint32_t*)(&aesBuffers->block0);
uint32_t *dstBuff = (uint32_t*)(&aesBuffers->block1);
uint32_t *streamBuff = (uint32_t*)(&aesBuffers->block2);
Cy_Crypto_Core_V1_MemCpy(base, nonceCounter, ivPtr, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V1_MemCpy(base, blockCounter, ivPtr, CY_CRYPTO_AES_BLOCK_SIZE);
counter = CY_SWAP_ENDIAN64(*(uint64_t*)(nonceCounter + CY_CRYPTO_AES_CTR_CNT_POS));
counter = CY_SWAP_ENDIAN64(*(uint64_t*)(blockCounter + CY_CRYPTO_AES_CTR_CNT_POS));
cnt = (uint32_t)(srcSize / CY_CRYPTO_AES_BLOCK_SIZE);
for (i = 0uL; i < cnt; i++)
for (i = 0UL; i < cnt; i++)
{
/* source message block */
Cy_Crypto_Core_V1_MemCpy(base, srcBuff, src, CY_CRYPTO_AES_BLOCK_SIZE);
/* In this mode, (CTR) is always an encryption! */
Cy_Crypto_Core_V1_Aes_ProcessBlock(base, aesState, CY_CRYPTO_ENCRYPT, streamBuff, nonceCounter);
Cy_Crypto_Core_V1_Aes_ProcessBlock(base, aesState, CY_CRYPTO_ENCRYPT, streamBuff, blockCounter);
/* Increment the nonce counter, at least 64Bits (from 128) is the counter part */
/* Increment the block counter, at least 64Bits (from 128) is the counter part */
counter++;
*(uint64_t*)(nonceCounter + CY_CRYPTO_AES_CTR_CNT_POS) = CY_SWAP_ENDIAN64(counter);
*(uint64_t*)(blockCounter + CY_CRYPTO_AES_CTR_CNT_POS) = CY_SWAP_ENDIAN64(counter);
Cy_Crypto_Core_V1_Aes_Xor(base, aesState, dstBuff, srcBuff, streamBuff);
@ -523,7 +531,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Aes_Ctr(CRYPTO_Type *base,
dst += CY_CRYPTO_AES_BLOCK_SIZE;
}
Cy_Crypto_Core_V1_MemCpy(base, ivPtr, nonceCounter, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V1_MemCpy(base, ivPtr, blockCounter, CY_CRYPTO_AES_BLOCK_SIZE);
/* Save the reminder of the last non-complete block */
*srcOffset = (uint32_t)(srcSize % CY_CRYPTO_AES_BLOCK_SIZE);

109
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_aes_v2.c
View File

@ -45,10 +45,11 @@
* Calculates an inverse block cipher key from the block cipher key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
*******************************************************************************/
void Cy_Crypto_Core_V2_Aes_LoadEncKey(CRYPTO_Type *base,
@ -77,10 +78,11 @@ void Cy_Crypto_Core_V2_Aes_LoadEncKey(CRYPTO_Type *base,
* Calculates an inverse block cipher key from the block cipher key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
*******************************************************************************/
void Cy_Crypto_Core_V2_Aes_LoadDecKey(CRYPTO_Type *base,
@ -109,10 +111,10 @@ void Cy_Crypto_Core_V2_Aes_LoadDecKey(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V2_Aes_Init
****************************************************************************//**
*
* Sets Aes mode and prepare inversed key.
* Sets AES mode and prepares inverse key.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param key
* The pointer to the encryption/decryption key.
@ -121,10 +123,11 @@ void Cy_Crypto_Core_V2_Aes_LoadDecKey(CRYPTO_Type *base,
* \ref cy_en_crypto_aes_key_length_t
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Init(CRYPTO_Type *base,
@ -150,10 +153,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Init(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V2_Aes_Ecb
****************************************************************************//**
*
* Performs AES operation on one Block.
* Performs an AES operation on one block.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -166,10 +169,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Init(CRYPTO_Type *base,
* The pointer to a source block.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Ecb(CRYPTO_Type *base,
@ -202,7 +206,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Ecb(CRYPTO_Type *base,
* Performs AES operation on a plain text with Cipher Block Chaining (CBC).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -221,10 +225,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Ecb(CRYPTO_Type *base,
* The pointer to a source plain text. Must be 4-Byte aligned.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
@ -236,10 +241,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
cy_stc_crypto_aes_state_t *aesState)
{
uint32_t size = srcSize;
cy_en_crypto_status_t myResult = CY_CRYPTO_SIZE_NOT_X16;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SIZE_NOT_X16;
/* Check whether the data size is multiple of CY_CRYPTO_AES_BLOCK_SIZE */
if (0uL == (uint32_t)(srcSize & (uint32_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1u)))
if (0UL == (uint32_t)(srcSize & (uint32_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1U)))
{
(CY_CRYPTO_ENCRYPT == dirMode) ? \
@ -254,7 +259,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
{
Cy_Crypto_Core_V2_BlockMov(base, CY_CRYPTO_V2_RB_BLOCK1, CY_CRYPTO_V2_RB_FF_LOAD1, CY_CRYPTO_AES_BLOCK_SIZE);
while (size != 0u)
while (size != 0U)
{
Cy_Crypto_Core_V2_BlockXor(base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_FF_LOAD0,
CY_CRYPTO_V2_RB_BLOCK1, CY_CRYPTO_AES_BLOCK_SIZE);
@ -268,7 +273,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
{
Cy_Crypto_Core_V2_BlockMov(base, CY_CRYPTO_V2_RB_BLOCK2, CY_CRYPTO_V2_RB_FF_LOAD1, CY_CRYPTO_AES_BLOCK_SIZE);
while (size != 0u)
while (size != 0U)
{
Cy_Crypto_Core_V2_BlockMov(base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_FF_LOAD0, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V2_RunAesInv(base);
@ -280,12 +285,12 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
}
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
Cy_Crypto_Core_WaitForReady(base);
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -295,7 +300,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
* Performs AES operation on a plain text with the Cipher Feedback Block method (CFB).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -314,10 +319,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cbc(CRYPTO_Type *base,
* The pointer to a source plain text. Must be 4-Byte aligned.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
@ -330,10 +336,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
{
uint32_t size = srcSize;
cy_en_crypto_status_t myResult = CY_CRYPTO_SIZE_NOT_X16;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SIZE_NOT_X16;
/* Check whether the data size is multiple of CY_CRYPTO_AES_BLOCK_SIZE */
if (0uL == (uint32_t)(size & (uint32_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1u)))
if (0UL == (uint32_t)(size & (uint32_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1U)))
{
Cy_Crypto_Core_V2_Aes_LoadEncKey(base, aesState);
@ -345,7 +351,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
if (CY_CRYPTO_ENCRYPT == dirMode)
{
while (size != 0u)
while (size != 0U)
{
Cy_Crypto_Core_V2_RunAes(base);
Cy_Crypto_Core_V2_BlockXor(base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_FF_LOAD0,
@ -357,7 +363,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
}
else
{
while (size != 0u)
while (size != 0U)
{
Cy_Crypto_Core_V2_RunAes(base);
Cy_Crypto_Core_V2_BlockMov(base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_FF_LOAD0, CY_CRYPTO_AES_BLOCK_SIZE);
@ -368,12 +374,12 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
}
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
Cy_Crypto_Core_WaitForReady(base);
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -383,7 +389,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
* Performs AES operation on a plain text using the counter method (CTR).
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param srcSize
* The size of a source plain text.
@ -405,13 +411,14 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Cfb(CRYPTO_Type *base,
* The pointer to a source plain text. Must be 4-Byte aligned.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
#define CY_CRYPTO_AES_CTR_CNT_POS (2u)
#define CY_CRYPTO_AES_CTR_CNT_POS (2U)
cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Ctr(CRYPTO_Type *base,
uint32_t srcSize,
uint32_t *srcOffset,
@ -421,28 +428,28 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Ctr(CRYPTO_Type *base,
uint8_t const *src,
cy_stc_crypto_aes_state_t *aesState)
{
uint32_t nonceCounter[4];
uint32_t blockCounter[4];
uint64_t counter;
uint32_t cnt;
uint32_t i;
nonceCounter[ 0] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[ 3], ivPtr[ 2], ivPtr[ 1], ivPtr[0]);
nonceCounter[ 1] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[ 7], ivPtr[ 6], ivPtr[ 5], ivPtr[4]);
nonceCounter[ 2] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[11], ivPtr[10], ivPtr[ 9], ivPtr[8]);
nonceCounter[ 3] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[15], ivPtr[14], ivPtr[13], ivPtr[12]);
blockCounter[ 0] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[ 3], ivPtr[ 2], ivPtr[ 1], ivPtr[0]);
blockCounter[ 1] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[ 7], ivPtr[ 6], ivPtr[ 5], ivPtr[4]);
blockCounter[ 2] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[11], ivPtr[10], ivPtr[ 9], ivPtr[8]);
blockCounter[ 3] = (uint32_t) CY_CRYPTO_MERGE_BYTES(ivPtr[15], ivPtr[14], ivPtr[13], ivPtr[12]);
counter = CY_SWAP_ENDIAN64(*(uint64_t*)(nonceCounter + CY_CRYPTO_AES_CTR_CNT_POS));
counter = CY_SWAP_ENDIAN64(*(uint64_t*)(blockCounter + CY_CRYPTO_AES_CTR_CNT_POS));
Cy_Crypto_Core_V2_Aes_LoadEncKey(base, aesState);
Cy_Crypto_Core_V2_FFContinue(base, CY_CRYPTO_V2_RB_FF_LOAD1, (const uint8_t *) &nonceCounter, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V2_FFContinue(base, CY_CRYPTO_V2_RB_FF_LOAD1, (const uint8_t *) &blockCounter, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V2_BlockMov (base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_FF_LOAD1, CY_CRYPTO_AES_BLOCK_SIZE);
/* CTR counter is placed into last 4 bytes of the Nonce block */
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 4u, (uint8_t)((counter >> 24u) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 3u, (uint8_t)((counter >> 16u) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 2u, (uint8_t)((counter >> 8u) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 1u, (uint8_t)((counter) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 4U, (uint8_t)((counter >> 24U) & 0xffU));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 3U, (uint8_t)((counter >> 16U) & 0xffU));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 2U, (uint8_t)((counter >> 8U) & 0xffU));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 1U, (uint8_t)((counter) & 0xffU));
Cy_Crypto_Core_V2_RunAes(base);
@ -457,19 +464,19 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Aes_Ctr(CRYPTO_Type *base,
/* Increment the nonce counter */
counter++;
*(uint64_t*)(nonceCounter + CY_CRYPTO_AES_CTR_CNT_POS) = CY_SWAP_ENDIAN64(counter);
*(uint64_t*)(blockCounter + CY_CRYPTO_AES_CTR_CNT_POS) = CY_SWAP_ENDIAN64(counter);
/* CTR counter is placed into last 4 bytes of the Nonce block */
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 4u, (uint8_t)((counter >> 24u) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 3u, (uint8_t)((counter >> 16u) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 2u, (uint8_t)((counter >> 8u) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 1u, (uint8_t)((counter) & 0xffu));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 4U, (uint8_t)((counter >> 24u) & 0xffU));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 3U, (uint8_t)((counter >> 16u) & 0xffU));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 2U, (uint8_t)((counter >> 8u) & 0xffU));
Cy_Crypto_Core_V2_RBSetByte(base, CY_CRYPTO_AES_BLOCK_SIZE - 1U, (uint8_t)((counter) & 0xffU));
Cy_Crypto_Core_V2_RBXor (base, CY_CRYPTO_AES_BLOCK_SIZE, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V2_RBStore(base, CY_CRYPTO_AES_BLOCK_SIZE, CY_CRYPTO_AES_BLOCK_SIZE);
}
Cy_Crypto_Core_V2_MemCpy(base, ivPtr, nonceCounter, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V2_MemCpy(base, ivPtr, blockCounter, CY_CRYPTO_AES_BLOCK_SIZE);
/* Save the reminder of the last non-complete block */
*srcOffset = (uint32_t)(srcSize % CY_CRYPTO_AES_BLOCK_SIZE);

35
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_cmac_v1.c
View File

@ -56,20 +56,20 @@ static void Cy_Crypto_Core_V1_Cmac_CalcSubKey(uint8_t *srcDstPtr)
{
int32_t i;
uint32_t c;
uint32_t msb = 0uL;
uint32_t msb = 0UL;
for (i = (int32_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1); i >= 0; i--)
for (i = (int32_t)((int32_t)CY_CRYPTO_AES_BLOCK_SIZE - 1); i >= 0; i--)
{
c = (uint32_t)srcDstPtr[i];
c = (c << 1u) | msb;
c = (c << 1U) | msb;
srcDstPtr[i] = (uint8_t) c;
msb = (c >> 8u) & 1uL;
msb = (c >> 8U) & 1UL;
}
if (0uL != msb)
if (0UL != msb)
{
/* Just one byte is valuable, the rest are zeros */
srcDstPtr[(uint8_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1u)] ^= CY_CRYPTO_CMAC_RB;
srcDstPtr[(uint8_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1U)] ^= CY_CRYPTO_CMAC_RB;
}
}
@ -110,13 +110,13 @@ void Cy_Crypto_Core_V1_Cmac_Init(cy_stc_crypto_v1_cmac_state_t* cmacState,
* Starts CMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the structure which stores the AES context.
*
* \param cmacState
* the pointer to the structure which stores the CMAC context.
* The pointer to the structure which stores the CMAC context.
*
*******************************************************************************/
void Cy_Crypto_Core_V1_Cmac_Start(CRYPTO_Type *base,
@ -127,7 +127,7 @@ void Cy_Crypto_Core_V1_Cmac_Start(CRYPTO_Type *base,
uint32_t *tempTmp = cmacState->temp;
/* Calculate the K1 sub-key */
Cy_Crypto_Core_V1_MemSet(base, (void*)tempTmp, 0u, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V1_MemSet(base, (void*)tempTmp, 0U, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V1_Aes_ProcessBlock(base, aesState, CY_CRYPTO_ENCRYPT, kTmp, tempTmp);
@ -141,7 +141,7 @@ void Cy_Crypto_Core_V1_Cmac_Start(CRYPTO_Type *base,
* Calculates CMAC on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* The pointer to the structure which stores the AES context.
@ -166,7 +166,7 @@ void Cy_Crypto_Core_V1_Cmac_Update(CRYPTO_Type *base,
uint32_t *tempBuff = cmacState->temp;
/* Clear the argument for XOR for the first block */
Cy_Crypto_Core_V1_MemSet(base, (void* )tempBuff, 0x00u, CY_CRYPTO_AES_BLOCK_SIZE);
Cy_Crypto_Core_V1_MemSet(base, (void* )tempBuff, 0x00U, CY_CRYPTO_AES_BLOCK_SIZE);
/* Process all blocks except last */
while (messageSize > CY_CRYPTO_AES_BLOCK_SIZE)
@ -197,7 +197,7 @@ void Cy_Crypto_Core_V1_Cmac_Update(CRYPTO_Type *base,
* Completes CMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param aesState
* the pointer to the structure which stores the AES context.
@ -226,11 +226,11 @@ void Cy_Crypto_Core_V1_Cmac_Finish(CRYPTO_Type *base,
Cy_Crypto_Core_V1_Cmac_CalcSubKey((uint8_t* )kPtrTmp);
/* Appended '1' bit to the end of message, followed by '0' */
*((uint8_t* )blockBuff + blockIdxTmp) = 0x80u;
*((uint8_t* )blockBuff + blockIdxTmp) = 0x80U;
/* Write zeros into the rest of the message */
copySize = CY_CRYPTO_AES_BLOCK_SIZE - 1u - blockIdxTmp;
Cy_Crypto_Core_V1_MemSet(base, ((uint8_t* )blockBuff + blockIdxTmp + 1), 0x00u, (uint16_t)copySize);
Cy_Crypto_Core_V1_MemSet(base, ((uint8_t* )blockBuff + blockIdxTmp + 1), 0x00U, (uint16_t)copySize);
}
Cy_Crypto_Core_V1_Aes_Xor(base, aesState, blockBuff, blockBuff, tempBuff);
@ -250,7 +250,7 @@ void Cy_Crypto_Core_V1_Cmac_Finish(CRYPTO_Type *base,
* on a message to produce message authentication code using AES.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param message
* The pointer to a source plain text. Must be 4-byte aligned.
@ -268,10 +268,11 @@ void Cy_Crypto_Core_V1_Cmac_Finish(CRYPTO_Type *base,
* The pointer to the calculated CMAC.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Cmac(CRYPTO_Type *base,

29
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_cmac_v2.c
View File

@ -66,20 +66,20 @@ static void Cy_Crypto_Core_V2_Cmac_CalcSubKey(uint8_t *srcDstPtr)
{
int32_t i;
uint32_t c;
uint32_t msb = 0uL;
uint32_t msb = 0UL;
for (i = (int32_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1); i >= 0; i--)
for (i = (int32_t)((int32_t)CY_CRYPTO_AES_BLOCK_SIZE - 1); i >= 0; i--)
{
c = (uint32_t)srcDstPtr[i];
c = (c << 1u) | msb;
c = (c << 1U) | msb;
srcDstPtr[i] = (uint8_t) c;
msb = (c >> 8u) & 1uL;
msb = (c >> 8U) & 1UL;
}
if (0uL != msb)
if (0UL != msb)
{
/* Just one byte is valuable, the rest are zeros */
srcDstPtr[(uint8_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1u)] ^= CY_CRYPTO_CMAC_RB;
srcDstPtr[(uint8_t)(CY_CRYPTO_AES_BLOCK_SIZE - 1U)] ^= CY_CRYPTO_CMAC_RB;
}
}
@ -105,7 +105,7 @@ void Cy_Crypto_Core_V2_Cmac_Init(cy_stc_crypto_v2_cmac_state_t* cmacState, uint8
* Starts CMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param cmacState
* the pointer to the structure which stores the CMAC context.
@ -114,7 +114,7 @@ void Cy_Crypto_Core_V2_Cmac_Init(cy_stc_crypto_v2_cmac_state_t* cmacState, uint8
void Cy_Crypto_Core_V2_Cmac_Start(CRYPTO_Type *base,
cy_stc_crypto_v2_cmac_state_t *cmacState)
{
cmacState->block_idx = 0u;
cmacState->block_idx = 0U;
/* Calculate the K1 sub-key */
Cy_Crypto_Core_V2_BlockXor(base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_BLOCK0,
@ -137,7 +137,7 @@ void Cy_Crypto_Core_V2_Cmac_Start(CRYPTO_Type *base,
* Calculates CMAC on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param cmacState
* The pointer to the structure which stores the CMAC context.
@ -177,7 +177,7 @@ void Cy_Crypto_Core_V2_Cmac_Update(CRYPTO_Type *base,
* Completes CMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param cmacState
* The pointer to the structure which stores the CMAC context.
@ -226,7 +226,7 @@ void Cy_Crypto_Core_V2_Cmac_Finish(CRYPTO_Type *base,
* on a message to produce message authentication code using AES.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param message
* The pointer to a source plain text. Must be 4-byte aligned.
@ -244,10 +244,11 @@ void Cy_Crypto_Core_V2_Cmac_Finish(CRYPTO_Type *base,
* The pointer to the calculated CMAC.
*
* \param aesState
* The pointer to the aesState structure which stores the AES context.
* The pointer to the AES state structure allocated by the user. The user
* must not modify anything in this structure.
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Cmac(CRYPTO_Type *base,
@ -259,7 +260,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Cmac(CRYPTO_Type *base,
cy_stc_crypto_aes_state_t *aesState)
{
/* Allocate space for the structure which stores the CMAC context */
cy_stc_crypto_v2_cmac_buffers_t cmacBuffersData;
cy_stc_crypto_v2_cmac_buffers_t cmacBuffersData = { 0 };
cy_stc_crypto_v2_cmac_buffers_t *cmacBuffers = &cmacBuffersData;
uint8_t *myK = cmacBuffers->k;

102
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_crc_v1.c
View File

@ -41,7 +41,7 @@
* Initializes CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param polynomial
* The polynomial (specified using 32 bits) used in the computing CRC.
@ -59,7 +59,7 @@
* Specifies a mask with which the LFSR32 register is XORed to produce a remainder.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_Init(CRYPTO_Type *base,
@ -85,7 +85,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_Init(CRYPTO_Type *base,
* (this bit is always assumed '1'). */
REG_CRYPTO_CRC_POL_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_POL_CTL_POLYNOMIAL, polynomial));
/*Specifies a mask with which the CRC_LFSR_CTL.LFSR32 register is XORed to produce a remainder.
/* Specifies a mask with which the CRC_LFSR_CTL.LFSR32 register is XORed to produce a remainder.
* The XOR is performed before remainder reversal. */
REG_CRYPTO_CRC_REM_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_REM_CTL_REM_XOR, remXor));
@ -99,7 +99,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_Init(CRYPTO_Type *base,
* Performs CRC calculation on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param crc
* The pointer to a computed CRC value. Must be 4-byte aligned.
@ -114,7 +114,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_Init(CRYPTO_Type *base,
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc(CRYPTO_Type *base,
@ -148,10 +148,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V1_Crc_CalcInit
****************************************************************************//**
*
* Initializes CRC calculation.
* Initializes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -163,19 +163,19 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc(CRYPTO_Type *base,
* The order in which data bytes are processed. 0 - MSB first; 1- LSB first.
*
* \param dataXor
* The byte mask for XORing data
* The byte mask for XORing data.
*
* \param remReverse
* A remainder reverse: 0 means the remainder is not reversed. 1 means reversed.
* A remainder reverse: 0 means the remainder is not reversed. 1 means it is reversed.
*
* \param remXor
* Specifies a mask with which the LFSR32 register is XORed to produce a remainder.
* Specifies the mask with which the LFSR32 register is XORed to produce a remainder.
*
* \param lfsrInitState
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcInit(CRYPTO_Type *base,
@ -187,30 +187,33 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcInit(CRYPTO_Type *base,
uint32_t remXor,
uint32_t lfsrInitState)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
/* Specifies the bit order in which a data Byte is processed
/* Specifies the bit order in which a data byte is processed
* (reversal is performed after XORing):
* '0': Most significant bit (bit 1) first.
* '1': Least significant bit (bit 0) first. */
REG_CRYPTO_CRC_CTL(base) = (uint32_t)( (_VAL2FLD(CRYPTO_CRC_CTL_DATA_REVERSE, dataReverse)) |
(_VAL2FLD(CRYPTO_CRC_CTL_REM_REVERSE, remReverse)) );
/* Specifies a byte mask with which each data byte is XORed.
/* Specifies the byte mask with which each data byte is XORed.
* The XOR is performed before data reversal. */
REG_CRYPTO_CRC_DATA_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_DATA_CTL_DATA_XOR, dataXor));
/* CRC polynomial. The polynomial is represented WITHOUT the high order bit
/* The CRC polynomial. The polynomial is represented WITHOUT the high-order bit
* (this bit is always assumed '1').
* CRC_POLYNOMIAL << (32 - CRC_BITLEN) */
REG_CRYPTO_CRC_POL_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_POL_CTL_POLYNOMIAL, polynomial << (32u - width)));
REG_CRYPTO_CRC_POL_CTL(base) =
(uint32_t)(_VAL2FLD(CRYPTO_CRC_POL_CTL_POLYNOMIAL, polynomial << (CY_CRYPTO_HW_REGS_WIDTH - width)));
/*Specifies a mask with which the CRC_LFSR_CTL.LFSR32 register is XORed to produce a remainder.
/*Specifies the mask with which the CRC_LFSR_CTL.LFSR32 register is XORed to produce a remainder.
* The XOR is performed before remainder reversal. */
REG_CRYPTO_CRC_REM_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_REM_CTL_REM_XOR, remXor << (32u - width)));
REG_CRYPTO_CRC_REM_CTL(base) =
(uint32_t)(_VAL2FLD(CRYPTO_CRC_REM_CTL_REM_XOR, remXor << (CY_CRYPTO_HW_REGS_WIDTH - width)));
/* A state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement CRC. */
REG_CRYPTO_CRC_LFSR_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_LFSR_CTL_LFSR32, lfsrInitState << (32u - width)));
/* The state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement the CRC. */
REG_CRYPTO_CRC_LFSR_CTL(base) =
(uint32_t)(_VAL2FLD(CRYPTO_CRC_LFSR_CTL_LFSR32, lfsrInitState << (CY_CRYPTO_HW_REGS_WIDTH - width)));
return (CY_CRYPTO_SUCCESS);
}
@ -219,10 +222,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcInit(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V1_Crc_CalcStart
****************************************************************************//**
*
* Prepare CRC calculation by setting an initial seeds value.
* Prepares the CRC calculation by setting an initial seed value.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -231,15 +234,16 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcInit(CRYPTO_Type *base,
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcStart(CRYPTO_Type *base, uint32_t width, uint32_t lfsrInitState)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
/* A state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement CRC. */
REG_CRYPTO_CRC_LFSR_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CRC_LFSR_CTL_LFSR32, lfsrInitState << (32u - width)));
/* The state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement the CRC. */
REG_CRYPTO_CRC_LFSR_CTL(base) =
(uint32_t)(_VAL2FLD(CRYPTO_CRC_LFSR_CTL_LFSR32, lfsrInitState << (CY_CRYPTO_HW_REGS_WIDTH - width)));
return (CY_CRYPTO_SUCCESS);
}
@ -248,10 +252,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcStart(CRYPTO_Type *base, uint32_
* Function Name: Cy_Crypto_Core_V1_Crc_CalcPartial
****************************************************************************//**
*
* Performs CRC calculation of a message part.
* Performs the CRC calculation of a message part.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data
* The pointer to the message whose CRC is being computed.
@ -260,19 +264,19 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcStart(CRYPTO_Type *base, uint32_
* The size of a message in bytes.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcPartial(CRYPTO_Type *base,
void const *data, uint32_t dataSize)
{
/* Fill the FIFO with the instruction parameters */
/* Fills the FIFO with the instruction parameters. */
Cy_Crypto_SetReg2Instr(base, (uint32_t)data, dataSize );
/* Issue the CRC instruction */
/* Issues the CRC instruction. */
Cy_Crypto_Run2ParamInstr(base, CY_CRYPTO_V1_CRC_OPC, CY_CRYPTO_RSRC0_SHIFT, CY_CRYPTO_RSRC4_SHIFT);
/* Wait until CRC instruction is complete */
/* Waits until the CRC instruction is complete. */
while(0uL != _FLD2VAL(CRYPTO_STATUS_CRC_BUSY, REG_CRYPTO_STATUS(base)))
{
}
@ -284,10 +288,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcPartial(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V1_Crc_CalcFinish
****************************************************************************//**
*
* Finalizes CRC calculation.
* Finalizes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -296,22 +300,22 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcPartial(CRYPTO_Type *base,
* The pointer to a computed CRC value. Must be 4-byte aligned.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcFinish(CRYPTO_Type *base, uint32_t width, uint32_t *crc)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
uint32_t calculatedCrc;
/* Copy the result from the CRC_REM_RESULT register */
/* Copies the result from the CRC_REM_RESULT register. */
calculatedCrc = (uint32_t)_FLD2VAL(CRYPTO_CRC_REM_RESULT_REM, REG_CRYPTO_CRC_REM_RESULT(base));
/* Note: Calculated CRC value is MSB aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
/* NOTE The calculated CRC value is MSB-aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
if (_FLD2VAL(CRYPTO_CRC_CTL_REM_REVERSE, REG_CRYPTO_CRC_CTL(base)) == 0u)
{
calculatedCrc = calculatedCrc >> (32u - width);
calculatedCrc = calculatedCrc >> (CY_CRYPTO_HW_REGS_WIDTH - width);
}
*crc = calculatedCrc;
@ -323,10 +327,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcFinish(CRYPTO_Type *base, uint32
* Function Name: Cy_Crypto_Core_V1_Crc_Calc
****************************************************************************//**
*
* Performs CRC calculation on a message.
* Performs the CRC calculation on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -341,7 +345,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_CalcFinish(CRYPTO_Type *base, uint32
* The size of a message in bytes.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_Calc(CRYPTO_Type *base,
@ -350,28 +354,28 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Crc_Calc(CRYPTO_Type *base,
void const *data,
uint32_t dataSize)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
uint32_t calculatedCrc;
/* Fill the FIFO with the instruction parameters */
/* Fills the FIFO with the instruction parameters. */
Cy_Crypto_SetReg2Instr(base, (uint32_t)data, dataSize );
/* Issue the CRC instruction */
/* Issues the CRC instruction. */
Cy_Crypto_Run2ParamInstr(base, CY_CRYPTO_V1_CRC_OPC, CY_CRYPTO_RSRC0_SHIFT, CY_CRYPTO_RSRC4_SHIFT);
/* Wait until CRC instruction is complete */
/* Waits until the CRC instruction is complete. */
while(0uL != _FLD2VAL(CRYPTO_STATUS_CRC_BUSY, REG_CRYPTO_STATUS(base)))
{
}
/* Copy the result from the CRC_REM_RESULT register */
/* Copies the result from the CRC_REM_RESULT register. */
calculatedCrc = (uint32_t)_FLD2VAL(CRYPTO_CRC_REM_RESULT_REM, REG_CRYPTO_CRC_REM_RESULT(base));
/* Note: Calculated CRC value is MSB aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
/* NOTE The calculated CRC value is MSB-aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
if (_FLD2VAL(CRYPTO_CRC_CTL_REM_REVERSE, REG_CRYPTO_CRC_CTL(base)) == 0u)
{
calculatedCrc = calculatedCrc >> (32u - width);
calculatedCrc = calculatedCrc >> (CY_CRYPTO_HW_REGS_WIDTH - width);
}
*crc = calculatedCrc;

103
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_crc_v2.c
View File

@ -42,7 +42,7 @@
* Initializes CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param polynomial
* The polynomial (specified using 32 bits) used in the computing CRC.
@ -60,7 +60,7 @@
* Specifies a mask with which the LFSR32 register is XORed to produce a remainder.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_Init(CRYPTO_Type *base,
@ -100,7 +100,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_Init(CRYPTO_Type *base,
* Performs CRC calculation on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param crc
* The pointer to a computed CRC value. Must be 4-byte aligned.
@ -115,7 +115,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_Init(CRYPTO_Type *base,
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc(CRYPTO_Type *base,
@ -146,10 +146,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V2_Crc_CalcInit
****************************************************************************//**
*
* Initializes CRC calculation.
* Initializes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -161,19 +161,19 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc(CRYPTO_Type *base,
* The order in which data bytes are processed. 0 - MSB first; 1- LSB first.
*
* \param dataXor
* The byte mask for XORing data
* The byte mask for XORing data.
*
* \param remReverse
* A remainder reverse: 0 means the remainder is not reversed. 1 means reversed.
* The remainder reverse: 0 means the remainder is not reversed; 1 means it is reversed.
*
* \param remXor
* Specifies a mask with which the LFSR32 register is XORed to produce a remainder.
* Specifies the mask with which the LFSR32 register is XORed to produce a remainder.
*
* \param lfsrInitState
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcInit(CRYPTO_Type *base,
@ -185,29 +185,32 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcInit(CRYPTO_Type *base,
uint32_t remXor,
uint32_t lfsrInitState)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
/* Specifies the bit order in which a data Byte is processed
/* Specifies the bit order in which a data byte is processed
* (reversal is performed after XORing):
* '0': Most significant bit (bit 1) first.
* '1': Least significant bit (bit 0) first. */
REG_CRYPTO_CRC_CTL(base) = (uint32_t)( (_VAL2FLD(CRYPTO_V2_CRC_CTL_DATA_REVERSE, dataReverse)) |
(_VAL2FLD(CRYPTO_V2_CRC_CTL_REM_REVERSE, remReverse)) );
/* Specifies a byte mask with which each data byte is XORed.
/* Specifies the byte mask with which each data byte is XORed.
* The XOR is performed before data reversal. */
REG_CRYPTO_CRC_DATA_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_V2_CRC_DATA_CTL_DATA_XOR, dataXor));
/* CRC polynomial. The polynomial is represented WITHOUT the high order bit
/* The CRC polynomial. The polynomial is represented WITHOUT the high-order bit
* (this bit is always assumed '1'). */
REG_CRYPTO_CRC_POL_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_V2_CRC_POL_CTL_POLYNOMIAL, polynomial << (32u - width)));
REG_CRYPTO_CRC_POL_CTL(base) =
(uint32_t)(_VAL2FLD(CRYPTO_V2_CRC_POL_CTL_POLYNOMIAL, polynomial << (CY_CRYPTO_HW_REGS_WIDTH - width)));
/*Specifies a mask with which the CRC_LFSR_CTL.LFSR32 register is XORed to produce a remainder.
/*Specifies the mask with which the CRC_LFSR_CTL.LFSR32 register is XORed to produce a remainder.
* The XOR is performed before remainder reversal. */
REG_CRYPTO_CRC_REM_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_V2_CRC_REM_CTL_REM_XOR, remXor << (32u - width)));
REG_CRYPTO_CRC_REM_CTL(base) =
(uint32_t)(_VAL2FLD(CRYPTO_V2_CRC_REM_CTL_REM_XOR, remXor << (CY_CRYPTO_HW_REGS_WIDTH - width)));
/* A state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement CRC. */
REG_CRYPTO_RESULT(base) = (uint32_t)(_VAL2FLD(CRYPTO_V2_RESULT_DATA, lfsrInitState << (32u - width)));
/* The state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement the CRC. */
REG_CRYPTO_RESULT(base) =
(uint32_t)(_VAL2FLD(CRYPTO_V2_RESULT_DATA, lfsrInitState << (CY_CRYPTO_HW_REGS_WIDTH - width)));
return (CY_CRYPTO_SUCCESS);
}
@ -216,10 +219,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcInit(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V2_Crc_CalcStart
****************************************************************************//**
*
* Prepares CRC calculation by setting an initial seeds value.
* Prepares the CRC calculation by setting an initial seed value.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -228,15 +231,15 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcInit(CRYPTO_Type *base,
* The initial state of the LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcStart(CRYPTO_Type *base, uint32_t width, uint32_t lfsrInitState)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
/* A state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement CRC. */
REG_CRYPTO_RESULT(base) = (uint32_t)(_VAL2FLD(CRYPTO_V2_RESULT_DATA, lfsrInitState << (32u - width)));
/* The state of 32-bit Linear Feedback Shift Registers (LFSR) used to implement the CRC. */
REG_CRYPTO_RESULT(base) = (uint32_t)(_VAL2FLD(CRYPTO_V2_RESULT_DATA, lfsrInitState << (CY_CRYPTO_HW_REGS_WIDTH - width)));
return (CY_CRYPTO_SUCCESS);
}
@ -245,10 +248,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcStart(CRYPTO_Type *base, uint32_
* Function Name: Cy_Crypto_Core_V2_Crc_CalcPartial
****************************************************************************//**
*
* Performs CRC calculation of a message part.
* Performs the CRC calculation of a message part.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data
* The pointer to the message whose CRC is being computed.
@ -257,19 +260,19 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcStart(CRYPTO_Type *base, uint32_
* The size of a message in bytes.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcPartial(CRYPTO_Type *base,
void const *data, uint32_t dataSize)
{
/* Fill the FIFO with the instruction parameters */
/* Fills the FIFO with the instruction parameters. */
Cy_Crypto_Core_V2_FFStart(base, CY_CRYPTO_V2_RB_FF_LOAD0, (uint8_t const *)data, dataSize);
/* Issue the CRC instruction */
/* Issues the CRC instruction. */
Cy_Crypto_Core_V2_Run(base, CY_CRYPTO_V2_CRC_OPC);
/* Wait until CRC instruction is complete */
/* Waits until the CRC instruction is complete. */
Cy_Crypto_Core_V2_Sync(base);
return (CY_CRYPTO_SUCCESS);
@ -279,10 +282,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcPartial(CRYPTO_Type *base,
* Function Name: Cy_Crypto_Core_V2_Crc_CalcFinish
****************************************************************************//**
*
* Finalizes CRC calculation.
* Finalizes the CRC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -291,22 +294,22 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcPartial(CRYPTO_Type *base,
* The pointer to a computed CRC value. Must be 4-byte aligned.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcFinish(CRYPTO_Type *base, uint32_t width, uint32_t *crc)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
uint32_t calculatedCrc;
/* Copy the result from the CRC_REM_RESULT register */
/* Copies the result from the CRC_REM_RESULT register. */
calculatedCrc = (uint32_t)_FLD2VAL(CRYPTO_V2_CRC_REM_RESULT_REM, REG_CRYPTO_CRC_REM_RESULT(base));
/* Note: Calculated CRC value is MSB aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
if (_FLD2VAL(CRYPTO_V2_CRC_CTL_REM_REVERSE, REG_CRYPTO_CRC_CTL(base)) == 0u)
/* NOTE The calculated CRC value is MSB-aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
if (_FLD2VAL(CRYPTO_V2_CRC_CTL_REM_REVERSE, REG_CRYPTO_CRC_CTL(base)) == 0U)
{
calculatedCrc = calculatedCrc >> (32u - width);
calculatedCrc = calculatedCrc >> (CY_CRYPTO_HW_REGS_WIDTH - width);
}
*crc = calculatedCrc;
@ -318,10 +321,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcFinish(CRYPTO_Type *base, uint32
* Function Name: Cy_Crypto_Core_V2_Crc_Calc
****************************************************************************//**
*
* Performs CRC calculation on a message.
* Performs the CRC calculation on a message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param width
* The CRC width in bits.
@ -336,7 +339,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_CalcFinish(CRYPTO_Type *base, uint32
* The size of a message in bytes.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_Calc(CRYPTO_Type *base,
@ -345,26 +348,26 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Crc_Calc(CRYPTO_Type *base,
void const *data,
uint32_t dataSize)
{
CY_ASSERT_L1((width >= 1) && (width <=32u));
CY_ASSERT_L1((width >= 1U) && (width <= CY_CRYPTO_HW_REGS_WIDTH));
uint32_t calculatedCrc;
/* Fill the FIFO with the instruction parameters */
/* Fills the FIFO with the instruction parameters. */
Cy_Crypto_Core_V2_FFStart(base, CY_CRYPTO_V2_RB_FF_LOAD0, (uint8_t const *)data, dataSize);
/* Issue the CRC instruction */
/* Issues the CRC instruction. */
Cy_Crypto_Core_V2_Run(base, CY_CRYPTO_V2_CRC_OPC);
/* Wait until CRC instruction is complete */
/* Waits until the CRC instruction is complete. */
Cy_Crypto_Core_V2_Sync(base);
/* Copy the result from the CRC_REM_RESULT register */
/* Copies the result from the CRC_REM_RESULT register. */
calculatedCrc = (uint32_t)_FLD2VAL(CRYPTO_V2_CRC_REM_RESULT_REM, REG_CRYPTO_CRC_REM_RESULT(base));
/* Note: Calculated CRC value is MSB aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
if (_FLD2VAL(CRYPTO_V2_CRC_CTL_REM_REVERSE, REG_CRYPTO_CRC_CTL(base)) == 0u)
/* NOTE The calculated CRC value is MSB-aligned and should be shifted WHEN CRC_DATA_REVERSE is zero. */
if (_FLD2VAL(CRYPTO_V2_CRC_CTL_REM_REVERSE, REG_CRYPTO_CRC_CTL(base)) == 0U)
{
calculatedCrc = calculatedCrc >> (32u - width);
calculatedCrc = calculatedCrc >> (CY_CRYPTO_HW_REGS_WIDTH - width);
}
*crc = calculatedCrc;

41
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_des_v1.c
View File

@ -91,7 +91,7 @@ static void Cy_Crypto_Core_V1_Des_ProcessBlock(CRYPTO_Type *base,
* srcBlock could overlap dstBlock.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* One of CRYPTO_ENCRYPT or CRYPTO_DECRYPT.
@ -145,7 +145,7 @@ static void Cy_Crypto_Core_V1_Des_ProcessBlock(CRYPTO_Type *base,
* This function is independent from the previous Crypto state.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -161,7 +161,7 @@ static void Cy_Crypto_Core_V1_Des_ProcessBlock(CRYPTO_Type *base,
* The pointer to a source block.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Des(CRYPTO_Type *base,
@ -176,12 +176,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Des(CRYPTO_Type *base,
cy_stc_crypto_des_buffers_t *desBuffers = (cy_stc_crypto_des_buffers_t *)REG_CRYPTO_MEM_BUFF(base);
/* Check weak keys */
for (i = 0u; i < CY_CRYPTO_DES_WEAK_KEY_COUNT; i++)
for (i = 0U; (i < CY_CRYPTO_DES_WEAK_KEY_COUNT) && (CY_CRYPTO_SUCCESS == status); i++)
{
if (memcmp(key, (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0)
if (Cy_Crypto_Core_V1_MemCmp(base, key, (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0U)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
}
}
@ -205,7 +204,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Des(CRYPTO_Type *base,
* This function is independent from the previous Crypto state.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -221,7 +220,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Des(CRYPTO_Type *base,
* The pointer to a source data block.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Tdes(CRYPTO_Type *base,
@ -236,30 +235,18 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Tdes(CRYPTO_Type *base,
cy_stc_crypto_des_buffers_t *desBuffers = (cy_stc_crypto_des_buffers_t *)REG_CRYPTO_MEM_BUFF(base);
/* Check weak keys */
for (i = 0u; i < CY_CRYPTO_DES_WEAK_KEY_COUNT; i++)
for (i = 0U; (i < CY_CRYPTO_DES_WEAK_KEY_COUNT) && (CY_CRYPTO_SUCCESS == status); i++)
{
if (memcmp(key, (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0)
for (uint32_t keynum=0U; (keynum < (CY_CRYPTO_TDES_KEY_SIZE / CY_CRYPTO_DES_KEY_SIZE)) && (CY_CRYPTO_SUCCESS == status); keynum++)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
}
if (memcmp(&(key[CY_CRYPTO_DES_KEY_BYTE_LENGTH]),
(uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
}
if (memcmp(&(key[2u * CY_CRYPTO_DES_KEY_BYTE_LENGTH]),
(uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
if (Cy_Crypto_Core_V1_MemCmp(base, &(key[keynum * CY_CRYPTO_DES_KEY_BYTE_LENGTH]), (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0U)
{
status = CY_CRYPTO_DES_WEAK_KEY;
}
}
}
Cy_Crypto_Core_V1_MemCpy(base, desBuffers->key, key, CY_CRYPTO_DES_KEY_BYTE_LENGTH * 3u);
Cy_Crypto_Core_V1_MemCpy(base, desBuffers->key, key, CY_CRYPTO_DES_KEY_BYTE_LENGTH * 3U);
Cy_Crypto_Core_V1_MemCpy(base, desBuffers->block0, src, CY_CRYPTO_DES_KEY_BYTE_LENGTH);
Cy_Crypto_Core_V1_Des_ProcessBlock(base, CY_CRYPTO_DES_MODE_TRIPLE, dirMode,

46
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_des_v2.c
View File

@ -36,8 +36,8 @@
#if (CPUSS_CRYPTO_DES == 1)
#define CY_CRYPTO_DES_WEAK_KEY_COUNT (16u)
#define CY_CRYPTO_DES_KEY_BYTE_LENGTH (8u)
#define CY_CRYPTO_DES_WEAK_KEY_COUNT (16U)
#define CY_CRYPTO_DES_KEY_BYTE_LENGTH (8U)
typedef enum
{
@ -78,7 +78,7 @@ static uint8_t const cy_desWeakKeys[CY_CRYPTO_DES_WEAK_KEY_COUNT][CY_CRYPTO_DES_
* This function is independent from the previous Crypto state.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -94,7 +94,7 @@ static uint8_t const cy_desWeakKeys[CY_CRYPTO_DES_WEAK_KEY_COUNT][CY_CRYPTO_DES_
* The pointer to a source data block.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Des(CRYPTO_Type *base,
@ -107,9 +107,9 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Des(CRYPTO_Type *base,
cy_en_crypto_status_t status = CY_CRYPTO_SUCCESS;
/* Check weak keys */
for (i = 0u; i < CY_CRYPTO_DES_WEAK_KEY_COUNT; i++)
for (i = 0U; i < CY_CRYPTO_DES_WEAK_KEY_COUNT; i++)
{
if (Cy_Crypto_Core_V2_MemCmp(base, key, (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0u)
if (Cy_Crypto_Core_V2_MemCmp(base, key, (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0U)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
@ -139,7 +139,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Des(CRYPTO_Type *base,
* This function is independent from the previous Crypto state.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dirMode
* Can be \ref CY_CRYPTO_ENCRYPT or \ref CY_CRYPTO_DECRYPT
@ -155,7 +155,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Des(CRYPTO_Type *base,
* The pointer to a source data block.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Tdes(CRYPTO_Type *base,
@ -168,36 +168,24 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Tdes(CRYPTO_Type *base,
cy_en_crypto_status_t status = CY_CRYPTO_SUCCESS;
/* Check weak keys */
for (i = 0u; i < CY_CRYPTO_DES_WEAK_KEY_COUNT; i++)
for (i = 0U; (i < CY_CRYPTO_DES_WEAK_KEY_COUNT) && (CY_CRYPTO_SUCCESS == status); i++)
{
if (Cy_Crypto_Core_V2_MemCmp(base, key, (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0u)
for (uint32_t keynum=0U; (keynum < (CY_CRYPTO_TDES_KEY_SIZE / CY_CRYPTO_DES_KEY_SIZE)) && (CY_CRYPTO_SUCCESS == status); keynum++)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
}
if (Cy_Crypto_Core_V2_MemCmp(base, &(key[CY_CRYPTO_DES_KEY_BYTE_LENGTH]),
(uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0u)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
}
if (Cy_Crypto_Core_V2_MemCmp(base, &(key[2u * CY_CRYPTO_DES_KEY_BYTE_LENGTH]),
(uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0u)
{
status = CY_CRYPTO_DES_WEAK_KEY;
break;
if (Cy_Crypto_Core_V2_MemCmp(base, &(key[keynum * CY_CRYPTO_DES_KEY_BYTE_LENGTH]), (uint8_t const *)cy_desWeakKeys[i], CY_CRYPTO_DES_KEY_BYTE_LENGTH) == 0U)
{
status = CY_CRYPTO_DES_WEAK_KEY;
}
}
}
/* Load keys */
Cy_Crypto_Core_V2_FFContinue(base, CY_CRYPTO_V2_RB_FF_LOAD0, key, CY_CRYPTO_DES_KEY_BYTE_LENGTH * 3u);
Cy_Crypto_Core_V2_BlockMov (base, CY_CRYPTO_V2_RB_KEY0, CY_CRYPTO_V2_RB_FF_LOAD0, CY_CRYPTO_DES_KEY_BYTE_LENGTH * 2u);
Cy_Crypto_Core_V2_FFContinue(base, CY_CRYPTO_V2_RB_FF_LOAD0, key, CY_CRYPTO_DES_KEY_BYTE_LENGTH * 3U);
Cy_Crypto_Core_V2_BlockMov (base, CY_CRYPTO_V2_RB_KEY0, CY_CRYPTO_V2_RB_FF_LOAD0, CY_CRYPTO_DES_KEY_BYTE_LENGTH * 2U);
Cy_Crypto_Core_V2_BlockMov (base, CY_CRYPTO_V2_RB_KEY1, CY_CRYPTO_V2_RB_FF_LOAD0, CY_CRYPTO_DES_KEY_BYTE_LENGTH);
Cy_Crypto_Core_V2_FFContinue(base, CY_CRYPTO_V2_RB_FF_LOAD0, src, CY_CRYPTO_DES_KEY_BYTE_LENGTH);
Cy_Crypto_Core_V2_FFStart (base, CY_CRYPTO_V2_RB_FF_STORE, dst, CY_CRYPTO_DES_KEY_BYTE_LENGTH);
Cy_Crypto_Core_V2_FFStart (base, CY_CRYPTO_V2_RB_FF_STORE, dst, CY_CRYPTO_DES_KEY_BYTE_LENGTH);
Cy_Crypto_Core_V2_BlockMov(base, CY_CRYPTO_V2_RB_BLOCK0, CY_CRYPTO_V2_RB_FF_LOAD0, CY_CRYPTO_DES_KEY_BYTE_LENGTH);
Cy_Crypto_Core_V2_Run(base, (uint32_t)((dirMode == CY_CRYPTO_ENCRYPT) ? (CY_CRYPTO_V2_TDES_OPC) : (CY_CRYPTO_V2_TDES_INV_OPC)));

839
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_ecc_domain_params.c
View File

@ -27,445 +27,444 @@
#include "cy_crypto_core_ecc.h"
#include "cy_syslib.h"
const cy_stc_crypto_ecc_dp_type eccDomainParams[];
/*******************************************************************************
* Function Name: Cy_Crypto_Core_ECC_GetCurveParams
****************************************************************************//**
*
* .
* Get curve domain parameters if this curve is supported.
*
* \param curveID
* See \ref cy_en_crypto_ecc_curve_id_t.
*
* \return status code. See \ref cy_stc_crypto_ecc_dp_type.
* \return
* Pointer to curve domain parameters. See \ref cy_stc_crypto_ecc_dp_type.
*
*******************************************************************************/
cy_stc_crypto_ecc_dp_type *Cy_Crypto_Core_ECC_GetCurveParams(cy_en_crypto_ecc_curve_id_t curveId)
{
cy_stc_crypto_ecc_dp_type *result = NULL;
/* P192 CURVE PARAMETERS */
CY_ALIGN(4) static const uint8_t eccP192Polynomial[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xfeu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
};
CY_ALIGN(4) static const uint8_t eccP192PolyBarrett[CY_CRYPTO_ECC_P192_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u
};
CY_ALIGN(4) static const uint8_t eccP192Order[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0x31u, 0x28u, 0xD2u, 0xB4u, 0xB1u, 0xC9u, 0x6Bu, 0x14u,
0x36u, 0xF8u, 0xDEu, 0x99u, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu
};
/* barrett_o: "1000000000000000000000000662107c9eb94364e4b2dd7cf" */
CY_ALIGN(4) static const uint8_t eccP192OrderBarrett[CY_CRYPTO_ECC_P192_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xcfu, 0xd7u, 0x2du, 0x4bu, 0x4eu, 0x36u, 0x94u, 0xebu,
0xc9u, 0x07u, 0x21u, 0x66u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u
};
/* base point x: "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012" */
CY_ALIGN(4) static const uint8_t eccP192BasePointX[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0x12u, 0x10u, 0xffu, 0x82u, 0xfdu, 0x0au, 0xffu, 0xf4u,
0x00u, 0x88u, 0xa1u, 0x43u, 0xebu, 0x20u, 0xbfu, 0x7cu,
0xf6u, 0x90u, 0x30u, 0xb0u, 0x0eu, 0xa8u, 0x8du, 0x18u
};
/* base point y: "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811" */
CY_ALIGN(4) static const uint8_t eccP192BasePointY[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0x11u, 0x48u, 0x79u, 0x1eu, 0xa1u, 0x77u, 0xf9u, 0x73u,
0xd5u, 0xcdu, 0x24u, 0x6bu, 0xedu, 0x11u, 0x10u, 0x63u,
0x78u, 0xdau, 0xc8u, 0xffu, 0x95u, 0x2bu, 0x19u, 0x07u
};
/* P224 CURVE PARAMETERS */
CY_ALIGN(4) static const uint8_t eccP224Polynomial[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu
};
CY_ALIGN(4) static const uint8_t eccP224PolyBarrett[CY_CRYPTO_ECC_P224_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x01u
};
CY_ALIGN(4) static const uint8_t eccP224Order[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x3Du, 0x2Au, 0x5Cu, 0x5Cu, 0x45u, 0x29u, 0xDDu, 0x13u,
0x3Eu, 0xF0u, 0xB8u, 0xE0u, 0xA2u, 0x16u, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu
};
/* barrett_o: "10000000000000000000000000000e95d1f470fc1ec22d6baa3a3d5c3" */
CY_ALIGN(4) static const uint8_t eccP224OrderBarrett[CY_CRYPTO_ECC_P224_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xc3u, 0xd5u, 0xa3u, 0xa3u, 0xbau, 0xd6u, 0x22u, 0xecu,
0xc1u, 0x0fu, 0x47u, 0x1fu, 0x5du, 0xe9u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x01u
};
/* Gx - base point x: "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21" */
CY_ALIGN(4) static const uint8_t eccP224BasePointX[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x21u, 0x1du, 0x5cu, 0x11u, 0xd6u, 0x80u, 0x32u, 0x34u,
0x22u, 0x11u, 0xc2u, 0x56u, 0xd3u, 0xc1u, 0x03u, 0x4au,
0xb9u, 0x90u, 0x13u, 0x32u, 0x7fu, 0xbfu, 0xb4u, 0x6bu,
0xbdu, 0x0cu, 0x0eu, 0xb7u
};
/* Gy - base point y: "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34" */
CY_ALIGN(4) static const uint8_t eccP224BasePointY[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x34u, 0x7eu, 0x00u, 0x85u, 0x99u, 0x81u, 0xd5u, 0x44u,
0x64u, 0x47u, 0x07u, 0x5au, 0xa0u, 0x75u, 0x43u, 0xcdu,
0xe6u, 0xdfu, 0x22u, 0x4cu, 0xfbu, 0x23u, 0xf7u, 0xb5u,
0x88u, 0x63u, 0x37u, 0xbdu
};
/* P256 CURVE PARAMETERS */
/* prime: "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF" */
CY_ALIGN(4) static const uint8_t eccP256Polynomial[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u, 0x00u, 0x00u, 0x00u, 0xffu, 0xffu, 0xffu, 0xffu
};
/* barrett_p: "100000000fffffffffffffffefffffffefffffffeffffffff0000000000000003" */
CY_ALIGN(4) static const uint8_t eccP256PolyBarrett[CY_CRYPTO_ECC_P256_BYTE_SIZE + 1u] =
{ /* pre-calculated! */
0x03u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0xffu, 0xffu, 0xffu, 0xffu, 0xfeu, 0xffu, 0xffu, 0xffu,
0xfeu, 0xffu, 0xffu, 0xffu, 0xfeu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u
};
/* order: "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551" */
CY_ALIGN(4) static const uint8_t eccP256Order[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0x51u, 0x25u, 0x63u, 0xfcu, 0xc2u, 0xcau, 0xb9u, 0xf3u,
0x84u, 0x9eu, 0x17u, 0xa7u, 0xadu, 0xfau, 0xe6u, 0xbcu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0x00u, 0x00u, 0x00u, 0x00u, 0xffu, 0xffu, 0xffu, 0xffu
};
/* barrett_o: 100000000fffffffffffffffeffffffff43190552df1a6c21012ffd85eedf9bfe" */
CY_ALIGN(4) static const uint8_t eccP256OrderBarrett[CY_CRYPTO_ECC_P256_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xfeu, 0x9bu, 0xdfu, 0xeeu, 0x85u, 0xfdu, 0x2fu, 0x01u,
0x21u, 0x6cu, 0x1au, 0xdfu, 0x52u, 0x05u, 0x19u, 0x43u,
0xffu, 0xffu, 0xffu, 0xffu, 0xfeu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u
};
/* base point x: "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296" */
CY_ALIGN(4) static const uint8_t eccP256BasePointX[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0x96u, 0xc2u, 0x98u, 0xd8u, 0x45u, 0x39u, 0xa1u, 0xf4u,
0xa0u, 0x33u, 0xebu, 0x2du, 0x81u, 0x7du, 0x03u, 0x77u,
0xf2u, 0x40u, 0xa4u, 0x63u, 0xe5u, 0xe6u, 0xbcu, 0xf8u,
0x47u, 0x42u, 0x2cu, 0xe1u, 0xf2u, 0xd1u, 0x17u, 0x6bu
};
/* base point y: "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5" */
CY_ALIGN(4) static const uint8_t eccP256BasePointY[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0xf5u, 0x51u, 0xbfu, 0x37u, 0x68u, 0x40u, 0xb6u, 0xcbu,
0xceu, 0x5eu, 0x31u, 0x6bu, 0x57u, 0x33u, 0xceu, 0x2bu,
0x16u, 0x9eu, 0x0fu, 0x7cu, 0x4au, 0xebu, 0xe7u, 0x8eu,
0x9bu, 0x7fu, 0x1au, 0xfeu, 0xe2u, 0x42u, 0xe3u, 0x4fu,
};
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF" */
CY_ALIGN(4) static const uint8_t eccP384Polynomial[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0xffu, 0xffu, 0xffu, 0xffu, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0xffu, 0xffu, 0xffu, 0xffu,
0xfeu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu
};
/* barrett_p: "1000000000000000000000000000000000000000000000000000000000000000100000000ffffffffffffffff00000001" */
CY_ALIGN(4) static const uint8_t eccP384PolyBarrett[CY_CRYPTO_ECC_P384_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0x01u, 0x00u, 0x00u, 0x00u, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u
};
/* order: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973" */
CY_ALIGN(4) static const uint8_t eccP384Order[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0x73u, 0x29u, 0xC5u, 0xCCu, 0x6Au, 0x19u, 0xECu, 0xECu,
0x7Au, 0xA7u, 0xB0u, 0x48u, 0xB2u, 0x0Du, 0x1Au, 0x58u,
0xDFu, 0x2Du, 0x37u, 0xF4u, 0x81u, 0x4Du, 0x63u, 0xC7u,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu
};
/* barrett_o: "1000000000000000000000000000000000000000000000000389cb27e0bc8d220a7e5f24db74f58851313e695333ad68d" */
CY_ALIGN(4) static const uint8_t eccP384OrderBarrett[CY_CRYPTO_ECC_P384_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0x8du, 0xd6u, 0x3au, 0x33u, 0x95u, 0xe6u, 0x13u, 0x13u,
0x85u, 0x58u, 0x4fu, 0xb7u, 0x4du, 0xf2u, 0xe5u, 0xa7u,
0x20u, 0xd2u, 0xc8u, 0x0bu, 0x7eu, 0xb2u, 0x9cu, 0x38u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x01u
};
/* base point x: "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7" */
CY_ALIGN(4) static const uint8_t eccP384BasePointX[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0xb7u, 0x0au, 0x76u, 0x72u, 0x38u, 0x5eu, 0x54u, 0x3au,
0x6cu, 0x29u, 0x55u, 0xbfu, 0x5du, 0xf2u, 0x02u, 0x55u,
0x38u, 0x2au, 0x54u, 0x82u, 0xe0u, 0x41u, 0xf7u, 0x59u,
0x98u, 0x9bu, 0xa7u, 0x8bu, 0x62u, 0x3bu, 0x1du, 0x6eu,
0x74u, 0xadu, 0x20u, 0xf3u, 0x1eu, 0xc7u, 0xb1u, 0x8eu,
0x37u, 0x05u, 0x8bu, 0xbeu, 0x22u, 0xcau, 0x87u, 0xaau
};
/* base point y: "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F" */
CY_ALIGN(4) static const uint8_t eccP384BasePointY[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0x5fu, 0x0eu, 0xeau, 0x90u, 0x7cu, 0x1du, 0x43u, 0x7au,
0x9du, 0x81u, 0x7eu, 0x1du, 0xceu, 0xb1u, 0x60u, 0x0au,
0xc0u, 0xb8u, 0xf0u, 0xb5u, 0x13u, 0x31u, 0xdau, 0xe9u,
0x7cu, 0x14u, 0x9au, 0x28u, 0xbdu, 0x1du, 0xf4u, 0xf8u,
0x29u, 0xdcu, 0x92u, 0x92u, 0xbfu, 0x98u, 0x9eu, 0x5du,
0x6fu, 0x2cu, 0x26u, 0x96u, 0x4au, 0xdeu, 0x17u, 0x36u
};
CY_ALIGN(4) static const uint8_t eccP521Polynomial[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0x01u
};
CY_ALIGN(4) static const uint8_t eccP521PolyBarrett[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{ /* pre-calculated */
0x01u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x02u
};
CY_ALIGN(4) static const uint8_t eccP521Order[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0x09u, 0x64u, 0x38u, 0x91u, 0x1Eu, 0xB7u, 0x6Fu, 0xBBu,
0xAEu, 0x47u, 0x9Cu, 0x89u, 0xB8u, 0xC9u, 0xB5u, 0x3Bu,
0xD0u, 0xA5u, 0x09u, 0xF7u, 0x48u, 0x01u, 0xCCu, 0x7Fu,
0x6Bu, 0x96u, 0x2Fu, 0xBFu, 0x83u, 0x87u, 0x86u, 0x51u,
0xFAu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu, 0xffu,
0xffu, 0x01u
};
/* barrett_o: "2000000000000000000000000000000000000000000000000000000000000000005ae79787c40d069948033feb708f65a2fc44a36477663b851449048e16ec79bf7" */
CY_ALIGN(4) static const uint8_t eccP521OrderBarrett[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{ /* pre-calculated */
0xf7u, 0x9bu, 0xc7u, 0x6eu, 0xe1u, 0x48u, 0x90u, 0x44u,
0x51u, 0xb8u, 0x63u, 0x76u, 0x47u, 0x36u, 0x4au, 0xc4u,
0x2fu, 0x5au, 0xf6u, 0x08u, 0xb7u, 0xfeu, 0x33u, 0x80u,
0x94u, 0x69u, 0xd0u, 0x40u, 0x7cu, 0x78u, 0x79u, 0xaeu,
0x05u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x02u
};
/* base point x: "00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66" */
CY_ALIGN(4) static const uint8_t eccP521BasePointX[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0x66u, 0xbdu, 0xe5u, 0xc2u, 0x31u, 0x7eu, 0x7eu, 0xf9u,
0x9bu, 0x42u, 0x6au, 0x85u, 0xc1u, 0xb3u, 0x48u, 0x33u,
0xdeu, 0xa8u, 0xffu, 0xa2u, 0x27u, 0xc1u, 0x1du, 0xfeu,
0x28u, 0x59u, 0xe7u, 0xefu, 0x77u, 0x5eu, 0x4bu, 0xa1u,
0xbau, 0x3du, 0x4du, 0x6bu, 0x60u, 0xafu, 0x28u, 0xf8u,
0x21u, 0xb5u, 0x3fu, 0x05u, 0x39u, 0x81u, 0x64u, 0x9cu,
0x42u, 0xb4u, 0x95u, 0x23u, 0x66u, 0xcbu, 0x3eu, 0x9eu,
0xcdu, 0xe9u, 0x04u, 0x04u, 0xb7u, 0x06u, 0x8eu, 0x85u,
0xc6u, 0x00u
};
/* base point y: "011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650" */
CY_ALIGN(4) static const uint8_t eccP521BasePointY[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0x50u, 0x66u, 0xd1u, 0x9fu, 0x76u, 0x94u, 0xbeu, 0x88u,
0x40u, 0xc2u, 0x72u, 0xa2u, 0x86u, 0x70u, 0x3cu, 0x35u,
0x61u, 0x07u, 0xadu, 0x3fu, 0x01u, 0xb9u, 0x50u, 0xc5u,
0x40u, 0x26u, 0xf4u, 0x5eu, 0x99u, 0x72u, 0xeeu, 0x97u,
0x2cu, 0x66u, 0x3eu, 0x27u, 0x17u, 0xbdu, 0xafu, 0x17u,
0x68u, 0x44u, 0x9bu, 0x57u, 0x49u, 0x44u, 0xf5u, 0x98u,
0xd9u, 0x1bu, 0x7du, 0x2cu, 0xb4u, 0x5fu, 0x8au, 0x5cu,
0x04u, 0xc0u, 0x3bu, 0x9au, 0x78u, 0x6au, 0x29u, 0x39u,
0x18u, 0x01u
};
static const cy_stc_crypto_ecc_dp_type eccDomainParams[] =
{
{
CY_CRYPTO_ECC_ECP_NONE,
0u,
NULL,
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
},
{
CY_CRYPTO_ECC_ECP_SECP192R1,
CY_CRYPTO_ECC_P192_SIZE,
"NIST P-192",
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG,
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF" */
eccP192Polynomial,
/* barrett_p: "1000000000000000000000000000000010000000000000001" */
eccP192PolyBarrett,
/* order: "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831" */
eccP192Order,
/* barrett_o: "1000000000000000000000000662107c9eb94364e4b2dd7cf" */
eccP192OrderBarrett,
/* base point x: "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012" */
eccP192BasePointX,
/* base point y: "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811" */
eccP192BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP224R1,
CY_CRYPTO_ECC_P224_SIZE,
"NIST P-224",
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG,
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001" */
eccP224Polynomial,
/* barrett_p: "100000000000000000000000000000000ffffffffffffffffffffffff" */
eccP224PolyBarrett,
/* order: "FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D" */
eccP224Order,
/* barrett_o: "10000000000000000000000000000e95d1f470fc1ec22d6baa3a3d5c3" */
eccP224OrderBarrett,
/* Gx - base point x: "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21" */
eccP224BasePointX,
/* Gy - base point y: "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34" */
eccP224BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP256R1,
CY_CRYPTO_ECC_P256_SIZE,
"NIST P-256",
CY_CRYPTO_NIST_P_BARRETT_RED_ALG,
/* prime: "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF" */
eccP256Polynomial,
/* barrett_p: "100000000fffffffffffffffefffffffefffffffeffffffff0000000000000003" */
eccP256PolyBarrett,
/* order: "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551" */
eccP256Order,
/* barrett_o: "100000000fffffffffffffffeffffffff43190552df1a6c21012ffd85eedf9bfe" */
eccP256OrderBarrett,
/* Gx - base point x: "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296" */
eccP256BasePointX,
/* Gy - base point y: "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5" */
eccP256BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP384R1,
CY_CRYPTO_ECC_P384_SIZE,
"NIST P-384",
CY_CRYPTO_NIST_P_BARRETT_RED_ALG,
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF" */
eccP384Polynomial,
/* barrett_p: "1000000000000000000000000000000000000000000000000000000000000000100000000ffffffffffffffff00000001" */
eccP384PolyBarrett,
/* order: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973" */
eccP384Order,
/* barrett_o: "1000000000000000000000000000000000000000000000000389cb27e0bc8d220a7e5f24db74f58851313e695333ad68d" */
eccP384OrderBarrett,
/* base point x: "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7" */
eccP384BasePointX,
/* base point y: "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F" */
eccP384BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP521R1,
CY_CRYPTO_ECC_P521_SIZE,
"NIST P-521",
/* Currently driver uses CY_CRYPTO_NIST_P_BARRETT_RED_ALG algorithm instead of
curve specific CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG */
CY_CRYPTO_NIST_P_BARRETT_RED_ALG,
/* prime: "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" */
eccP521Polynomial,
/* barrett_p: "20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" */
eccP521PolyBarrett,
/* order: "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409" */
eccP521Order,
/* barrett_o: "2000000000000000000000000000000000000000000000000000000000000000005ae79787c40d069948033feb708f65a2fc44a36477663b851449048e16ec79bf7" */
eccP521OrderBarrett,
/* base point x: "0C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66" */
eccP521BasePointX,
/* base point y: "11839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650" */
eccP521BasePointY
}
};
cy_stc_crypto_ecc_dp_type *tmpResult = NULL;
if ((curveId > CY_CRYPTO_ECC_ECP_NONE) && (curveId < CY_CRYPTO_ECC_ECP_CURVES_CNT))
{
result = (cy_stc_crypto_ecc_dp_type *)&eccDomainParams[curveId];
tmpResult = (cy_stc_crypto_ecc_dp_type *)&eccDomainParams[curveId];
}
return result;
return tmpResult;
}
/* P192 CURVE PARAMETERS */
CY_ALIGN(4) const uint8_t eccP192Polynomial[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
};
CY_ALIGN(4) const uint8_t eccP192PolyBarrett[CY_CRYPTO_ECC_P192_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01
};
CY_ALIGN(4) const uint8_t eccP192Order[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0x31, 0x28, 0xD2, 0xB4, 0xB1, 0xC9, 0x6B, 0x14,
0x36, 0xF8, 0xDE, 0x99, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
/* barrett_o: "1000000000000000000000000662107c9eb94364e4b2dd7cf" */
CY_ALIGN(4) const uint8_t eccP192OrderBarrett[CY_CRYPTO_ECC_P192_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xcf, 0xd7, 0x2d, 0x4b, 0x4e, 0x36, 0x94, 0xeb,
0xc9, 0x07, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01
};
/* base point x: "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012" */
CY_ALIGN(4) const uint8_t eccP192BasePointX[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0x12, 0x10, 0xff, 0x82, 0xfd, 0x0a, 0xff, 0xf4,
0x00, 0x88, 0xa1, 0x43, 0xeb, 0x20, 0xbf, 0x7c,
0xf6, 0x90, 0x30, 0xb0, 0x0e, 0xa8, 0x8d, 0x18
};
/* base point y: "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811" */
CY_ALIGN(4) const uint8_t eccP192BasePointY[CY_CRYPTO_ECC_P192_BYTE_SIZE] =
{
0x11, 0x48, 0x79, 0x1e, 0xa1, 0x77, 0xf9, 0x73,
0xd5, 0xcd, 0x24, 0x6b, 0xed, 0x11, 0x10, 0x63,
0x78, 0xda, 0xc8, 0xff, 0x95, 0x2b, 0x19, 0x07
};
/* P224 CURVE PARAMETERS */
CY_ALIGN(4) const uint8_t eccP224Polynomial[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff
};
CY_ALIGN(4) const uint8_t eccP224PolyBarrett[CY_CRYPTO_ECC_P224_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01
};
CY_ALIGN(4) const uint8_t eccP224Order[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x3D, 0x2A, 0x5C, 0x5C, 0x45, 0x29, 0xDD, 0x13,
0x3E, 0xF0, 0xB8, 0xE0, 0xA2, 0x16, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF
};
/* barrett_o: "10000000000000000000000000000e95d1f470fc1ec22d6baa3a3d5c3" */
CY_ALIGN(4) const uint8_t eccP224OrderBarrett[CY_CRYPTO_ECC_P224_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xc3, 0xd5, 0xa3, 0xa3, 0xba, 0xd6, 0x22, 0xec,
0xc1, 0x0f, 0x47, 0x1f, 0x5d, 0xe9, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01
};
/* Gx - base point x: "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21" */
CY_ALIGN(4) const uint8_t eccP224BasePointX[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x21, 0x1d, 0x5c, 0x11, 0xd6, 0x80, 0x32, 0x34,
0x22, 0x11, 0xc2, 0x56, 0xd3, 0xc1, 0x03, 0x4a,
0xb9, 0x90, 0x13, 0x32, 0x7f, 0xbf, 0xb4, 0x6b,
0xbd, 0x0c, 0x0e, 0xb7
};
/* Gy - base point y: "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34" */
CY_ALIGN(4) const uint8_t eccP224BasePointY[CY_CRYPTO_ECC_P224_BYTE_SIZE] =
{
0x34, 0x7e, 0x00, 0x85, 0x99, 0x81, 0xd5, 0x44,
0x64, 0x47, 0x07, 0x5a, 0xa0, 0x75, 0x43, 0xcd,
0xe6, 0xdf, 0x22, 0x4c, 0xfb, 0x23, 0xf7, 0xb5,
0x88, 0x63, 0x37, 0xbd
};
/* P256 CURVE PARAMETERS */
/* prime: "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF" */
CY_ALIGN(4) const uint8_t eccP256Polynomial[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
};
/* barrett_p: "100000000fffffffffffffffefffffffefffffffeffffffff0000000000000003" */
CY_ALIGN(4) const uint8_t eccP256PolyBarrett[CY_CRYPTO_ECC_P256_BYTE_SIZE + 1u] =
{ /* pre-calculated! */
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01
};
/* order: "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551" */
CY_ALIGN(4) const uint8_t eccP256Order[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0x51, 0x25, 0x63, 0xfc, 0xc2, 0xca, 0xb9, 0xf3,
0x84, 0x9e, 0x17, 0xa7, 0xad, 0xfa, 0xe6, 0xbc,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
};
/* barrett_o: 100000000fffffffffffffffeffffffff43190552df1a6c21012ffd85eedf9bfe" */
CY_ALIGN(4) const uint8_t eccP256OrderBarrett[CY_CRYPTO_ECC_P256_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0xfe, 0x9b, 0xdf, 0xee, 0x85, 0xfd, 0x2f, 0x01,
0x21, 0x6c, 0x1a, 0xdf, 0x52, 0x05, 0x19, 0x43,
0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01
};
/* base point x: "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296" */
CY_ALIGN(4) const uint8_t eccP256BasePointX[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0x96, 0xc2, 0x98, 0xd8, 0x45, 0x39, 0xa1, 0xf4,
0xa0, 0x33, 0xeb, 0x2d, 0x81, 0x7d, 0x03, 0x77,
0xf2, 0x40, 0xa4, 0x63, 0xe5, 0xe6, 0xbc, 0xf8,
0x47, 0x42, 0x2c, 0xe1, 0xf2, 0xd1, 0x17, 0x6b
};
/* base point y: "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5" */
CY_ALIGN(4) const uint8_t eccP256BasePointY[CY_CRYPTO_ECC_P256_BYTE_SIZE] =
{
0xf5, 0x51, 0xbf, 0x37, 0x68, 0x40, 0xb6, 0xcb,
0xce, 0x5e, 0x31, 0x6b, 0x57, 0x33, 0xce, 0x2b,
0x16, 0x9e, 0x0f, 0x7c, 0x4a, 0xeb, 0xe7, 0x8e,
0x9b, 0x7f, 0x1a, 0xfe, 0xe2, 0x42, 0xe3, 0x4f,
};
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF" */
CY_ALIGN(4) const uint8_t eccP384Polynomial[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
/* barrett_p: "1000000000000000000000000000000000000000000000000000000000000000100000000ffffffffffffffff00000001" */
CY_ALIGN(4) const uint8_t eccP384PolyBarrett[CY_CRYPTO_ECC_P384_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01
};
/* order: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973" */
CY_ALIGN(4) const uint8_t eccP384Order[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0x73, 0x29, 0xC5, 0xCC, 0x6A, 0x19, 0xEC, 0xEC,
0x7A, 0xA7, 0xB0, 0x48, 0xB2, 0x0D, 0x1A, 0x58,
0xDF, 0x2D, 0x37, 0xF4, 0x81, 0x4D, 0x63, 0xC7,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
/* barrett_o: "1000000000000000000000000000000000000000000000000389cb27e0bc8d220a7e5f24db74f58851313e695333ad68d" */
CY_ALIGN(4) const uint8_t eccP384OrderBarrett[CY_CRYPTO_ECC_P384_BYTE_SIZE + 1u] =
{ /* pre-calculated */
0x8d, 0xd6, 0x3a, 0x33, 0x95, 0xe6, 0x13, 0x13,
0x85, 0x58, 0x4f, 0xb7, 0x4d, 0xf2, 0xe5, 0xa7,
0x20, 0xd2, 0xc8, 0x0b, 0x7e, 0xb2, 0x9c, 0x38,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01
};
/* base point x: "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7" */
CY_ALIGN(4) const uint8_t eccP384BasePointX[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0xb7, 0x0a, 0x76, 0x72, 0x38, 0x5e, 0x54, 0x3a,
0x6c, 0x29, 0x55, 0xbf, 0x5d, 0xf2, 0x02, 0x55,
0x38, 0x2a, 0x54, 0x82, 0xe0, 0x41, 0xf7, 0x59,
0x98, 0x9b, 0xa7, 0x8b, 0x62, 0x3b, 0x1d, 0x6e,
0x74, 0xad, 0x20, 0xf3, 0x1e, 0xc7, 0xb1, 0x8e,
0x37, 0x05, 0x8b, 0xbe, 0x22, 0xca, 0x87, 0xaa
};
/* base point y: "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F" */
CY_ALIGN(4) const uint8_t eccP384BasePointY[CY_CRYPTO_ECC_P384_BYTE_SIZE] =
{
0x5f, 0x0e, 0xea, 0x90, 0x7c, 0x1d, 0x43, 0x7a,
0x9d, 0x81, 0x7e, 0x1d, 0xce, 0xb1, 0x60, 0x0a,
0xc0, 0xb8, 0xf0, 0xb5, 0x13, 0x31, 0xda, 0xe9,
0x7c, 0x14, 0x9a, 0x28, 0xbd, 0x1d, 0xf4, 0xf8,
0x29, 0xdc, 0x92, 0x92, 0xbf, 0x98, 0x9e, 0x5d,
0x6f, 0x2c, 0x26, 0x96, 0x4a, 0xde, 0x17, 0x36
};
CY_ALIGN(4) const uint8_t eccP521Polynomial[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x01
};
CY_ALIGN(4) const uint8_t eccP521PolyBarrett[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{ /* pre-calculated */
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x02
};
CY_ALIGN(4) const uint8_t eccP521Order[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0x09, 0x64, 0x38, 0x91, 0x1E, 0xB7, 0x6F, 0xBB,
0xAE, 0x47, 0x9C, 0x89, 0xB8, 0xC9, 0xB5, 0x3B,
0xD0, 0xA5, 0x09, 0xF7, 0x48, 0x01, 0xCC, 0x7F,
0x6B, 0x96, 0x2F, 0xBF, 0x83, 0x87, 0x86, 0x51,
0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x01
};
/* barrett_o: "2000000000000000000000000000000000000000000000000000000000000000005ae79787c40d069948033feb708f65a2fc44a36477663b851449048e16ec79bf7" */
CY_ALIGN(4) const uint8_t eccP521OrderBarrett[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{ /* pre-calculated */
0xf7, 0x9b, 0xc7, 0x6e, 0xe1, 0x48, 0x90, 0x44,
0x51, 0xb8, 0x63, 0x76, 0x47, 0x36, 0x4a, 0xc4,
0x2f, 0x5a, 0xf6, 0x08, 0xb7, 0xfe, 0x33, 0x80,
0x94, 0x69, 0xd0, 0x40, 0x7c, 0x78, 0x79, 0xae,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x02
};
/* base point x: "00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66" */
CY_ALIGN(4) const uint8_t eccP521BasePointX[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0x66, 0xbd, 0xe5, 0xc2, 0x31, 0x7e, 0x7e, 0xf9,
0x9b, 0x42, 0x6a, 0x85, 0xc1, 0xb3, 0x48, 0x33,
0xde, 0xa8, 0xff, 0xa2, 0x27, 0xc1, 0x1d, 0xfe,
0x28, 0x59, 0xe7, 0xef, 0x77, 0x5e, 0x4b, 0xa1,
0xba, 0x3d, 0x4d, 0x6b, 0x60, 0xaf, 0x28, 0xf8,
0x21, 0xb5, 0x3f, 0x05, 0x39, 0x81, 0x64, 0x9c,
0x42, 0xb4, 0x95, 0x23, 0x66, 0xcb, 0x3e, 0x9e,
0xcd, 0xe9, 0x04, 0x04, 0xb7, 0x06, 0x8e, 0x85,
0xc6, 0x00
};
/* base point y: "011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650" */
CY_ALIGN(4) const uint8_t eccP521BasePointY[CY_CRYPTO_ECC_P521_BYTE_SIZE] =
{
0x50, 0x66, 0xd1, 0x9f, 0x76, 0x94, 0xbe, 0x88,
0x40, 0xc2, 0x72, 0xa2, 0x86, 0x70, 0x3c, 0x35,
0x61, 0x07, 0xad, 0x3f, 0x01, 0xb9, 0x50, 0xc5,
0x40, 0x26, 0xf4, 0x5e, 0x99, 0x72, 0xee, 0x97,
0x2c, 0x66, 0x3e, 0x27, 0x17, 0xbd, 0xaf, 0x17,
0x68, 0x44, 0x9b, 0x57, 0x49, 0x44, 0xf5, 0x98,
0xd9, 0x1b, 0x7d, 0x2c, 0xb4, 0x5f, 0x8a, 0x5c,
0x04, 0xc0, 0x3b, 0x9a, 0x78, 0x6a, 0x29, 0x39,
0x18, 0x01
};
const cy_stc_crypto_ecc_dp_type eccDomainParams[] =
{
{
CY_CRYPTO_ECC_ECP_NONE,
0,
NULL,
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
},
{
CY_CRYPTO_ECC_ECP_SECP192R1,
CY_CRYPTO_ECC_P192_SIZE,
"NIST P-192",
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG,
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF" */
eccP192Polynomial,
/* barrett_p: "1000000000000000000000000000000010000000000000001" */
eccP192PolyBarrett,
/* order: "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831" */
eccP192Order,
/* barrett_o: "1000000000000000000000000662107c9eb94364e4b2dd7cf" */
eccP192OrderBarrett,
/* base point x: "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012" */
eccP192BasePointX,
/* base point y: "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811" */
eccP192BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP224R1,
CY_CRYPTO_ECC_P224_SIZE,
"NIST P-224",
CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG,
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001" */
eccP224Polynomial,
/* barrett_p: "100000000000000000000000000000000ffffffffffffffffffffffff" */
eccP224PolyBarrett,
/* order: "FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D" */
eccP224Order,
/* barrett_o: "10000000000000000000000000000e95d1f470fc1ec22d6baa3a3d5c3" */
eccP224OrderBarrett,
/* Gx - base point x: "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21" */
eccP224BasePointX,
/* Gy - base point y: "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34" */
eccP224BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP256R1,
CY_CRYPTO_ECC_P256_SIZE,
"NIST P-256",
CY_CRYPTO_NIST_P_BARRETT_RED_ALG,
/* prime: "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF" */
eccP256Polynomial,
/* barrett_p: "100000000fffffffffffffffefffffffefffffffeffffffff0000000000000003" */
eccP256PolyBarrett,
/* order: "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551" */
eccP256Order,
/* barrett_o: "100000000fffffffffffffffeffffffff43190552df1a6c21012ffd85eedf9bfe" */
eccP256OrderBarrett,
/* Gx - base point x: "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296" */
eccP256BasePointX,
/* Gy - base point y: "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5" */
eccP256BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP384R1,
CY_CRYPTO_ECC_P384_SIZE,
"NIST P-384",
CY_CRYPTO_NIST_P_BARRETT_RED_ALG,
/* prime: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF" */
eccP384Polynomial,
/* barrett_p: "1000000000000000000000000000000000000000000000000000000000000000100000000ffffffffffffffff00000001" */
eccP384PolyBarrett,
/* order: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973" */
eccP384Order,
/* barrett_o: "1000000000000000000000000000000000000000000000000389cb27e0bc8d220a7e5f24db74f58851313e695333ad68d" */
eccP384OrderBarrett,
/* base point x: "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7" */
eccP384BasePointX,
/* base point y: "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F" */
eccP384BasePointY
},
{
CY_CRYPTO_ECC_ECP_SECP521R1,
CY_CRYPTO_ECC_P521_SIZE,
"NIST P-521",
/* Currently driver uses CY_CRYPTO_NIST_P_BARRETT_RED_ALG algorithm instead of
curve specific CY_CRYPTO_NIST_P_CURVE_SPECIFIC_RED_ALG */
CY_CRYPTO_NIST_P_BARRETT_RED_ALG,
/* prime: "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" */
eccP521Polynomial,
/* barrett_p: "20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" */
eccP521PolyBarrett,
/* order: "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409" */
eccP521Order,
/* barrett_o: "2000000000000000000000000000000000000000000000000000000000000000005ae79787c40d069948033feb708f65a2fc44a36477663b851449048e16ec79bf7" */
eccP521OrderBarrett,
/* base point x: "0C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66" */
eccP521BasePointX,
/* base point y: "11839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650" */
eccP521BasePointY
}
};
/* [] END OF FILE */

189
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_ecc_ecdsa.c
View File

@ -31,16 +31,6 @@
#include <stdbool.h>
#define ECC_ECDSA_DEBUG 0
#if ECC_ECDSA_DEBUG
#include "cy_crypto_core_my_support.h"
#ifndef Tb_PrintStr
#include <stdio.h>
#define Tb_PrintStr(s) printf("%s\n", s)
#endif
#endif
/*******************************************************************************
* Function Name: Cy_Crypto_Core_ECC_SignHash
@ -70,22 +60,22 @@
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8_t *hash, uint32_t hashlen, uint8_t *sig,
cy_stc_crypto_ecc_key *key, uint8_t *messageKey)
const cy_stc_crypto_ecc_key *key, const uint8_t *messageKey)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
cy_stc_crypto_ecc_key ephKey;
uint8_t myKGX[CY_CRYPTO_ECC_MAX_BYTE_SIZE];
uint8_t myKGY[CY_CRYPTO_ECC_MAX_BYTE_SIZE];
const cy_stc_crypto_ecc_dp_type *eccDp;
uint32_t mallocMask = 0;
uint32_t mallocMask = 0U;
uint32_t bitsize;
/* NULL parameters checking */
if ((hash != NULL) && (sig != NULL) && (key != NULL) && (messageKey != NULL))
{
myResult = CY_CRYPTO_NOT_SUPPORTED;
tmpResult = CY_CRYPTO_NOT_SUPPORTED;
eccDp = Cy_Crypto_Core_ECC_GetCurveParams(key->curveID);
@ -93,44 +83,27 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
{
bitsize = eccDp->size;
#if ECC_ECDSA_DEBUG
Tb_PrintStr("\necc_sign_hash() for ");
Tb_PrintStr(eccDp->name);
Tb_PrintStr("\n");
#endif /* ECC_ECDSA_DEBUG */
/* make ephemeral key pair */
ephKey.pubkey.x = myKGX;
ephKey.pubkey.y = myKGY;
myResult = Cy_Crypto_Core_ECC_MakePublicKey(base, key->curveID, messageKey, &ephKey);
tmpResult = Cy_Crypto_Core_ECC_MakePublicKey(base, key->curveID, messageKey, &ephKey);
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = CY_CRYPTO_BAD_PARAMS;
tmpResult = CY_CRYPTO_BAD_PARAMS;
int dividend = 0; /* for whatever reason Crypto_EC_DivMod only works if dividend is in register 0 */
int p_temp = 8;
int p_r = 9;
int p_s = 10;
int p_d = 11;
#if ECC_ECDSA_DEBUG
Tb_PrintStr("%10s: \t", "hash");
Crypto_PrintNumber((uint8_t *)hash, hashlen);
Tb_PrintStr("%10s: \t", "k");
Crypto_PrintNumber(messageKey, CY_CRYPTO_BYTE_SIZE_OF_BITS(bitsize));
Tb_PrintStr("%10s: \t", "x1");
Crypto_PrintNumber((uint8_t *)ephKey.pubkey.x, CY_CRYPTO_BYTE_SIZE_OF_BITS(bitsize));
#endif /* ECC_ECDSA_DEBUG */
uint32_t dividend = 0U; /* for whatever reason Crypto_EC_DivMod only works if dividend is in register 0 */
uint32_t p_temp = 8U;
uint32_t p_r = 9U;
uint32_t p_s = 10U;
uint32_t p_d = 11U;
/* load values needed for reduction modulo order of the base point */
CY_CRYPTO_VU_ALLOC_MEM (base, VR_P, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, (uint8_t *)eccDp->order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, VR_BARRETT, bitsize + 1);
CY_CRYPTO_VU_ALLOC_MEM (base, VR_BARRETT, bitsize + 1U);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, (uint8_t *)eccDp->barrett_o, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_r, bitsize);
@ -140,7 +113,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
if (!Cy_Crypto_Core_Vu_IsRegZero(base, p_r))
{
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
CY_CRYPTO_VU_ALLOC_MEM (base, p_d, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_s, bitsize);
@ -162,15 +135,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
/* r = x1 mod n */
Cy_Crypto_Core_Vu_GetMemValue (base, sig, p_r, bitsize);
#if ECC_ECDSA_DEBUG
Tb_PrintStr("x1 after reduction modulo order: ");
Crypto_RegMemNumberPrint(p_r);
#endif /* ECC_ECDSA_DEBUG */
if (Cy_Crypto_Core_Vu_IsRegZero(base, p_r))
{
/* R is zero!!! */
myResult = CY_CRYPTO_HW_ERROR;
tmpResult = CY_CRYPTO_HW_ERROR;
}
}
else
@ -180,14 +148,14 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
Cy_Crypto_Core_MemCpy(base, sig, ephKey.pubkey.x, (uint16_t)CY_CRYPTO_BYTE_SIZE_OF_BITS(bitsize));
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* find s = (e + d*r)/k */
/* load signing private key */
Cy_Crypto_Core_Vu_SetMemValue (base, p_d, (uint8_t *)key->k, bitsize);
/* use barrett reduction algorithm for operations modulo n (order of the base point) */
/* use Barrett reduction algorithm for operations modulo n (order of the base point) */
Cy_Crypto_Core_EC_NistP_SetRedAlg(CY_CRYPTO_NIST_P_BARRETT_RED_ALG);
/* d*r mod n */
@ -202,7 +170,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
}
else
{
Cy_Crypto_Core_Vu_SetMemValue (base, p_d, (uint8_t *)hash, hashlen * 8);
Cy_Crypto_Core_Vu_SetMemValue (base, p_d, (uint8_t *)hash, hashlen * 8U);
}
Cy_Crypto_Core_Vu_SetMemValue (base, p_r, messageKey, bitsize);
@ -226,14 +194,8 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
}
else
{
myResult = CY_CRYPTO_HW_ERROR;
tmpResult = CY_CRYPTO_HW_ERROR;
}
#if ECC_ECDSA_DEBUG
Crypto_PrintRegister(p_r, "k");
Crypto_PrintRegister(p_s, "(e+d*r)/k");
#endif /* ECC_ECDSA_DEBUG */
}
}
@ -243,7 +205,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
}
}
return (myResult);
return (tmpResult);
}
@ -276,47 +238,40 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_SignHash(CRYPTO_Type *base, const uint8
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
const uint8_t *sig, const uint8_t *hash, uint32_t hashlen,
uint8_t *stat, cy_stc_crypto_ecc_key *key)
uint8_t *stat, const cy_stc_crypto_ecc_key *key)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
const cy_stc_crypto_ecc_dp_type *eccDp;
uint32_t bitsize;
uint32_t mallocMask = 0;
uint32_t mallocMask = 0U;
/* NULL parameters checking */
if ((sig != NULL) && (hash != NULL) && (stat != NULL) && (key != NULL))
{
myResult = CY_CRYPTO_NOT_SUPPORTED;
tmpResult = CY_CRYPTO_NOT_SUPPORTED;
eccDp = Cy_Crypto_Core_ECC_GetCurveParams(key->curveID);
if (eccDp != NULL)
{
#if ECC_ECDSA_DEBUG
Tb_PrintStr("\necc_verify_hash() for ");
Tb_PrintStr((char *)eccDp->name);
Tb_PrintStr("\n");
#endif /* ECC_ECDSA_DEBUG */
bitsize = eccDp->size;
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
int dividend = 0; /* for whatever reason Crypto_EC_DivMod only works if dividend is in register 0 */
int p_r = 4;
int p_s = 5;
int p_u1 = 6;
int p_u2 = 7;
int p_o = 8;
int p_gx = 9;
int p_gy = 10;
int p_qx = 11;
int p_qy = 12;
uint32_t dividend = 0u; /* for whatever reason Crypto_EC_DivMod only works if dividend is in register 0 */
uint32_t p_r = 4U;
uint32_t p_s = 5U;
uint32_t p_u1 = 6U;
uint32_t p_u2 = 7U;
uint32_t p_o = 8U;
uint32_t p_gx = 9U;
uint32_t p_gy = 10U;
uint32_t p_qx = 11U;
uint32_t p_qy = 12U;
/* use barrett reduction algorithm for operations modulo n (order of the base point) */
/* use Barrett reduction algorithm for operations modulo n (order of the base point) */
Cy_Crypto_Core_EC_NistP_SetRedAlg(CY_CRYPTO_NIST_P_BARRETT_RED_ALG);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
@ -325,13 +280,13 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
CY_CRYPTO_VU_ALLOC_MEM (base, VR_P, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, (uint8_t *)eccDp->order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, VR_BARRETT, bitsize + 1);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, (uint8_t *)eccDp->barrett_o, bitsize + 1);
CY_CRYPTO_VU_ALLOC_MEM (base, VR_BARRETT, bitsize + 1U);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, (uint8_t *)eccDp->barrett_o, bitsize + 1U);
/*******************************************************************************/
/* check that R and S are within the valid range, i.e. 0 < R < n and 0 < S < n */
CY_CRYPTO_VU_ALLOC_MEM (base, p_r, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_s, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_r, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_s, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_r, (uint8_t *)sig, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_s, (uint8_t *)&sig[CY_CRYPTO_BYTE_SIZE_OF_BITS(bitsize)], bitsize);
@ -342,28 +297,28 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
if (Cy_Crypto_Core_Vu_IsRegZero(base, p_r))
{
/* R is zero!!! */
myResult = CY_CRYPTO_BAD_PARAMS;
tmpResult = CY_CRYPTO_BAD_PARAMS;
}
if (!Cy_Crypto_Core_Vu_IsRegLess(base, p_r, VR_P))
{
/* R is not less than n!!! */
myResult = CY_CRYPTO_BAD_PARAMS;
tmpResult = CY_CRYPTO_BAD_PARAMS;
}
if (Cy_Crypto_Core_Vu_IsRegZero(base, p_s))
{
/* S is zero!!! */
myResult = CY_CRYPTO_BAD_PARAMS;
tmpResult = CY_CRYPTO_BAD_PARAMS;
}
if (!Cy_Crypto_Core_Vu_IsRegLess(base, p_s, VR_P))
{
/* S is not less than n!!! */
myResult = CY_CRYPTO_BAD_PARAMS;
tmpResult = CY_CRYPTO_BAD_PARAMS;
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
CY_CRYPTO_VU_ALLOC_MEM (base, dividend, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_o, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_o, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_u1, bitsize);
CY_CRYPTO_VU_ALLOC_MEM (base, p_u2, bitsize);
@ -386,41 +341,25 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
}
else
{
Cy_Crypto_Core_Vu_SetMemValue (base, p_u1, (uint8_t *)hash, hashlen * 8);
Cy_Crypto_Core_Vu_SetMemValue (base, p_u1, (uint8_t *)hash, hashlen * 8U);
}
#if ECC_ECDSA_DEBUG
Crypto_PrintRegister(p_u1, "hash");
Crypto_PrintRegister(p_r, "R");
Crypto_PrintRegister(p_s, "S");
Tb_PrintStr("\n");
#endif /* ECC_ECDSA_DEBUG */
/* w = s^-1 mod n */
CY_CRYPTO_VU_SET_TO_ONE(base, dividend);
Cy_Crypto_Core_EC_DivMod(base, p_s, dividend, p_s, bitsize);
#if ECC_ECDSA_DEBUG
Crypto_PrintRegister(p_s, "w");
#endif /* ECC_ECDSA_DEBUG */
/* u1 = e*w mod n */
Cy_Crypto_Core_EC_MulMod(base, p_u1, p_u1, p_s, bitsize);
/* u2 = r*w mod n */
Cy_Crypto_Core_EC_MulMod(base, p_u2, p_r, p_s, bitsize);
#if ECC_ECDSA_DEBUG
Crypto_PrintRegister(p_u1, "u1");
Crypto_PrintRegister(p_u2, "u2");
#endif /* ECC_ECDSA_DEBUG */
Cy_Crypto_Core_EC_MulMod(base, p_u2, p_r, p_s, bitsize);
/* Initialize point multiplication */
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
/* load prime, order and barrett coefficient */
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, (uint8_t *)eccDp->prime, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_o, (uint8_t *)eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, (uint8_t *)eccDp->barrett_p, bitsize + 1);
/* load prime, order and Barrett coefficient */
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, (uint8_t *)eccDp->prime, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_o, (uint8_t *)eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, (uint8_t *)eccDp->barrett_p, bitsize + 1U);
/* load base Point G */
Cy_Crypto_Core_Vu_SetMemValue (base, p_gx, (uint8_t *)eccDp->Gx, bitsize);
@ -439,40 +378,22 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
/* u2 * Qa */
Cy_Crypto_Core_EC_NistP_PointMul(base, p_qx, p_qy, p_u2, p_o, bitsize);
#if ECC_ECDSA_DEBUG
Tb_PrintStr("u1 * G: \n");
Crypto_PrintRegister(p_gx, " u1*G(x)");
Crypto_PrintRegister(p_gy, " u1*G(y)");
Tb_PrintStr("u2 * Q: \n");
Crypto_PrintRegister(p_qx, " u2*Q(x)");
Crypto_PrintRegister(p_qy, " u2*Q(x)");
#endif /* ECC_ECDSA_DEBUG */
/* P = u1 * G + u2 * Qa. Only Px is needed */
Cy_Crypto_Core_EC_SubMod(base, dividend, p_qy, p_gy); /* (y2-y1) */
Cy_Crypto_Core_EC_SubMod(base, p_s, p_qx, p_gx); /* (x2-x1) */
Cy_Crypto_Core_EC_DivMod(base, p_s, dividend, p_s, bitsize); /* s = (y2-y1)/(x2-x1) */
#if ECC_ECDSA_DEBUG
Tb_PrintStr("Point addition: \n");
Crypto_PrintRegister(p_s, "s");
#endif /* ECC_ECDSA_DEBUG */
Cy_Crypto_Core_EC_SquareMod (base, p_s, p_s, bitsize); /* s^2 */
Cy_Crypto_Core_EC_SubMod (base, p_s, p_s, p_gx); /* s^2 - x1 */
Cy_Crypto_Core_EC_SubMod (base, p_s, p_s, p_qx); /* s^2 - x1 - x2 which is Px mod n */
#if ECC_ECDSA_DEBUG
Crypto_PrintRegister(p_s, "px");
#endif /* ECC_ECDSA_DEBUG */
if (Cy_Crypto_Core_Vu_IsRegEqual(base, p_s, p_r))
{
*stat = 1;
*stat = 1u;
}
else
{
*stat = 0;
*stat = 0u;
}
}
@ -481,7 +402,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_VerifyHash(CRYPTO_Type *base,
}
}
return (myResult);
return (tmpResult);
}

512
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_ecc_key_gen.c
View File

@ -29,11 +29,8 @@
#include "cy_crypto_core_vu.h"
#include "cy_crypto_core_trng.h"
#define CY_ECC_CONFIG_TR_GARO_CTL 0x6C740B8Du
#define CY_ECC_CONFIG_TR_FIRO_CTL 0x52D246E1u
/* print some debug information. enabling this will render meaningless all time measurements */
#define ECC_KEY_GEN_DEBUG 0
#define CY_ECC_CONFIG_TR_GARO_CTL 0x6C740B8DuL
#define CY_ECC_CONFIG_TR_FIRO_CTL 0x52D246E1uL
/*******************************************************************************
@ -65,152 +62,135 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakeKeyPair(CRYPTO_Type *base,
cy_func_get_random_data_t GetRandomDataFunc,
void *randomDataInfo)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_NOT_SUPPORTED;
cy_stc_crypto_ecc_dp_type *eccDp = Cy_Crypto_Core_ECC_GetCurveParams(curveID);
if (eccDp == NULL || key == NULL)
if ((eccDp != NULL) && (key != NULL))
{
/* NULL parameter detected in Cy_Crypto_Core_ECC_MakeKeyPair()!!! */
return CY_CRYPTO_NOT_SUPPORTED;
}
tmpResult = CY_CRYPTO_SUCCESS;
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("\necc_make_key() for ");
Tb_PrintStr((int8_t *)eccDp->name);
Tb_PrintStr("\n");
#endif /* ECC_KEY_GEN_DEBUG */
uint32_t bitsize = eccDp->size;
int bitsize = eccDp->size;
/* used VU registers. Same values as in crypto_NIST_P.c */
uint32_t p_temp = 8u; /* temporal values */
uint32_t p_order = 9u; /* order of the curve */
uint32_t p_d = 10u; /* private key */
uint32_t p_x = 11u; /* x coordinate */
uint32_t p_y = 12u; /* y coordinate */
/* used VU registers. Same values as in crypto_NIST_P.c */
int p_temp = 8; /* temporal values */
int p_order = 9; /* order of the curve */
int p_d = 10; /* private key */
int p_x = 11; /* x coordinate */
int p_y = 12; /* y coordinate */
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1U);
CY_CRYPTO_VU_ALLOC_MEM(base, p_x, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_y, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1);
CY_CRYPTO_VU_ALLOC_MEM(base, p_x, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_y, bitsize);
/***************************************************************
* Apply domain parameters
***************************************************************/
/* load prime and order defining the curve as well as the Barrett coefficient. */
/* P and BARRETT_U are "globally" defined in cy_crypto_core_ecc.h */
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->prime, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_order, eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_p, bitsize + 1U);
/***************************************************************
* Apply domain parameters
***************************************************************/
/* load prime and order defining the curve as well as the barrett coefficient. */
/* Base Point, G = (p_x, p_y) */
Cy_Crypto_Core_Vu_SetMemValue (base, p_x, eccDp->Gx, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_y, eccDp->Gy, bitsize);
/* P and BARRETT_U are "globally" defined in cy_crypto_core_ecc.h */
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->prime, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_order, eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_p, bitsize + 1);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
/* Base Point, G = (p_x, p_y) */
Cy_Crypto_Core_Vu_SetMemValue (base, p_x, eccDp->Gx, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_y, eccDp->Gy, bitsize);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
/***************************************************************
* generate random string
***************************************************************/
if (GetRandomDataFunc != NULL)
{
GetRandomDataFunc( randomDataInfo, key->k, (bitsize + 7u) >> 3u );
}
else
{
for (int i = 0, randomsize = bitsize; randomsize > 0; randomsize-=32, i++)
/***************************************************************
* generate random string
***************************************************************/
if (GetRandomDataFunc != NULL)
{
int randombits = CY_CRYPTO_MIN(randomsize, 32);
(void)GetRandomDataFunc( randomDataInfo, (uint8_t*)key->k, ((bitsize + 7U) >> 3U) );
}
else
{
uint32_t i = 0U;
int32_t randomsize = (int32_t)bitsize;
cy_en_crypto_status_t status = CY_CRYPTO_SUCCESS;
cy_en_crypto_status_t error = Cy_Crypto_Core_Trng(base, CY_ECC_CONFIG_TR_GARO_CTL, CY_ECC_CONFIG_TR_FIRO_CTL,
randombits, &((uint32_t *)key->k)[i]);
if (CY_CRYPTO_SUCCESS != error)
while ((randomsize > 0) && (CY_CRYPTO_SUCCESS == status))
{
return CY_CRYPTO_HW_ERROR;
uint32_t randombits = (uint32_t)CY_CRYPTO_MIN(randomsize, 32);
status = Cy_Crypto_Core_Trng(base, CY_ECC_CONFIG_TR_GARO_CTL, CY_ECC_CONFIG_TR_FIRO_CTL,
randombits, &((uint32_t *)key->k)[i]);
randomsize -= 32;
i++;
if (CY_CRYPTO_SUCCESS != status)
{
tmpResult = CY_CRYPTO_HW_ERROR;
}
}
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/***************************************************************
* Load random data into VU
***************************************************************/
CY_CRYPTO_VU_ALLOC_MEM(base, p_d, bitsize);
Cy_Crypto_Core_Vu_SetMemValue(base, p_d, (uint8_t *)key->k, bitsize);
/* check that the key is smaller than the order of base point */
CY_CRYPTO_VU_CMP_SUB (base, p_d, p_order); /* C = (a >= b) */
uint32_t status = Cy_Crypto_Core_Vu_StatusRead(base);
if (0u != (status & CY_CRYPTO_VU_STATUS_CARRY_BIT))
{
/* random data >= order, needs reduction */
CY_CRYPTO_VU_PUSH_REG(base);
/* load values needed for reduction modulo curve order */
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1u);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_o, bitsize + 1u);
CY_CRYPTO_VU_ALLOC_MEM(base, p_temp, bitsize);
CY_CRYPTO_VU_MOV(base, p_temp, p_d);
/* z = x % mod */
Cy_Crypto_Core_EC_Bar_MulRed(base, p_d, p_temp, bitsize);
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(p_temp) | CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT));
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key->k, p_d, bitsize);
/* restore previous prime and Barrett values */
CY_CRYPTO_VU_POP_REG(base);
}
/*
* Make the public key
* EC scalar multiplication - X,Y-only co-Z arithmetic
*/
Cy_Crypto_Core_EC_NistP_PointMul(base, p_x, p_y, p_d, p_order, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key->pubkey.x, p_x, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key->pubkey.y, p_y, bitsize);
key->type = PK_PRIVATE;
key->curveID = curveID;
tmpResult = CY_CRYPTO_SUCCESS;
}
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT) |
CY_CRYPTO_VU_REG_BIT(p_x) | CY_CRYPTO_VU_REG_BIT(p_y) |
CY_CRYPTO_VU_REG_BIT(p_order) | CY_CRYPTO_VU_REG_BIT(p_d));
}
/***************************************************************
* Load random data into VU
***************************************************************/
CY_CRYPTO_VU_ALLOC_MEM(base, p_d, bitsize);
Cy_Crypto_Core_Vu_SetMemValue(base, p_d, (uint8_t *)key->k, bitsize);
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("random data: ");
Crypto_RegMemNumberPrint(p_d);
Tb_PrintStr("p_order: ");
Crypto_RegMemNumberPrint(p_order);
#endif /*ECC_KEY_GEN_DEBUG */
/* check that the key is smaller than the order of base point */
CY_CRYPTO_VU_CMP_SUB (base, p_d, p_order); /* C = (a >= b) */
uint16_t status = Cy_Crypto_Core_Vu_StatusRead(base);
if (status & CY_CRYPTO_VU_STATUS_CARRY_BIT)
{
/* random data >= order, needs reduction */
CY_CRYPTO_VU_PUSH_REG(base);
/* load values needed for reduction modulo curve order */
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1u);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_o, bitsize + 1u);
CY_CRYPTO_VU_ALLOC_MEM(base, p_temp, bitsize);
CY_CRYPTO_VU_MOV(base, p_temp, p_d);
/* z = x % mod */
Cy_Crypto_Core_EC_Bar_MulRed(base, p_d, p_temp, bitsize);
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(p_temp) | CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT));
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key->k, p_d, bitsize);
/* restore previous prime and barrett values */
CY_CRYPTO_VU_POP_REG(base);
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("random data after reduction modulo order: ");
Crypto_RegMemNumberPrint(p_d);
#endif /* ECC_KEY_GEN_DEBUG */
}
else
{
/* carry is clear, i. e. p_d < p_order */
}
/* make the public key
* EC scalar multiplication - X,Y-only co-Z arithmetic
*/
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("Doing scalar multiplication\n");
#endif /* ECC_KEY_GEN_DEBUG */
Cy_Crypto_Core_EC_NistP_PointMul(base, p_x, p_y, p_d, p_order, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key->pubkey.x, p_x, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key->pubkey.y, p_y, bitsize);
key->type = PK_PRIVATE;
key->curveID = curveID;
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT) |
CY_CRYPTO_VU_REG_BIT(p_x) | CY_CRYPTO_VU_REG_BIT(p_y) |
CY_CRYPTO_VU_REG_BIT(p_order) | CY_CRYPTO_VU_REG_BIT(p_d));
return CY_CRYPTO_SUCCESS;
return (tmpResult);
}
@ -242,105 +222,88 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakePrivateKey(CRYPTO_Type *base,
uint8_t *key,
cy_func_get_random_data_t GetRandomDataFunc, void *randomDataInfo)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
const cy_stc_crypto_ecc_dp_type *eccDp = Cy_Crypto_Core_ECC_GetCurveParams(curveID);
if (eccDp == NULL || key == NULL)
if ((eccDp != NULL) && (key != NULL))
{
/* NULL parameter detected in Cy_Crypto_Core_ECC_MakeKey()!!! */
return CY_CRYPTO_NOT_SUPPORTED;
}
tmpResult = CY_CRYPTO_SUCCESS;
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("\necc_make_key() for ");
Tb_PrintStr((int8_t *)eccDp->name);
Tb_PrintStr("\n");
#endif /* ECC_KEY_GEN_DEBUG */
uint32_t bitsize = eccDp->size;
int bitsize = eccDp->size;
uint32_t p_temp = 8u; /* temporal values */
uint32_t p_d = 10u; /* private key */
int p_temp = 8; /* temporal values */
int p_d = 10; /* private key */
/* generate random string */
if (GetRandomDataFunc != NULL)
{
GetRandomDataFunc( randomDataInfo, key, (bitsize + 7u) >> 3u );
}
else
{
for (int i = 0, randomsize = bitsize; randomsize > 0; randomsize-=32, i++)
/* generate random string */
if (GetRandomDataFunc != NULL)
{
int randombits = CY_CRYPTO_MIN(randomsize, 32);
(void)GetRandomDataFunc( randomDataInfo, key, ((bitsize + 7U) >> 3U) );
}
else
{
uint32_t i = 0U;
int32_t randomsize = (int32_t)bitsize;
cy_en_crypto_status_t status = CY_CRYPTO_SUCCESS;
cy_en_crypto_status_t error = Cy_Crypto_Core_Trng(base, CY_ECC_CONFIG_TR_GARO_CTL, CY_ECC_CONFIG_TR_FIRO_CTL,
randombits, &((uint32_t *)key)[i]);
if (CY_CRYPTO_SUCCESS != error)
while ((randomsize > 0) && (CY_CRYPTO_SUCCESS == status))
{
return CY_CRYPTO_HW_ERROR;
uint32_t randombits = (uint32_t)CY_CRYPTO_MIN(randomsize, 32);
status = Cy_Crypto_Core_Trng(base, CY_ECC_CONFIG_TR_GARO_CTL, CY_ECC_CONFIG_TR_FIRO_CTL,
randombits, &((uint32_t *)key)[i]);
randomsize -= 32;
i++;
if (CY_CRYPTO_SUCCESS != status)
{
tmpResult = CY_CRYPTO_HW_ERROR;
}
}
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* load prime and order defining the curve as well as the barrett coefficient. */
/* P and BARRETT_U are "globally" defined in cy_crypto_core_ecc.h */
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1u);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_o, bitsize + 1u);
/* Load random data into VU */
CY_CRYPTO_VU_ALLOC_MEM(base, p_d, bitsize);
Cy_Crypto_Core_Vu_SetMemValue(base, p_d, (uint8_t *)key, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_temp, bitsize);
CY_CRYPTO_VU_MOV(base, p_temp, p_d);
/* check that the key is smaller than the order of base point */
CY_CRYPTO_VU_CMP_SUB (base, p_d, VR_P); /* C = (a >= b) */
uint32_t status = Cy_Crypto_Core_Vu_StatusRead(base);
if (0u != (status & CY_CRYPTO_VU_STATUS_CARRY_BIT))
{
/* private key (random data) >= order, needs reduction */
/* use Barrett reduction algorithm for operations modulo n (order of the base point) */
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
/* z = x % mod */
Cy_Crypto_Core_EC_Bar_MulRed(base, p_d, p_temp, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key, p_d, bitsize);
}
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT) |
CY_CRYPTO_VU_REG_BIT(p_d) | CY_CRYPTO_VU_REG_BIT(p_temp));
tmpResult = CY_CRYPTO_SUCCESS;
}
}
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("private key: ");
Crypto_PrintNumber((uint8_t *)key, CY_CRYPTO_BYTE_SIZE_OF_BITS(bitsize));
#endif /* ECC_KEY_GEN_DEBUG */
/* load prime and order defining the curve as well as the barrett coefficient. */
/* P and BARRETT_U are "globally" defined in cy_crypto_core_ecc.h */
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_o, bitsize + 1);
/* Load random data into VU */
CY_CRYPTO_VU_ALLOC_MEM(base, p_d, bitsize);
Cy_Crypto_Core_Vu_SetMemValue(base, p_d, (uint8_t *)key, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_temp, bitsize);
CY_CRYPTO_VU_MOV(base, p_temp, p_d);
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("random data: ");
Crypto_RegMemNumberPrint(p_d);
Tb_PrintStr("p_order: ");
Crypto_RegMemNumberPrint(VR_P);
#endif /* ECC_KEY_GEN_DEBUG */
/* check that the key is smaller than the order of base point */
CY_CRYPTO_VU_CMP_SUB (base, p_d, VR_P); /* C = (a >= b) */
uint16_t status = Cy_Crypto_Core_Vu_StatusRead(base);
if (status & CY_CRYPTO_VU_STATUS_CARRY_BIT)
{
/* private key (random data) >= order, needs reduction */
/* use barrett reduction algorithm for operations modulo n (order of the base point) */
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
/* z = x % mod */
Cy_Crypto_Core_EC_Bar_MulRed(base, p_d, p_temp, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)key, p_d, bitsize);
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("private key after reduction modulo order: ");
Crypto_RegMemNumberPrint(p_d);
#endif /* ECC_KEY_GEN_DEBUG */
}
else
{
/* carry is clear, i. e. p_d < p_order */
}
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT) |
CY_CRYPTO_VU_REG_BIT(p_d) | CY_CRYPTO_VU_REG_BIT(p_temp));
return CY_CRYPTO_SUCCESS;
return (tmpResult);
}
@ -367,71 +330,66 @@ cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakePrivateKey(CRYPTO_Type *base,
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_ECC_MakePublicKey(CRYPTO_Type *base,
cy_en_crypto_ecc_curve_id_t curveID,
uint8_t *privateKey,
const uint8_t *privateKey,
cy_stc_crypto_ecc_key *publicKey)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
cy_stc_crypto_ecc_dp_type *eccDp = Cy_Crypto_Core_ECC_GetCurveParams(curveID);
if (eccDp == NULL || privateKey == NULL || publicKey == NULL)
if ((eccDp != NULL) && (privateKey != NULL) && (publicKey != NULL))
{
/* NULL parameter detected in Cy_Crypto_Core_ECC_MakeKey()!!! */
return CY_CRYPTO_NOT_SUPPORTED;
uint32_t bitsize = eccDp->size;
uint32_t p_order = 9u; /* order of the curve */
uint32_t p_d = 10u; /* private key */
uint32_t p_x = 11u; /* x coordinate */
uint32_t p_y = 12u; /* y coordinate */
/* make the public key
* EC scalar multiplication - X,Y-only co-Z arithmetic
*/
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1u);
CY_CRYPTO_VU_ALLOC_MEM(base, p_x, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_y, bitsize);
/* Apply domain parameters */
/* load prime and order defining the curve as well as the barrett coefficient. */
/* P and BARRETT_U are "globally" defined in cy_crypto_core_ecc.h */
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->prime, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_order, eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_p, bitsize + 1u);
/*Base Point, G = (p_x, p_y) */
Cy_Crypto_Core_Vu_SetMemValue (base, p_x, eccDp->Gx, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_y, eccDp->Gy, bitsize);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
/* Load random data into VU */
CY_CRYPTO_VU_ALLOC_MEM(base, p_d, bitsize);
Cy_Crypto_Core_Vu_SetMemValue(base, p_d, (uint8_t *)privateKey, bitsize);
Cy_Crypto_Core_EC_NistP_PointMul(base, p_x, p_y, p_d, p_order, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)publicKey->pubkey.x, p_x, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)publicKey->pubkey.y, p_y, bitsize);
publicKey->type = PK_PUBLIC;
publicKey->curveID = curveID;
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(p_order) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT) |
CY_CRYPTO_VU_REG_BIT(p_x) | CY_CRYPTO_VU_REG_BIT(p_y) | CY_CRYPTO_VU_REG_BIT(p_d));
tmpResult = CY_CRYPTO_SUCCESS;
}
#if ECC_KEY_GEN_DEBUG
Tb_PrintStr("\necc_make public key() for ");
Tb_PrintStr((int8_t *)eccDp->name);
Tb_PrintStr("\n");
#endif /* ECC_KEY_GEN_DEBUG */
int bitsize = eccDp->size;
int p_order = 9; /* order of the curve */
int p_d = 10; /* private key */
int p_x = 11; /* x coordinate */
int p_y = 12; /* y coordinate */
/* make the public key
* EC scalar multiplication - X,Y-only co-Z arithmetic
*/
CY_CRYPTO_VU_ALLOC_MEM(base, VR_P, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_order, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, VR_BARRETT, bitsize + 1);
CY_CRYPTO_VU_ALLOC_MEM(base, p_x, bitsize);
CY_CRYPTO_VU_ALLOC_MEM(base, p_y, bitsize);
/* Apply domain parameters */
/* load prime and order defining the curve as well as the barrett coefficient. */
/* P and BARRETT_U are "globally" defined in cy_crypto_core_ecc.h */
Cy_Crypto_Core_Vu_SetMemValue (base, VR_P, eccDp->prime, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_order, eccDp->order, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, VR_BARRETT, eccDp->barrett_p, bitsize + 1);
/*Base Point, G = (p_x, p_y) */
Cy_Crypto_Core_Vu_SetMemValue (base, p_x, eccDp->Gx, bitsize);
Cy_Crypto_Core_Vu_SetMemValue (base, p_y, eccDp->Gy, bitsize);
Cy_Crypto_Core_EC_NistP_SetMode(bitsize);
Cy_Crypto_Core_EC_NistP_SetRedAlg(eccDp->algo);
/* Load random data into VU */
CY_CRYPTO_VU_ALLOC_MEM(base, p_d, bitsize);
Cy_Crypto_Core_Vu_SetMemValue(base, p_d, (uint8_t *)privateKey, bitsize);
Cy_Crypto_Core_EC_NistP_PointMul(base, p_x, p_y, p_d, p_order, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)publicKey->pubkey.x, p_x, bitsize);
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t *)publicKey->pubkey.y, p_y, bitsize);
publicKey->type = PK_PUBLIC;
publicKey->curveID = curveID;
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(VR_P) | CY_CRYPTO_VU_REG_BIT(p_order) | CY_CRYPTO_VU_REG_BIT(VR_BARRETT) |
CY_CRYPTO_VU_REG_BIT(p_x) | CY_CRYPTO_VU_REG_BIT(p_y) | CY_CRYPTO_VU_REG_BIT(p_d));
return CY_CRYPTO_SUCCESS;
return (tmpResult);
}

1599
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_ecc_nist_p.c
View File

File diff suppressed because it is too large Load Diff

126
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_hmac_v1.c
View File

@ -65,7 +65,7 @@ static void Cy_Crypto_Core_V1_Hmac_Init(cy_stc_crypto_v1_hmac_state_t *hmacState
uint8_t *opad,
uint8_t *m0Key);
static void Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
static cy_en_crypto_status_t Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
cy_stc_crypto_v1_hmac_state_t *hmacState,
cy_stc_crypto_sha_state_t *hashState,
uint8_t const *key,
@ -118,7 +118,7 @@ static void Cy_Crypto_Core_V1_Hmac_Init(cy_stc_crypto_v1_hmac_state_t *hmacState
* Starts HMAC (Hash-based Message Authentication Code) calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmacState
* The pointer to the hmacState structure which stores internal variables
@ -144,7 +144,7 @@ static void Cy_Crypto_Core_V1_Hmac_Init(cy_stc_crypto_v1_hmac_state_t *hmacState
* The pointer to the calculated HMAC.
*
*******************************************************************************/
static void Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
static cy_en_crypto_status_t Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
cy_stc_crypto_v1_hmac_state_t *hmacState,
cy_stc_crypto_sha_state_t *hashState,
uint8_t const *key,
@ -153,6 +153,8 @@ static void Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
uint32_t messageSize,
uint8_t *hmac)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
uint32_t i = 0uL;
uint8_t *ipadPtrTmp = (uint8_t*)hmacState->ipad;
uint8_t *opadPtrTmp = (uint8_t*)hmacState->opad;
@ -162,13 +164,22 @@ static void Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
if (keyLength > hashState->blockSize)
{
/* The key is larger than the block size. Do a hash on the key. */
Cy_Crypto_Core_V1_Sha_Start (base, hashState);
Cy_Crypto_Core_V1_Sha_Update (base, hashState, key, keyLength);
Cy_Crypto_Core_V1_Sha_Finish (base, hashState, (uint8_t*)m0KeyPtrTmp/*, keyLength*/);
tmpResult = Cy_Crypto_Core_V1_Sha_Start(base, hashState);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Update(base, hashState, key, keyLength);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Finish(base, hashState, (uint8_t*)m0KeyPtrTmp);
}
/* Append zeros */
Cy_Crypto_Core_V1_MemSet(base, (m0KeyPtrTmp + hashState->digestSize), 0x00u,
(uint16_t)(hashState->blockSize - hashState->digestSize));
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* Append zeros */
Cy_Crypto_Core_V1_MemSet(base, (m0KeyPtrTmp + hashState->digestSize), 0x00u,
(uint16_t)(hashState->blockSize - hashState->digestSize));
}
}
else if (keyLength < hashState->blockSize)
{
@ -181,31 +192,59 @@ static void Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
Cy_Crypto_Core_V1_MemCpy(base, m0KeyPtrTmp, key, (uint16_t)keyLength);
}
/* Steps 4 and 7 according to FIPS 198-1 */
while (i < hashState->blockSize)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
ipadPtrTmp[i] = CY_CRYPTO_HMAC_IPAD ^ m0KeyPtrTmp[i];
opadPtrTmp[i] = CY_CRYPTO_HMAC_0PAD ^ m0KeyPtrTmp[i];
i++;
/* Steps 4 and 7 according to FIPS 198-1 */
while (i < hashState->blockSize)
{
ipadPtrTmp[i] = CY_CRYPTO_HMAC_IPAD ^ m0KeyPtrTmp[i];
opadPtrTmp[i] = CY_CRYPTO_HMAC_0PAD ^ m0KeyPtrTmp[i];
i++;
}
/* Step 6 according to FIPS 198-1 */
tmpResult = Cy_Crypto_Core_V1_Sha_Start(base, hashState);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Update(base, hashState, ipadPtrTmp, hashState->blockSize);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* Append a message */
tmpResult = Cy_Crypto_Core_V1_Sha_Update (base, hashState, message, messageSize);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Finish (base, hashState, ipadPtrTmp);
}
/* Here is the ready part of HASH: Hash((Key^ipad)||text) */
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* Steps 8, 9 according to FIPS 198-1 */
tmpResult = Cy_Crypto_Core_V1_Sha_Start(base, hashState);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Update(base, hashState, opadPtrTmp, hashState->blockSize);
}
/* Append HASH from Step 6 */
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Update(base, hashState, (uint8_t*)ipadPtrTmp, hashState->digestSize);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V1_Sha_Finish(base, hashState, hmac);
}
}
}
/* Step 6 according to FIPS 198-1 */
Cy_Crypto_Core_V1_Sha_Start (base, hashState);
Cy_Crypto_Core_V1_Sha_Update(base, hashState, ipadPtrTmp, hashState->blockSize);
/* Append a message */
Cy_Crypto_Core_V1_Sha_Update (base, hashState, message, messageSize);
Cy_Crypto_Core_V1_Sha_Finish (base, hashState, ipadPtrTmp);
/* Here is the ready part of HASH: Hash((Key^ipad)||text) */
/* Steps 8, 9 according to FIPS 198-1 */
Cy_Crypto_Core_V1_Sha_Start (base, hashState);
Cy_Crypto_Core_V1_Sha_Update(base, hashState, opadPtrTmp, hashState->blockSize);
/* Append HASH from Step 6 */
Cy_Crypto_Core_V1_Sha_Update (base, hashState, (uint8_t*)ipadPtrTmp, hashState->digestSize);
Cy_Crypto_Core_V1_Sha_Finish (base, hashState, hmac);
return (tmpResult);
}
/*******************************************************************************
@ -215,7 +254,7 @@ static void Cy_Crypto_Core_V1_Hmac_Calculate(CRYPTO_Type *base,
* Clears the used memory buffers.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmacState
* The pointer to the HMAC context.
@ -236,7 +275,7 @@ static void Cy_Crypto_Core_V1_Hmac_Free(CRYPTO_Type *base, cy_stc_crypto_v1_hmac
* Performs HMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmac
* The pointer to the calculated HMAC. Must be 4-byte aligned.
@ -257,7 +296,7 @@ static void Cy_Crypto_Core_V1_Hmac_Free(CRYPTO_Type *base, cy_stc_crypto_v1_hmac
* \ref cy_en_crypto_sha_mode_t
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Hmac(CRYPTO_Type *base,
@ -268,25 +307,30 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Hmac(CRYPTO_Type *base,
uint32_t keyLength,
cy_en_crypto_sha_mode_t mode)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
/* Allocating internal variables into the CRYPTO SRAM Buffer */
cy_stc_crypto_hmac_buffers_t *hmacBuffers = (cy_stc_crypto_hmac_buffers_t *)(REG_CRYPTO_MEM_BUFF(base));
cy_stc_crypto_v1_hmac_state_t *hmacStateTmp = &hmacBuffers->hmacState;
cy_stc_crypto_sha_state_t hashState;
cy_stc_crypto_sha_state_t hashStateLoc = { 0 };
uint8_t *ipadTmp = (uint8_t*)(&hmacBuffers->ipad);
uint8_t *opadTmp = (uint8_t*)(&hmacBuffers->opad);
uint8_t *m0KeyTmp = (uint8_t*)(&hmacBuffers->m0Key);
Cy_Crypto_Core_V1_Sha_Init (base, &hashState, mode, &hmacBuffers->shaBuffers);
tmpResult = Cy_Crypto_Core_V1_Sha_Init(base, &hashStateLoc, mode, &hmacBuffers->shaBuffers);
Cy_Crypto_Core_V1_Hmac_Init (hmacStateTmp, ipadTmp, opadTmp, m0KeyTmp);
Cy_Crypto_Core_V1_Hmac_Calculate (base, hmacStateTmp, &hashState, key, keyLength, message, messageSize, hmac);
Cy_Crypto_Core_V1_Hmac_Free (base, hmacStateTmp);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
Cy_Crypto_Core_V1_Hmac_Init(hmacStateTmp, ipadTmp, opadTmp, m0KeyTmp);
tmpResult = Cy_Crypto_Core_V1_Hmac_Calculate (base, hmacStateTmp, &hashStateLoc, key, keyLength, message, messageSize, hmac);
Cy_Crypto_Core_V1_Hmac_Free(base, hmacStateTmp);
}
Cy_Crypto_Core_V1_Sha_Free (base, &hashState);
(void)Cy_Crypto_Core_V1_Sha_Free(base, &hashStateLoc);
return (CY_CRYPTO_SUCCESS);
return (tmpResult);
}

120
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_hmac_v2.c
View File

@ -64,7 +64,7 @@ static void Cy_Crypto_Core_V2_Hmac_Init(cy_stc_crypto_v2_hmac_state_t *hmacState
uint8_t *ipad,
uint8_t *opad,
uint8_t *m0Key);
static void Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
static cy_en_crypto_status_t Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
cy_stc_crypto_v2_hmac_state_t *hmacState,
cy_stc_crypto_sha_state_t *hashState,
uint8_t const *key,
@ -116,7 +116,7 @@ static void Cy_Crypto_Core_V2_Hmac_Init(cy_stc_crypto_v2_hmac_state_t *hmacState
* Starts HMAC (Hash-based Message Authentication Code) calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmacState
* The pointer to the hmacState structure which stores internal variables
@ -142,7 +142,7 @@ static void Cy_Crypto_Core_V2_Hmac_Init(cy_stc_crypto_v2_hmac_state_t *hmacState
* The pointer to the calculated HMAC.
*
*******************************************************************************/
static void Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
static cy_en_crypto_status_t Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
cy_stc_crypto_v2_hmac_state_t *hmacState,
cy_stc_crypto_sha_state_t *hashState,
uint8_t const *key,
@ -151,6 +151,8 @@ static void Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
uint32_t messageSize,
uint8_t *hmac)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
uint32_t i = 0uL;
uint32_t blockSizeTmp = hashState->blockSize;
uint32_t digestSizeTmp = hashState->digestSize;
@ -164,9 +166,16 @@ static void Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
if (keyLength > blockSizeTmp)
{
/* The key is larger than the block size. Do a hash on the key. */
Cy_Crypto_Core_V2_Sha_Start (base, hashState);
Cy_Crypto_Core_V2_Sha_Update (base, hashState, key, keyLength);
Cy_Crypto_Core_V2_Sha_Finish (base, hashState, m0KeyPtrTmp);
tmpResult = Cy_Crypto_Core_V2_Sha_Start (base, hashState);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Update (base, hashState, key, keyLength);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Finish (base, hashState, m0KeyPtrTmp);
}
/* Append zeros */
Cy_Crypto_Core_V2_MemSet(base, (m0KeyPtrTmp + digestSizeTmp), 0x00u, (uint16_t)(blockSizeTmp - digestSizeTmp));
@ -182,31 +191,59 @@ static void Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
Cy_Crypto_Core_V2_MemCpy(base, m0KeyPtrTmp, key, (uint16_t)keyLength);
}
/* Steps 4 and 7 according to FIPS 198-1 */
while (i < blockSizeTmp)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
ipadPtrTmp[i] = CY_CRYPTO_HMAC_IPAD ^ m0KeyPtrTmp[i];
opadPtrTmp[i] = CY_CRYPTO_HMAC_0PAD ^ m0KeyPtrTmp[i];
i++;
/* Steps 4 and 7 according to FIPS 198-1 */
while (i < blockSizeTmp)
{
ipadPtrTmp[i] = CY_CRYPTO_HMAC_IPAD ^ m0KeyPtrTmp[i];
opadPtrTmp[i] = CY_CRYPTO_HMAC_0PAD ^ m0KeyPtrTmp[i];
i++;
}
/* Step 6 according to FIPS 198-1 */
tmpResult = Cy_Crypto_Core_V2_Sha_Start (base, hashState);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Update(base, hashState, ipadPtrTmp, blockSizeTmp);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* Append a message */
tmpResult = Cy_Crypto_Core_V2_Sha_Update(base, hashState, message, messageSize);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Finish(base, hashState, ipadPtrTmp);
}
/* Here is the ready part of HASH: Hash((Key^ipad)||text) */
if (CY_CRYPTO_SUCCESS == tmpResult)
{
/* Steps 8, 9 according to FIPS 198-1 */
tmpResult = Cy_Crypto_Core_V2_Sha_Start(base, hashState);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Update(base, hashState, opadPtrTmp, blockSizeTmp);
}
/* Append HASH from Step 6 */
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Update(base, hashState, ipadPtrTmp, digestSizeTmp);
}
if (CY_CRYPTO_SUCCESS == tmpResult)
{
tmpResult = Cy_Crypto_Core_V2_Sha_Finish(base, hashState, hmac);
}
}
}
/* Step 6 according to FIPS 198-1 */
Cy_Crypto_Core_V2_Sha_Start (base, hashState);
Cy_Crypto_Core_V2_Sha_Update(base, hashState, ipadPtrTmp, blockSizeTmp);
/* Append a message */
Cy_Crypto_Core_V2_Sha_Update(base, hashState, message, messageSize);
Cy_Crypto_Core_V2_Sha_Finish(base, hashState, ipadPtrTmp);
/* Here is the ready part of HASH: Hash((Key^ipad)||text) */
/* Steps 8, 9 according to FIPS 198-1 */
Cy_Crypto_Core_V2_Sha_Start(base, hashState);
Cy_Crypto_Core_V2_Sha_Update(base, hashState, opadPtrTmp, blockSizeTmp);
/* Append HASH from Step 6 */
Cy_Crypto_Core_V2_Sha_Update(base, hashState, ipadPtrTmp, digestSizeTmp);
Cy_Crypto_Core_V2_Sha_Finish(base, hashState, hmac);
return (tmpResult);
}
/*******************************************************************************
@ -216,7 +253,7 @@ static void Cy_Crypto_Core_V2_Hmac_Calculate(CRYPTO_Type *base,
* Clears the used memory buffers.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmacState
* The pointer to the HMAC context.
@ -235,7 +272,7 @@ static void Cy_Crypto_Core_V2_Hmac_Free(CRYPTO_Type *base, cy_stc_crypto_v2_hmac
* Performs HMAC calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hmac
* The pointer to the calculated HMAC. Must be 4-byte aligned.
@ -256,7 +293,7 @@ static void Cy_Crypto_Core_V2_Hmac_Free(CRYPTO_Type *base, cy_stc_crypto_v2_hmac
* \ref cy_en_crypto_sha_mode_t
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Hmac(CRYPTO_Type *base,
@ -267,27 +304,32 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Hmac(CRYPTO_Type *base,
uint32_t keyLength,
cy_en_crypto_sha_mode_t mode)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
/* Allocating internal variables into the CRYPTO SRAM Buffer */
cy_stc_crypto_v2_hmac_buffers_t hmacBuffersData;
cy_stc_crypto_v2_hmac_buffers_t hmacBuffersData = { 0 };
cy_stc_crypto_v2_hmac_buffers_t *hmacBuffers = &hmacBuffersData;
cy_stc_crypto_v2_hmac_state_t *hmacStateTmp = &hmacBuffers->hmacState;
cy_stc_crypto_sha_state_t hashState;
cy_stc_crypto_sha_state_t hashStateLoc = { 0 };
uint8_t *ipadTmp = (uint8_t*)&hmacBuffers->ipad;
uint8_t *opadTmp = (uint8_t*)&hmacBuffers->opad;
uint8_t *m0KeyTmp = (uint8_t*)&hmacBuffers->m0Key;
/* No any buffers needed for Crypto_ver2 IP block */
Cy_Crypto_Core_V2_Sha_Init (base, &hashState, mode, NULL);
tmpResult = Cy_Crypto_Core_V2_Sha_Init(base, &hashStateLoc, mode, NULL);
Cy_Crypto_Core_V2_Hmac_Init (hmacStateTmp, ipadTmp, opadTmp, m0KeyTmp);
Cy_Crypto_Core_V2_Hmac_Calculate (base, hmacStateTmp, &hashState, key, keyLength, message, messageSize, hmac);
Cy_Crypto_Core_V2_Hmac_Free (base, hmacStateTmp);
if (CY_CRYPTO_SUCCESS == tmpResult)
{
Cy_Crypto_Core_V2_Hmac_Init(hmacStateTmp, ipadTmp, opadTmp, m0KeyTmp);
tmpResult = Cy_Crypto_Core_V2_Hmac_Calculate(base, hmacStateTmp, &hashStateLoc, key, keyLength, message, messageSize, hmac);
Cy_Crypto_Core_V2_Hmac_Free(base, hmacStateTmp);
}
Cy_Crypto_Core_V2_Sha_Free (base, &hashState);
(void)Cy_Crypto_Core_V2_Sha_Free(base, &hashStateLoc);
return (CY_CRYPTO_SUCCESS);
return (tmpResult);
}

25
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_hw.c
View File

@ -104,6 +104,12 @@ const cy_stc_cryptoIP_t cy_cryptoIpBlockCfgPSoC6_02 =
#define CY_CRYPTO_PWR_MODE_RETAINED (2UL)
#define CY_CRYPTO_PWR_MODE_ENABLED (3UL)
/**
* \addtogroup group_crypto_lld_hw_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_ClearVuRegisters
****************************************************************************//**
@ -111,7 +117,7 @@ const cy_stc_cryptoIP_t cy_cryptoIpBlockCfgPSoC6_02 =
* The function to initialize the Crypto VU registers.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
void Cy_Crypto_Core_ClearVuRegisters(CRYPTO_Type *base)
@ -140,8 +146,6 @@ void Cy_Crypto_Core_ClearVuRegisters(CRYPTO_Type *base)
*
* The function to initialize the Crypto hardware.
*
* This function is internal and should not to be called directly by user software
*
*******************************************************************************/
void Cy_Crypto_Core_HwInit(void)
{
@ -155,17 +159,17 @@ void Cy_Crypto_Core_HwInit(void)
* The function to enable the Crypto hardware.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \return
* Crypto status \ref cy_en_crypto_status_t.
* Crypto status \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_Enable(CRYPTO_Type *base)
{
Cy_Crypto_Core_HwInit();
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
/* Enable Crypto HW */
REG_CRYPTO_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CTL_PWR_MODE, CY_CRYPTO_PWR_MODE_ENABLED) |
@ -232,7 +236,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Enable(CRYPTO_Type *base)
* The pointer to a variable to store gathered crypto library information.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_GetLibInfo(cy_en_crypto_lib_info_t *libInfo)
@ -249,15 +253,15 @@ cy_en_crypto_status_t Cy_Crypto_Core_GetLibInfo(cy_en_crypto_lib_info_t *libInfo
* Disables the operation of the CRYPTO block.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_Disable(CRYPTO_Type *base)
{
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
/* Disable Crypto HW */
REG_CRYPTO_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_CTL_PWR_MODE, CY_CRYPTO_PWR_MODE_OFF) |
@ -322,6 +326,7 @@ void Cy_Crypto_Core_InvertEndianness(void *inArrPtr, uint32_t byteSize)
}
}
/** \} group_crypto_lld_hw_functions */
#endif /* CY_IP_MXCRYPTO */

18
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_hw_v1.c
View File

@ -39,7 +39,7 @@
* Writes one 32-Bit data word into Crypto FIFO.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data0
* The address of data to be placed into Crypto FIFO
@ -66,7 +66,7 @@ void Cy_Crypto_SetReg1Instr(CRYPTO_Type *base, uint32_t data0)
* Writes two 32-Bit data words into Crypto FIFO.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data0
* The address of data to be placed into Crypto FIFO
@ -99,7 +99,7 @@ void Cy_Crypto_SetReg2Instr(CRYPTO_Type *base, uint32_t data0, uint32_t data1)
* Writes three 32-Bit data words into Crypto FIFO.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data0
* The address of data to be placed into Crypto FIFO
@ -138,7 +138,7 @@ void Cy_Crypto_SetReg3Instr(CRYPTO_Type *base, uint32_t data0, uint32_t data1, u
* Writes four 32-Bit data words into Crypto FIFO.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param data0
* The address of data to be placed into Crypto FIFO
@ -183,7 +183,7 @@ void Cy_Crypto_SetReg4Instr(CRYPTO_Type *base, uint32_t data0, uint32_t data1, u
* Run the Crypto instruction without parameters.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param instr
* The Opcode of the called instruction.
@ -207,7 +207,7 @@ void Cy_Crypto_Run0ParamInstr(CRYPTO_Type *base, uint8_t instr)
* The parameter must be placed into register 0
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param instr
* The Opcode of the called instruction.
@ -236,7 +236,7 @@ void Cy_Crypto_Run1ParamInstr(CRYPTO_Type *base, uint8_t instr, uint32_t rdst0Sh
* the first parameter must be placed into register 1.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param instr
* The Opcode of the called instruction.
@ -273,7 +273,7 @@ void Cy_Crypto_Run2ParamInstr(CRYPTO_Type *base,
* the second parameter must be placed into register 2.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param instr
* The Opcode of the called instruction.
@ -316,7 +316,7 @@ void Cy_Crypto_Run3ParamInstr(CRYPTO_Type *base,
* the third parameter must be placed into register 3.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param instr
* The Opcode of the called instruction.

8
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_mem_v1.c
View File

@ -44,7 +44,7 @@
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src
* The pointer to the source of MemCpy.
@ -85,7 +85,7 @@ void Cy_Crypto_Core_V1_MemCpy(CRYPTO_Type *base, void* dst, void const *src, uin
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dst
* The pointer to the destination of MemSet.
@ -125,7 +125,7 @@ void Cy_Crypto_Core_V1_MemSet(CRYPTO_Type *base, void* dst, uint8_t data, uint16
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src0
* The pointer to the first source of MemCmp.
@ -171,7 +171,7 @@ uint32_t Cy_Crypto_Core_V1_MemCmp(CRYPTO_Type *base, void const *src0, void cons
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src0
* The pointer to the first source of MemXor.

8
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_mem_v2.c
View File

@ -42,7 +42,7 @@
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src
* The pointer to the source of MemCpy.
@ -81,7 +81,7 @@ void Cy_Crypto_Core_V2_MemCpy(CRYPTO_Type *base, void* dst, void const *src, uin
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param dst
* The pointer to the destination of MemSet.
@ -119,7 +119,7 @@ void Cy_Crypto_Core_V2_MemSet(CRYPTO_Type *base, void* dst, uint8_t data, uint16
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src0
* The pointer to the first source of MemCmp.
@ -166,7 +166,7 @@ uint32_t Cy_Crypto_Core_V2_MemCmp(CRYPTO_Type *base, void const *src0, void cons
* There is no alignment restriction.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param src0
* The pointer to the first source of MemXor.

8
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_prng_v1.c
View File

@ -43,7 +43,7 @@
* Invoking this function causes a restart of the pseudo-random sequence.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param lfsr32InitState
* A non-zero seed value for the first LFSR.
@ -55,7 +55,7 @@
* A non-zero seed value for the third LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Prng_Init(CRYPTO_Type *base,
@ -79,7 +79,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Prng_Init(CRYPTO_Type *base,
* Generates a Pseudo Random Number.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param max
* The maximum value of a random number.
@ -88,7 +88,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Prng_Init(CRYPTO_Type *base,
* The pointer to a variable to store the generated pseudo random number.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Prng(CRYPTO_Type *base,

8
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_prng_v2.c
View File

@ -43,7 +43,7 @@
* Invoking this function causes a restart of the pseudo-random sequence.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param lfsr32InitState
* A non-zero seed value for the first LFSR.
@ -55,7 +55,7 @@
* A non-zero seed value for the third LFSR.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Prng_Init(CRYPTO_Type *base,
@ -79,7 +79,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Prng_Init(CRYPTO_Type *base,
* Generates a Pseudo Random Number.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param max
* The maximum value of a random number.
@ -88,7 +88,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Prng_Init(CRYPTO_Type *base,
* The pointer to a variable to store the generated pseudo random number.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Prng(CRYPTO_Type *base,

248
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_rsa.c
View File

@ -57,61 +57,10 @@ static void Cy_Crypto_Core_Rsa_expModByMont(CRYPTO_Type *base,
#endif /* #if (CPUSS_CRYPTO_VU == 1) */
/* Encodings for hash functions */
#if (CPUSS_CRYPTO_SHA1 == 1)
static const uint8_t sha1EncStr[CY_CRYPTO_SHA1_PADDING_SIZE] =
{
0x30u, 0x21u, 0x30u, 0x09u, 0x06u, 0x05u, 0x2Bu, 0x0Eu,
0x03u, 0x02u, 0x1Au, 0x05u, 0x00u, 0x04u, 0x14u
};
#endif /* #if (CPUSS_CRYPTO_SHA1 == 1) */
#if (CPUSS_CRYPTO_SHA256 == 1)
static const uint8_t sha224EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x2Du, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x04u, 0x05u,
0x00u, 0x04u, 0x1Cu
};
static const uint8_t sha256EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x31u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x01u, 0x05u,
0x00u, 0x04u, 0x20u
};
#endif /* #if (CPUSS_CRYPTO_SHA256 == 1) */
#if (CPUSS_CRYPTO_SHA512 == 1)
static const uint8_t sha384EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x41u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x02u, 0x05u,
0x00u, 0x04u, 0x30u
};
static const uint8_t sha512EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x51u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x03u, 0x05u,
0x00u, 0x04u, 0x40u
};
static const uint8_t sha512_224EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x2Du, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x05u, 0x05u,
0x00u, 0x04u, 0x1Cu
};
static const uint8_t sha512_256EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x31u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x06u, 0x05u,
0x00u, 0x04u, 0x20u
};
#endif /* #if (CPUSS_CRYPTO_SHA512 == 1) */
/**
* \addtogroup group_crypto_lld_asymmetric_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Rsa_Verify
@ -127,7 +76,7 @@ static const uint8_t sha512_256EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
* Returns the verification result \ref cy_en_crypto_rsa_ver_result_t.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param verResult
* The pointer to the verification result \ref cy_en_crypto_rsa_ver_result_t.
@ -145,7 +94,7 @@ static const uint8_t sha512_256EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
* The length of the decrypted signature to be verified (in bytes)
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
@ -155,11 +104,67 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
uint8_t const *decryptedSignature,
uint32_t decryptedSignatureLength)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_SUCCESS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
/* Encodings for hash functions */
#if (CPUSS_CRYPTO_SHA1 == 1)
static const uint8_t sha1EncStr[CY_CRYPTO_SHA1_PADDING_SIZE] =
{
0x30u, 0x21u, 0x30u, 0x09u, 0x06u, 0x05u, 0x2Bu, 0x0Eu,
0x03u, 0x02u, 0x1Au, 0x05u, 0x00u, 0x04u, 0x14u
};
#endif /* #if (CPUSS_CRYPTO_SHA1 == 1) */
#if (CPUSS_CRYPTO_SHA256 == 1)
static const uint8_t sha224EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x2Du, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x04u, 0x05u,
0x00u, 0x04u, 0x1Cu
};
static const uint8_t sha256EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x31u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x01u, 0x05u,
0x00u, 0x04u, 0x20u
};
#endif /* #if (CPUSS_CRYPTO_SHA256 == 1) */
#if (CPUSS_CRYPTO_SHA512 == 1)
static const uint8_t sha384EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x41u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x02u, 0x05u,
0x00u, 0x04u, 0x30u
};
static const uint8_t sha512EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x51u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x03u, 0x05u,
0x00u, 0x04u, 0x40u
};
static const uint8_t sha512_224EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x2Du, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x05u, 0x05u,
0x00u, 0x04u, 0x1Cu
};
static const uint8_t sha512_256EncStr[CY_CRYPTO_SHA256_512_PADDING_SIZE] =
{
0x30u, 0x31u, 0x30u, 0x0Du, 0x06u, 0x09u, 0x60u, 0x86u,
0x48u, 0x01u, 0x65u, 0x03u, 0x04u, 0x02u, 0x06u, 0x05u,
0x00u, 0x04u, 0x20u
};
#endif /* #if (CPUSS_CRYPTO_SHA512 == 1) */
uint8_t const *encodingArr = NULL;
uint32_t encodingArrSize = 0u;
uint32_t digestSize = 0u;
uint32_t locDigestSize = 0u;
uint32_t i;
uint32_t psLength;
uint32_t cmpRes = 0u;
@ -172,7 +177,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
case CY_CRYPTO_MODE_SHA1:
encodingArr = sha1EncStr;
encodingArrSize = sizeof(sha1EncStr);
digestSize = CY_CRYPTO_SHA1_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA1_DIGEST_SIZE;
break;
#endif /* #if (CPUSS_CRYPTO_SHA1 == 1) */
@ -180,13 +185,13 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
case CY_CRYPTO_MODE_SHA224:
encodingArr = sha224EncStr;
encodingArrSize = sizeof(sha224EncStr);
digestSize = CY_CRYPTO_SHA224_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA224_DIGEST_SIZE;
break;
case CY_CRYPTO_MODE_SHA256:
encodingArr = sha256EncStr;
encodingArrSize = sizeof(sha256EncStr);
digestSize = CY_CRYPTO_SHA256_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA256_DIGEST_SIZE;
break;
#endif /* #if (CPUSS_CRYPTO_SHA256 == 1) */
@ -194,25 +199,25 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
case CY_CRYPTO_MODE_SHA384:
encodingArr = sha384EncStr;
encodingArrSize = sizeof(sha384EncStr);
digestSize = CY_CRYPTO_SHA384_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA384_DIGEST_SIZE;
break;
case CY_CRYPTO_MODE_SHA512:
encodingArr = sha512EncStr;
encodingArrSize = sizeof(sha512EncStr);
digestSize = CY_CRYPTO_SHA512_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA512_DIGEST_SIZE;
break;
case CY_CRYPTO_MODE_SHA512_224:
encodingArr = sha512_224EncStr;
encodingArrSize = sizeof(sha512_224EncStr);
digestSize = CY_CRYPTO_SHA512_224_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA512_224_DIGEST_SIZE;
break;
case CY_CRYPTO_MODE_SHA512_256:
encodingArr = sha512_256EncStr;
encodingArrSize = sizeof(sha512_256EncStr);
digestSize = CY_CRYPTO_SHA512_256_DIGEST_SIZE;
locDigestSize = CY_CRYPTO_SHA512_256_DIGEST_SIZE;
break;
#endif /* #if (CPUSS_CRYPTO_SHA512 == 1) */
@ -224,12 +229,12 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
*verResult = CY_CRYPTO_RSA_VERIFY_FAIL;
/* Check size of decrypted message */
if (decryptedSignatureLength < (encodingArrSize + digestSize + 11u))
if (decryptedSignatureLength < (encodingArrSize + locDigestSize + 11u))
{
cmpRes = 1u; /* further checking is not needed */
}
psLength = decryptedSignatureLength - digestSize - encodingArrSize - 3u;
psLength = decryptedSignatureLength - locDigestSize - encodingArrSize - 3u;
/* Check whether the begin of message is 0x00, 0x01 and after PS string (before T string) is 0x00 byte.*/
if ( (0u != cmpRes) ||
@ -265,8 +270,8 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
if (0u == cmpRes)
{
cmpRes = Cy_Crypto_Core_MemCmp(base, digest,
(decryptedSignature + (decryptedSignatureLength - digestSize)),
(uint16_t)digestSize);
(decryptedSignature + (decryptedSignatureLength - locDigestSize)),
(uint16_t)locDigestSize);
}
if (0u == cmpRes )
@ -274,9 +279,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
*verResult = CY_CRYPTO_RSA_VERIFY_SUCCESS;
}
return (myResult);
return (tmpResult);
}
/** \} group_crypto_lld_asymmetric_functions */
#if (CPUSS_CRYPTO_VU == 1)
@ -297,7 +303,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
* where R = 1 << size.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param modDerReg
* Register index for Montgomery coefficient value.
@ -306,17 +312,17 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Verify(CRYPTO_Type *base,
* Register index for modulo value.
*
* \param size
* Size of modulo, in Bits.
* Modulo size in bits.
*
*******************************************************************************/
static void Cy_Crypto_Core_Rsa_MontCoeff(CRYPTO_Type *base, uint32_t modDerReg, uint32_t modReg, uint32_t size)
{
uint32_t myMod = 9u;
uint32_t tmp = 10u;
uint32_t a = 11u;
uint32_t b = 12u;
uint32_t u = 13u;
uint32_t v = 14u;
uint32_t ra = 11u;
uint32_t rb = 12u;
uint32_t ru = 13u;
uint32_t rv = 14u;
uint32_t status;
uint32_t aZero;
@ -324,27 +330,27 @@ static void Cy_Crypto_Core_Rsa_MontCoeff(CRYPTO_Type *base, uint32_t modDerReg,
CY_CRYPTO_VU_PUSH_REG (base);
CY_CRYPTO_VU_LD_REG (base, v, modDerReg);
CY_CRYPTO_VU_LD_REG (base, rv, modDerReg);
CY_CRYPTO_VU_LD_REG (base, myMod, modReg);
CY_CRYPTO_VU_ALLOC_MEM (base, a, size);
CY_CRYPTO_VU_ALLOC_MEM (base, b, size);
CY_CRYPTO_VU_ALLOC_MEM (base, u, size);
CY_CRYPTO_VU_ALLOC_MEM (base, ra, size);
CY_CRYPTO_VU_ALLOC_MEM (base, rb, size);
CY_CRYPTO_VU_ALLOC_MEM (base, ru, size);
CY_CRYPTO_VU_SET_TO_ONE (base, u);
CY_CRYPTO_VU_SET_TO_ZERO (base, v);
CY_CRYPTO_VU_SET_TO_ONE (base, ru);
CY_CRYPTO_VU_SET_TO_ZERO (base, rv);
CY_CRYPTO_VU_SET_TO_ZERO (base, a);
CY_CRYPTO_VU_SET_TO_ZERO (base, ra);
CY_CRYPTO_VU_SET_REG (base, tmp, (size - 1u), 1u);
CY_CRYPTO_VU_SET_BIT (base, a, tmp);
CY_CRYPTO_VU_MOV (base, b, myMod);
CY_CRYPTO_VU_SET_BIT (base, ra, tmp);
CY_CRYPTO_VU_MOV (base, rb, myMod);
while (1)
{
Cy_Crypto_Core_WaitForReady(base);
CY_CRYPTO_VU_TST(base, a);
CY_CRYPTO_VU_TST(base, ra);
status = Cy_Crypto_Core_Vu_StatusRead(base);
aZero = status & CY_CRYPTO_VU_STATUS_ZERO_BIT;
@ -354,27 +360,27 @@ static void Cy_Crypto_Core_Rsa_MontCoeff(CRYPTO_Type *base, uint32_t modDerReg,
break;
}
CY_CRYPTO_VU_LSR1(base, a, a);
CY_CRYPTO_VU_LSR1(base, ra, ra);
CY_CRYPTO_VU_TST(base, u);
CY_CRYPTO_VU_TST(base, ru);
status = Cy_Crypto_Core_Vu_StatusRead(base);
uEven = status & CY_CRYPTO_VU_STATUS_EVEN_BIT;
if (uEven != 0u)
{
CY_CRYPTO_VU_LSR1(base, u, u);
CY_CRYPTO_VU_LSR1(base, v, v);
CY_CRYPTO_VU_LSR1(base, ru, ru);
CY_CRYPTO_VU_LSR1(base, rv, rv);
}
else
{
CY_CRYPTO_VU_ADD(base, u, u, b);
CY_CRYPTO_VU_LSR1_WITH_CARRY(base, u, u);
CY_CRYPTO_VU_LSR1(base, v, v);
CY_CRYPTO_VU_SET_BIT(base, v, tmp);
CY_CRYPTO_VU_ADD(base, ru, ru, rb);
CY_CRYPTO_VU_LSR1_WITH_CARRY(base, ru, ru);
CY_CRYPTO_VU_LSR1(base, rv, rv);
CY_CRYPTO_VU_SET_BIT(base, rv, tmp);
}
}
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(a) | CY_CRYPTO_VU_REG_BIT(b) | CY_CRYPTO_VU_REG_BIT(u));
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(ra) | CY_CRYPTO_VU_REG_BIT(rb) | CY_CRYPTO_VU_REG_BIT(ru));
CY_CRYPTO_VU_POP_REG(base);
}
@ -392,7 +398,7 @@ static void Cy_Crypto_Core_Rsa_MontCoeff(CRYPTO_Type *base, uint32_t modDerReg,
* barrett = (1 << (2 * size)) / mod NO!!! leading '1' Barrett bit.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param barrettUReg
* Register index for Barrett reduction value.
@ -400,8 +406,8 @@ static void Cy_Crypto_Core_Rsa_MontCoeff(CRYPTO_Type *base, uint32_t modDerReg,
* \param modReg
* Register index for modulo value.
*
* \param
* Size modulo size in Bits.
* \param size
* The modulo size in bits.
*
*******************************************************************************/
static void Cy_Crypto_Core_Rsa_BarrettGetU(CRYPTO_Type *base, uint32_t barrettUReg, uint32_t modReg, uint32_t size)
@ -447,7 +453,7 @@ static void Cy_Crypto_Core_Rsa_BarrettGetU(CRYPTO_Type *base, uint32_t barrettUR
* z = (a << size) % mod
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param z
* Register index for Montgomery representation value.
@ -521,7 +527,7 @@ static void Cy_Crypto_Core_Rsa_MontTransform(CRYPTO_Type *base, uint32_t z, uint
* u = IF (u >= mod) u = u - mod
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param z
* Register index for product value.
@ -561,7 +567,7 @@ static void Cy_Crypto_Core_Rsa_MontMul(CRYPTO_Type *base,
CY_CRYPTO_VU_UMUL (base, tDouble, a, b);
/* Only lower 32 bits are needed */
/* Only the lower 32 bits are needed. */
CY_CRYPTO_VU_UMUL (base, t, tDouble, montModDer);
/* Clear the MSB bit (cut to size length) */
@ -605,7 +611,7 @@ static void Cy_Crypto_Core_Rsa_MontMul(CRYPTO_Type *base,
* calculation. Suitable for cases with short e.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param y
* Register index for calculated value.
@ -619,8 +625,17 @@ static void Cy_Crypto_Core_Rsa_MontMul(CRYPTO_Type *base,
* \param n
* Register index for modulo value.
*
* \param barretCoef
* Barrett coefficient.
*
* \param inverseModulo
* Binary inverse of the modulo.
*
* \param rBar
* Values of (2^moduloLength mod modulo).
*
* \param size
* modulo size, in Bits
* The modulo size in bits.
*
*******************************************************************************/
static void Cy_Crypto_Core_Rsa_expModByMont(CRYPTO_Type *base,
@ -720,6 +735,11 @@ static void Cy_Crypto_Core_Rsa_expModByMont(CRYPTO_Type *base,
CY_CRYPTO_VU_POP_REG(base);
}
/**
* \addtogroup group_crypto_lld_asymmetric_functions
* \{
*/
/*******************************************************************************
* Function Name: Cy_Crypto_Core_Rsa_Proc
****************************************************************************//**
@ -730,7 +750,7 @@ static void Cy_Crypto_Core_Rsa_expModByMont(CRYPTO_Type *base,
* https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param key
* The pointer to the \ref cy_stc_crypto_rsa_pub_key_t structure that stores
@ -746,7 +766,7 @@ static void Cy_Crypto_Core_Rsa_expModByMont(CRYPTO_Type *base,
* The pointer to processed message.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Proc(CRYPTO_Type *base,
@ -755,7 +775,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Proc(CRYPTO_Type *base,
uint32_t messageSize,
uint8_t *processedMessage)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_SUCCESS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
uint8_t *expPtr = key->pubExpPtr;
uint32_t expBitLength = key->pubExpLength;
@ -834,7 +854,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Proc(CRYPTO_Type *base,
Cy_Crypto_Core_Vu_WaitForComplete(base);
/* Copy the myResult to output buffer */
/* Copy the tmpResult to output buffer */
Cy_Crypto_Core_Vu_GetMemValue(base, (uint8_t*)processedMessage, yReg, nBitLength);
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(yReg) | CY_CRYPTO_VU_REG_BIT(xReg) |
@ -842,7 +862,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Proc(CRYPTO_Type *base,
CY_CRYPTO_VU_REG_BIT(inverseModuloReg) |
CY_CRYPTO_VU_REG_BIT(barrettReg) | CY_CRYPTO_VU_REG_BIT(rBarReg));
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -856,20 +876,20 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Proc(CRYPTO_Type *base,
* result of (2^moduloLength mod modulo)
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param key
* The pointer to the \ref cy_stc_crypto_rsa_pub_key_t structure that stores a
* public key.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Coef(CRYPTO_Type *base,
cy_stc_crypto_rsa_pub_key_t const *key)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_SUCCESS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
uint8_t *nPtr = key->moduloPtr;
uint32_t nBitLength = key->moduloLength;
@ -916,9 +936,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_Rsa_Coef(CRYPTO_Type *base,
CY_CRYPTO_VU_FREE_MEM(base, CY_CRYPTO_VU_REG_BIT(modReg) | CY_CRYPTO_VU_REG_BIT(inverseModuloReg) | CY_CRYPTO_VU_REG_BIT(barrettReg) | CY_CRYPTO_VU_REG_BIT(rBarReg));
return (myResult);
return (tmpResult);
}
/** \} group_crypto_lld_asymmetric_functions */
#endif /* #if (CPUSS_CRYPTO_VU == 1) */
#endif /* CY_IP_MXCRYPTO */

149
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_sha_v1.c
View File

@ -39,15 +39,15 @@
typedef enum
{
#if (CPUSS_CRYPTO_SHA1 == 1)
CY_CRYPTO_V1_SHA_CTL_MODE_SHA1 = 0u,
CY_CRYPTO_V1_SHA_CTL_MODE_SHA1 = 0U,
#endif /* #if (CPUSS_CRYPTO_SHA1 == 1) */
#if (CPUSS_CRYPTO_SHA256 == 1)
CY_CRYPTO_V1_SHA_CTL_MODE_SHA256 = 1u,
CY_CRYPTO_V1_SHA_CTL_MODE_SHA256 = 1U,
#endif /* #if (CPUSS_CRYPTO_SHA256 == 1) */
#if (CPUSS_CRYPTO_SHA512 == 1)
CY_CRYPTO_V1_SHA_CTL_MODE_SHA512 = 2u,
CY_CRYPTO_V1_SHA_CTL_MODE_SHA512 = 2U,
#endif /* #if (CPUSS_CRYPTO_SHA512 == 1) */
} cy_en_crypto_v1_sha_hw_mode_t;
@ -60,7 +60,7 @@ typedef enum
* All addresses must be 4-Byte aligned!
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to a Hash State.
@ -99,7 +99,7 @@ void Cy_Crypto_Core_V1_Sha_ProcessBlock(CRYPTO_Type *base,
* The function to initialize SHA operation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to a Hash State.
@ -109,10 +109,10 @@ void Cy_Crypto_Core_V1_Sha_ProcessBlock(CRYPTO_Type *base,
* CY_CRYPTO_SHA512, CY_CRYPTO_SHA384, CY_CRYPTO_SHA512_224, CY_CRYPTO_SHA512_256
*
* \param shaBuffers
* The pointer to memory buffers storage
* The pointer to the memory buffers storage.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
@ -120,6 +120,8 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
cy_en_crypto_sha_mode_t mode,
void *shaBuffers)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
/* Initialization vectors for different modes of the SHA algorithm */
#if (CPUSS_CRYPTO_SHA1 == 1)
static const uint32_t sha1InitHash[] =
@ -190,7 +192,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
#if (CPUSS_CRYPTO_SHA1 == 1)
case CY_CRYPTO_MODE_SHA1:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha1_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha1_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha1_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha1_buffers_t*)shaBuffers)->hash;
@ -208,7 +210,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
#if (CPUSS_CRYPTO_SHA256 == 1)
case CY_CRYPTO_MODE_SHA224:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha256_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha256_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha256_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha256_buffers_t*)shaBuffers)->hash;
@ -223,7 +225,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
break;
case CY_CRYPTO_MODE_SHA256:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha256_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha256_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha256_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha256_buffers_t*)shaBuffers)->hash;
@ -241,7 +243,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
#if (CPUSS_CRYPTO_SHA512 == 1)
case CY_CRYPTO_MODE_SHA384:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->hash;
@ -255,7 +257,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
break;
case CY_CRYPTO_MODE_SHA512:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->hash;
@ -269,7 +271,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
break;
case CY_CRYPTO_MODE_SHA512_224:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->hash;
@ -283,7 +285,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
break;
case CY_CRYPTO_MODE_SHA512_256:
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00u, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
Cy_Crypto_Core_V1_MemSet(base, shaBuffers, 0x00U, sizeof(cy_stc_crypto_v1_sha512_buffers_t));
hashState->block = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->block;
hashState->hash = (uint8_t*)((cy_stc_crypto_v1_sha512_buffers_t*)shaBuffers)->hash;
@ -298,13 +300,14 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
#endif /* #if (CPUSS_CRYPTO_SHA512 == 1) */
default:
tmpResult = CY_CRYPTO_BAD_PARAMS;
break;
}
/* Set the SHA mode */
REG_CRYPTO_SHA_CTL(base) = (uint32_t)(_VAL2FLD(CRYPTO_SHA_CTL_MODE, (uint32_t)shaHwMode));
return (CY_CRYPTO_SUCCESS);
return (tmpResult);
}
/*******************************************************************************
@ -314,33 +317,33 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Init(CRYPTO_Type *base,
* Initializes the initial hash vector.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Start(CRYPTO_Type *base, cy_stc_crypto_sha_state_t *hashState)
{
hashState->blockIdx = 0u;
hashState->messageSize = 0u;
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if (hashState != NULL)
{
if (hashState->hashSize != 0)
hashState->blockIdx = 0U;
hashState->messageSize = 0U;
if (hashState->hashSize != 0U)
{
Cy_Crypto_Core_V1_MemCpy(base, hashState->hash, hashState->initialHash, (uint16_t)hashState->hashSize);
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -350,7 +353,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Start(CRYPTO_Type *base, cy_stc_cryp
* Performs the SHA calculation on one message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
@ -362,12 +365,12 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Start(CRYPTO_Type *base, cy_stc_cryp
* The size of the message whose Hash is being computed.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \note
* This function can be called several times only with message lengths dividable
* by block size. Only the last call to the function can process a message with
* the not dividable size.
* by the block size. Only the last call to the function can process a message with
* a not-dividable size.
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Update(CRYPTO_Type *base,
@ -375,13 +378,13 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Update(CRYPTO_Type *base,
uint8_t const *message,
uint32_t messageSize)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if ((hashState != NULL) && (message != NULL))
{
if (hashState->blockSize != 0)
if (hashState->blockSize != 0U)
{
if (messageSize > 0)
if (messageSize != 0U)
{
uint32_t blockSizeTmp = hashState->blockSize;
hashState->messageSize += messageSize;
@ -394,28 +397,28 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Update(CRYPTO_Type *base,
messageSize -= blockSizeTmp;
}
/* Remaining block will be calculated in Finish function */
/* The remaining block will be calculated in the Finish function. */
hashState->blockIdx = messageSize;
/* Copy the end of the message to the block */
Cy_Crypto_Core_V1_MemCpy(base, hashState->block, message, (uint16_t)(messageSize & (blockSizeTmp - 1u)));
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_V1_Sha_Finish
****************************************************************************//**
*
* Completes SHA calculation.
* Completes the SHA calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
@ -424,14 +427,14 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Update(CRYPTO_Type *base,
* The pointer to the calculated hash digest.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Finish(CRYPTO_Type *base,
cy_stc_crypto_sha_state_t *hashState,
uint8_t *digest)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if ((hashState != NULL) && (digest != NULL))
{
@ -439,7 +442,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Finish(CRYPTO_Type *base,
uint8_t *blockTmp = hashState->block;
uint32_t blockSizeTmp = hashState->blockSize;
uint32_t blockIdxTmp = hashState->blockIdx;
uint64_t finalMessageSizeInBits = (uint64_t)hashState->messageSize * 8u;
uint64_t finalMessageSizeInBits = (uint64_t)hashState->messageSize * 8U;
uint32_t size;
if (CY_CRYPTO_SHA512_BLOCK_SIZE == blockSizeTmp)
@ -452,10 +455,10 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Finish(CRYPTO_Type *base,
}
/* Append 1 bit to the end of the message */
blockTmp[blockIdxTmp] = 0x80u;
blockTmp[blockIdxTmp] = 0x80U;
/* Clear the rest of the block */
Cy_Crypto_Core_V1_MemSet(base, (void* )&blockTmp[blockIdxTmp + 1u], 0x00u, (uint16_t)(blockSizeTmp - blockIdxTmp - 1u));
Cy_Crypto_Core_V1_MemSet(base, (void* )&blockTmp[blockIdxTmp + 1U], 0x00U, (uint16_t)(blockSizeTmp - blockIdxTmp - 1U));
if (blockIdxTmp >= size)
{
@ -466,32 +469,32 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Finish(CRYPTO_Type *base,
Cy_Crypto_Core_V1_MemSet(base, blockTmp, 0x00u, (uint16_t)blockSizeTmp);
}
blockTmp[blockSizeTmp - 4u] = (uint8_t)((finalMessageSizeInBits) >> 24u);
blockTmp[blockSizeTmp - 3u] = (uint8_t)((finalMessageSizeInBits) >> 16u);
blockTmp[blockSizeTmp - 2u] = (uint8_t)((finalMessageSizeInBits) >> 8u);
blockTmp[blockSizeTmp - 1u] = (uint8_t)(finalMessageSizeInBits);
blockTmp[blockSizeTmp - 4U] = (uint8_t)((finalMessageSizeInBits) >> 24U);
blockTmp[blockSizeTmp - 3U] = (uint8_t)((finalMessageSizeInBits) >> 16U);
blockTmp[blockSizeTmp - 2U] = (uint8_t)((finalMessageSizeInBits) >> 8U);
blockTmp[blockSizeTmp - 1U] = (uint8_t)(finalMessageSizeInBits);
/* Process the last block */
Cy_Crypto_Core_V1_Sha_ProcessBlock(base, hashState, (uint8_t*)blockTmp);
/* Invert endians of the hash and copy it to digest, re-use the size variable */
size = (uint32_t)(hashState->digestSize / 4u);
size = (uint32_t)(hashState->digestSize / 4U);
for(; size != 0u; size--)
for(; size != 0U; size--)
{
*(digest) = *(hashTmp+3);
*(digest+1) = *(hashTmp+2);
*(digest+2) = *(hashTmp+1);
*(digest+3) = *(hashTmp);
digest += 4;
hashTmp += 4;
digest += 4U;
hashTmp += 4U;
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -501,30 +504,30 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Finish(CRYPTO_Type *base,
* Clears the used memory buffers.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Free(CRYPTO_Type *base, cy_stc_crypto_sha_state_t *hashState)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if (hashState != NULL)
{
/* Clears the memory buffer. */
Cy_Crypto_Core_V1_MemSet(base, hashState->block, 0x00u, (uint16_t)hashState->blockSize);
Cy_Crypto_Core_V1_MemSet(base, hashState->hash, 0x00u, (uint16_t)hashState->hashSize);
Cy_Crypto_Core_V1_MemSet(base, hashState->roundMem, 0x00u, (uint16_t)hashState->roundMemSize);
Cy_Crypto_Core_V1_MemSet(base, hashState->block, 0x00U, (uint16_t)hashState->blockSize);
Cy_Crypto_Core_V1_MemSet(base, hashState->hash, 0x00U, (uint16_t)hashState->hashSize);
Cy_Crypto_Core_V1_MemSet(base, hashState->roundMem, 0x00U, (uint16_t)hashState->roundMemSize);
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
return (myResult);
return (tmpResult);
}
@ -535,7 +538,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Free(CRYPTO_Type *base, cy_stc_crypt
* Performs the SHA Hash function.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param mode
* \ref cy_en_crypto_sha_mode_t
@ -550,7 +553,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha_Free(CRYPTO_Type *base, cy_stc_crypt
* The pointer to the hash digest.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha(CRYPTO_Type *base,
@ -559,31 +562,31 @@ cy_en_crypto_status_t Cy_Crypto_Core_V1_Sha(CRYPTO_Type *base,
uint8_t *digest,
cy_en_crypto_sha_mode_t mode)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
void *shaBuffers = (void *)REG_CRYPTO_MEM_BUFF(base);
cy_stc_crypto_sha_state_t myHashState;
cy_stc_crypto_sha_state_t myHashState = { 0 };
myResult = Cy_Crypto_Core_V1_Sha_Init (base, &myHashState, mode, shaBuffers);
tmpResult = Cy_Crypto_Core_V1_Sha_Init (base, &myHashState, mode, shaBuffers);
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V1_Sha_Start (base, &myHashState);
tmpResult = Cy_Crypto_Core_V1_Sha_Start (base, &myHashState);
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V1_Sha_Update (base, &myHashState, message, messageSize);
tmpResult = Cy_Crypto_Core_V1_Sha_Update (base, &myHashState, message, messageSize);
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V1_Sha_Finish (base, &myHashState, digest);
tmpResult = Cy_Crypto_Core_V1_Sha_Finish (base, &myHashState, digest);
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V1_Sha_Free (base, &myHashState);
tmpResult = Cy_Crypto_Core_V1_Sha_Free (base, &myHashState);
}
return (myResult);
return (tmpResult);
}

123
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_sha_v2.c
View File

@ -42,7 +42,7 @@
* The function to initialize SHA operation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to a Hash State.
@ -52,10 +52,10 @@
* CY_CRYPTO_SHA512, CY_CRYPTO_SHA384, CY_CRYPTO_SHA512_224, CY_CRYPTO_SHA512_256
*
* \param shaBuffers
* The pointer to memory buffers storage
* The pointer to the memory buffers storage.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Init(CRYPTO_Type *base,
@ -63,6 +63,8 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Init(CRYPTO_Type *base,
cy_en_crypto_sha_mode_t mode,
void *shaBuffers)
{
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
/* Initialization vectors for different modes of the SHA algorithm */
#if (CPUSS_CRYPTO_SHA1 == 1)
static const uint8_t sha1InitHash[] =
@ -149,7 +151,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Init(CRYPTO_Type *base,
CY_ASSERT_L1(hashState != NULL);
Cy_Crypto_Core_V2_MemSet(base, hashState, 0x00u, sizeof(cy_stc_crypto_sha_state_t));
Cy_Crypto_Core_V2_MemSet(base, hashState, 0x00U, sizeof(cy_stc_crypto_sha_state_t));
switch (mode)
{
@ -209,10 +211,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Init(CRYPTO_Type *base,
break;
#endif /* #if (CPUSS_CRYPTO_SHA512 == 1) */
default:
tmpResult = CY_CRYPTO_BAD_PARAMS;
break;
}
return (CY_CRYPTO_SUCCESS);
return (tmpResult);
}
/*******************************************************************************
@ -222,39 +225,39 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Init(CRYPTO_Type *base,
* Initializes the initial hash vector.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Start(CRYPTO_Type *base, cy_stc_crypto_sha_state_t *hashState)
{
hashState->blockIdx = 0u;
hashState->messageSize = 0u;
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if (hashState != NULL)
{
if (hashState->hashSize != 0)
hashState->blockIdx = 0U;
hashState->messageSize = 0U;
if (hashState->hashSize != 0U)
{
Cy_Crypto_Core_V2_RBClear(base);
Cy_Crypto_Core_V2_Sync(base);
Cy_Crypto_Core_V2_FFStart(base, CY_CRYPTO_V2_RB_FF_LOAD0, hashState->initialHash, hashState->hashSize);
Cy_Crypto_Core_V2_RBXor(base, 0u, hashState->hashSize);
Cy_Crypto_Core_V2_RBXor(base, 0U, hashState->hashSize);
Cy_Crypto_Core_V2_Sync(base);
Cy_Crypto_Core_V2_RBSwap(base);
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -264,7 +267,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Start(CRYPTO_Type *base, cy_stc_cryp
* Performs the SHA calculation on one message.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
@ -276,12 +279,12 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Start(CRYPTO_Type *base, cy_stc_cryp
* The size of the message whose Hash is being computed.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* \note
* This function can be called several times only with message lengths dividable
* by block size. Only the last call to the function can process a message with
* the not dividable size.
* by the block size. Only the last call to the function can process a message with
* a not-dividable size.
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Update(CRYPTO_Type *base,
@ -289,13 +292,13 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Update(CRYPTO_Type *base,
uint8_t const *message,
uint32_t messageSize)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if ((hashState != NULL) && (message != NULL))
{
if (hashState->blockSize != 0)
if (hashState->blockSize != 0U)
{
if (messageSize > 0)
if (messageSize != 0U)
{
hashState->messageSize += messageSize;
@ -303,7 +306,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Update(CRYPTO_Type *base,
while (messageSize >= hashState->blockSize)
{
Cy_Crypto_Core_V2_RBXor(base, 0u, hashState->blockSize);
Cy_Crypto_Core_V2_RBXor(base, 0U, hashState->blockSize);
messageSize -= hashState->blockSize;
@ -314,11 +317,11 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Update(CRYPTO_Type *base,
hashState->blockIdx = messageSize;
}
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -328,7 +331,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Update(CRYPTO_Type *base,
* Completes SHA calculation.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
@ -337,21 +340,21 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Update(CRYPTO_Type *base,
* The pointer to the calculated hash digest.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Finish(CRYPTO_Type *base,
cy_stc_crypto_sha_state_t *hashState,
uint8_t *digest)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if ((hashState != NULL) && (digest != NULL))
{
uint32_t myBlockSize = hashState->blockSize;
uint32_t myBlockIdx = hashState->blockIdx;
uint64_t finalMessageSizeInBits = (uint64_t)hashState->messageSize * 8u;
uint64_t finalMessageSizeInBits = (uint64_t)hashState->messageSize * 8U;
uint32_t size;
if (CY_CRYPTO_SHA512_BLOCK_SIZE == myBlockSize)
@ -364,13 +367,13 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Finish(CRYPTO_Type *base,
}
/* Load the end of the message (tail that less then block size) to the register buffer */
Cy_Crypto_Core_V2_RBXor(base, 0u, myBlockIdx);
Cy_Crypto_Core_V2_RBXor(base, 0U, myBlockIdx);
/* Sync until XOR operation is completed */
Cy_Crypto_Core_V2_Sync(base);
/* Append 1 bit to the end of the message */
Cy_Crypto_Core_V2_RBSetByte(base, myBlockIdx, 0x80u);
Cy_Crypto_Core_V2_RBSetByte(base, myBlockIdx, 0x80U);
if (myBlockIdx >= size)
{
@ -381,12 +384,12 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Finish(CRYPTO_Type *base,
/* Append message size into last of the block */
/* In case of u32SizeInByte * 8 > u32Max */
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 5u, (uint8_t)(finalMessageSizeInBits >> 32u));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 5U, (uint8_t)(finalMessageSizeInBits >> 32U));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 4u, (uint8_t)(finalMessageSizeInBits >> 24u));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 3u, (uint8_t)(finalMessageSizeInBits >> 16u));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 2u, (uint8_t)(finalMessageSizeInBits >> 8u));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 1u, (uint8_t)(finalMessageSizeInBits));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 4U, (uint8_t)(finalMessageSizeInBits >> 24U));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 3U, (uint8_t)(finalMessageSizeInBits >> 16U));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 2U, (uint8_t)(finalMessageSizeInBits >> 8U));
Cy_Crypto_Core_V2_RBSetByte(base, myBlockSize - 1U, (uint8_t)(finalMessageSizeInBits));
Cy_Crypto_Core_V2_Run(base, hashState->mode);
Cy_Crypto_Core_V2_Sync(base);
@ -394,14 +397,14 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Finish(CRYPTO_Type *base,
/* Write digest. */
Cy_Crypto_Core_V2_FFStart(base, CY_CRYPTO_V2_RB_FF_STORE, digest, hashState->digestSize);
Cy_Crypto_Core_V2_RBSwap(base);
Cy_Crypto_Core_V2_RBStore(base, 0u, hashState->digestSize);
Cy_Crypto_Core_V2_RBStore(base, 0U, hashState->digestSize);
Cy_Crypto_Core_V2_FFStoreSync(base);
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -411,31 +414,31 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Finish(CRYPTO_Type *base,
* Clears the used memory buffers.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param hashState
* The pointer to the SHA context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
* *******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Free(CRYPTO_Type *base, cy_stc_crypto_sha_state_t *hashState)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
if (hashState != NULL)
{
Cy_Crypto_Core_V2_MemSet(base, hashState, 0x00u, sizeof(cy_stc_crypto_sha_state_t));
Cy_Crypto_Core_V2_MemSet(base, hashState, 0x00U, sizeof(cy_stc_crypto_sha_state_t));
/* Clears the memory buffer. */
Cy_Crypto_Core_V2_RBClear(base);
Cy_Crypto_Core_V2_Sync(base);
myResult = CY_CRYPTO_SUCCESS;
tmpResult = CY_CRYPTO_SUCCESS;
}
return (myResult);
return (tmpResult);
}
/*******************************************************************************
@ -445,7 +448,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Free(CRYPTO_Type *base, cy_stc_crypt
* Performs the SHA Hash function.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param mode
* \ref cy_en_crypto_sha_mode_t
@ -460,7 +463,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha_Free(CRYPTO_Type *base, cy_stc_crypt
* The pointer to the hash digest.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha(CRYPTO_Type *base,
@ -469,32 +472,32 @@ cy_en_crypto_status_t Cy_Crypto_Core_V2_Sha(CRYPTO_Type *base,
uint8_t *digest,
cy_en_crypto_sha_mode_t mode)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_BAD_PARAMS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_BAD_PARAMS;
/* Allocate space for the structure which stores the SHA context */
cy_stc_crypto_sha_state_t hashState;
cy_stc_crypto_sha_state_t hashState = { 0 };
/* No any buffers needed for Crypto_ver2 IP block */
myResult = Cy_Crypto_Core_V2_Sha_Init (base, &hashState, mode, NULL);
/* No buffers are needed for the Crypto_ver2 IP block. */
tmpResult = Cy_Crypto_Core_V2_Sha_Init (base, &hashState, mode, NULL);
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V2_Sha_Start (base, &hashState);
tmpResult = Cy_Crypto_Core_V2_Sha_Start (base, &hashState);
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V2_Sha_Update (base, &hashState, message, messageSize);
tmpResult = Cy_Crypto_Core_V2_Sha_Update (base, &hashState, message, messageSize);
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V2_Sha_Finish (base, &hashState, digest);
tmpResult = Cy_Crypto_Core_V2_Sha_Finish (base, &hashState, digest);
}
if (CY_CRYPTO_SUCCESS == myResult)
if (CY_CRYPTO_SUCCESS == tmpResult)
{
myResult = Cy_Crypto_Core_V2_Sha_Free (base, &hashState);
tmpResult = Cy_Crypto_Core_V2_Sha_Free (base, &hashState);
}
return (myResult);
return (tmpResult);
}

12
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_trng_v1.c
View File

@ -41,10 +41,10 @@ static void Cy_Crypto_Core_V1_Trng_Init(CRYPTO_Type *base);
* Function Name: Cy_Crypto_Core_V1_Trng_Init
****************************************************************************//**
*
* Initializes the TRND parameters.
* Initializes the TRNG parameters.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
static void Cy_Crypto_Core_V1_Trng_Init(CRYPTO_Type *base)
@ -57,15 +57,15 @@ static void Cy_Crypto_Core_V1_Trng_Init(CRYPTO_Type *base)
REG_CRYPTO_TR_MON_AP_CTL(base) = CY_CRYPTO_V1_TR_AC_CUTOFF;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_V1_Trng
****************************************************************************//**
*
* Generates a True Random Number and returns it in the
* cfContext->trngNumPtr.
* Generates a True Random Number.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param GAROPol
* The polynomial for the programmable Galois ring oscillator.
@ -80,7 +80,7 @@ static void Cy_Crypto_Core_V1_Trng_Init(CRYPTO_Type *base)
* The pointer to a generated true random number. Must be 4-byte aligned.
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V1_Trng(CRYPTO_Type *base,

12
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_trng_v2.c
View File

@ -40,10 +40,10 @@ static void Cy_Crypto_Core_V2_Trng_Init(CRYPTO_Type *base);
* Function Name: Cy_Crypto_Core_V2_Trng_Init
****************************************************************************//**
*
* Initializes the TRND parameters.
* Initializes the TRNG parameters.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
*******************************************************************************/
static void Cy_Crypto_Core_V2_Trng_Init(CRYPTO_Type *base)
@ -56,15 +56,15 @@ static void Cy_Crypto_Core_V2_Trng_Init(CRYPTO_Type *base)
REG_CRYPTO_TR_MON_AP_CTL(base) = CY_CRYPTO_V2_TR_AC_CUTOFF;
}
/*******************************************************************************
* Function Name: Cy_Crypto_Core_V2_Trng
****************************************************************************//**
*
* Generates a True Random Number and returns it in the
* cfContext->trngNumPtr.
* Generates a True Random Number.
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param GAROPol
* The polynomial for the programmable Galois ring oscillator.
@ -79,7 +79,7 @@ static void Cy_Crypto_Core_V2_Trng_Init(CRYPTO_Type *base)
* The pointer to a generated true random number. Must be 4-byte aligned.
*
* \return
* A Crypto status \ref en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
cy_en_crypto_status_t Cy_Crypto_Core_V2_Trng(CRYPTO_Type *base,

52
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_core_vu.c
View File

@ -46,7 +46,7 @@ void Cy_Crypto_Core_Vu_SetMemValue(CRYPTO_Type *base, uint32_t dstReg, uint8_t c
Cy_Crypto_Core_Vu_WaitForComplete(base);
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
CY_CRYPTO_VU_SAVE_REG(base, CY_CRYPTO_VU_HW_REG0, &reg0_data);
CY_CRYPTO_VU_SAVE_REG(base, CY_CRYPTO_VU_HW_REG1, &reg1_data);
@ -61,10 +61,10 @@ void Cy_Crypto_Core_Vu_SetMemValue(CRYPTO_Type *base, uint32_t dstReg, uint8_t c
CY_ASSERT_L1(size <= Cy_Crypto_Core_Vu_RegBitSizeRead(base, dstReg));
CY_ASSERT_L1(((uint32_t)Cy_Crypto_Core_Vu_RegMemPointer(base, dstReg) + byteSize - 1) < ((uint32_t)REG_CRYPTO_MEM_BUFF(base) + CY_CRYPTO_MEM_BUFF_SIZE) );
CY_ASSERT_L1( (((uint32_t)Cy_Crypto_Core_Vu_RegMemPointer(base, dstReg) + byteSize) - 1u) < ((uint32_t)REG_CRYPTO_MEM_BUFF(base) + CY_CRYPTO_MEM_BUFF_SIZE));
Cy_Crypto_Core_MemCpy(base, (void*)Cy_Crypto_Core_Vu_RegMemPointer(base, dstReg), (const void*)src, byteSize);
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
CY_CRYPTO_VU_RESTORE_REG(base, CY_CRYPTO_VU_HW_REG0, reg0_data);
CY_CRYPTO_VU_RESTORE_REG(base, CY_CRYPTO_VU_HW_REG1, reg1_data);
@ -78,7 +78,7 @@ void Cy_Crypto_Core_Vu_GetMemValue(CRYPTO_Type *base, uint8_t *dst, uint32_t src
Cy_Crypto_Core_Vu_WaitForComplete(base);
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
CY_CRYPTO_VU_SAVE_REG(base, CY_CRYPTO_VU_HW_REG0, &reg0_data);
CY_CRYPTO_VU_SAVE_REG(base, CY_CRYPTO_VU_HW_REG1, &reg1_data);
@ -92,11 +92,11 @@ void Cy_Crypto_Core_Vu_GetMemValue(CRYPTO_Type *base, uint8_t *dst, uint32_t src
}
CY_ASSERT_L1(size <= Cy_Crypto_Core_Vu_RegBitSizeRead(base, srcReg));
CY_ASSERT_L1(((uint32_t)Cy_Crypto_Core_Vu_RegMemPointer(base, srcReg) + byteSize - 1) < ((uint32_t)REG_CRYPTO_MEM_BUFF(base) + CY_CRYPTO_MEM_BUFF_SIZE) );
CY_ASSERT_L1((((uint32_t)Cy_Crypto_Core_Vu_RegMemPointer(base, srcReg) + byteSize) - 1u) < ((uint32_t)REG_CRYPTO_MEM_BUFF(base) + CY_CRYPTO_MEM_BUFF_SIZE) );
Cy_Crypto_Core_MemCpy(base, (void*)dst, (void*)Cy_Crypto_Core_Vu_RegMemPointer(base, srcReg), byteSize);
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
CY_CRYPTO_VU_RESTORE_REG(base, CY_CRYPTO_VU_HW_REG0, reg0_data);
CY_CRYPTO_VU_RESTORE_REG(base, CY_CRYPTO_VU_HW_REG1, reg1_data);
@ -129,7 +129,7 @@ cy_en_crypto_status_t Cy_Crypto_Core_Cleanup(CRYPTO_Type *base)
/* AES */
REG_CRYPTO_AES_CTL(base) = 0u;
if (cy_device->cryptoVersion == 1u)
if (CY_CRYPTO_HW_V1)
{
REG_CRYPTO_CRC_LFSR_CTL(base) = 0u;
REG_CRYPTO_SHA_CTL(base) = 0u;
@ -145,69 +145,69 @@ cy_en_crypto_status_t Cy_Crypto_Core_Cleanup(CRYPTO_Type *base)
Cy_Crypto_Core_V2_RBClear(base);
}
Cy_Crypto_Core_MemSet(base, (void *)REG_CRYPTO_MEM_BUFF(base), 0u, CY_CRYPTO_MEM_BUFF_SIZE);
Cy_Crypto_Core_MemSet(base, (void *)REG_CRYPTO_MEM_BUFF(base), 0u, (uint16_t)CY_CRYPTO_MEM_BUFF_SIZE);
return (CY_CRYPTO_SUCCESS);
}
bool Cy_Crypto_Core_Vu_IsRegZero(CRYPTO_Type *base, uint32_t srcReg)
{
bool result;
uint16_t status;
bool tmpResult;
uint32_t status;
CY_CRYPTO_VU_TST(base, srcReg);
status = Cy_Crypto_Core_Vu_StatusRead(base);
if (status & CY_CRYPTO_VU_STATUS_ZERO_BIT)
if (0u != (status & CY_CRYPTO_VU_STATUS_ZERO_BIT))
{
result = true;
tmpResult = true;
}
else
{
result = false;
tmpResult = false;
}
return result;
return tmpResult;
}
bool Cy_Crypto_Core_Vu_IsRegEqual(CRYPTO_Type *base, uint32_t srcReg0, uint32_t srcReg1)
{
bool result;
uint16_t status;
bool tmpResult;
uint32_t status;
CY_CRYPTO_VU_CMP_SUB (base, srcReg1, srcReg0); /* C = (a >= b) */
status = Cy_Crypto_Core_Vu_StatusRead(base);
if (status & CY_CRYPTO_VU_STATUS_ZERO_BIT)
if (0u != (status & CY_CRYPTO_VU_STATUS_ZERO_BIT))
{
result = true;
tmpResult = true;
}
else
{
result = false;
tmpResult = false;
}
return result;
return tmpResult;
}
bool Cy_Crypto_Core_Vu_IsRegLess(CRYPTO_Type *base, uint32_t srcReg0, uint32_t srcReg1)
{
bool result;
uint16_t status;
bool tmpResult;
uint32_t status;
CY_CRYPTO_VU_CMP_SUB (base, srcReg1, srcReg0); /* C = (a >= b) */
status = Cy_Crypto_Core_Vu_StatusRead(base);
if (status & CY_CRYPTO_VU_STATUS_CARRY_BIT)
if (0u != (status & CY_CRYPTO_VU_STATUS_CARRY_BIT))
{
result = true;
tmpResult = true;
}
else
{
result = false;
tmpResult = false;
}
return result;
return tmpResult;
}

14
targets/TARGET_Cypress/TARGET_PSOC6/psoc6pdl/drivers/source/cy_crypto_server.c
View File

@ -46,7 +46,7 @@
#if defined(CY_IP_MXCRYPTO)
/* The pointer to the CRYPTO instance address. */
/* The pointer to the CRYPTO instance. */
#define CY_CRYPTO_BASE ((CRYPTO_Type *)cy_device->cryptoBase)
typedef struct
@ -724,19 +724,19 @@ void Cy_Crypto_Server_GetDataHandler(void)
* This function is internal and should not to be called directly by user software
*
* \param base
* The pointer to the CRYPTO instance address.
* The pointer to the CRYPTO instance.
*
* \param cryptoContext
* The pointer to cy_stc_crypto_context_t structure which stores
* the Crypto driver context.
*
* \return
* A Crypto status \ref cy_en_crypto_status_t.
* \ref cy_en_crypto_status_t
*
*******************************************************************************/
static cy_en_crypto_status_t Cy_Crypto_Core_CheckHwForErrors(cy_stc_crypto_context_t *cryptoContext)
{
cy_en_crypto_status_t myResult = CY_CRYPTO_SUCCESS;
cy_en_crypto_status_t tmpResult = CY_CRYPTO_SUCCESS;
uint32_t myErrorStatus0;
uint32_t myErrorStatus1;
@ -750,7 +750,7 @@ static cy_en_crypto_status_t Cy_Crypto_Core_CheckHwForErrors(cy_stc_crypto_conte
if (_FLD2VAL(CRYPTO_ERROR_STATUS1_VALID, myErrorStatus1) == 1u)
{
myResult = CY_CRYPTO_HW_ERROR;
tmpResult = CY_CRYPTO_HW_ERROR;
cy_crypto_serverContext->isHwErrorOccured = true;
}
@ -763,7 +763,7 @@ static cy_en_crypto_status_t Cy_Crypto_Core_CheckHwForErrors(cy_stc_crypto_conte
if (_FLD2VAL(CRYPTO_ERROR_STATUS1_VALID, myErrorStatus1) == 1u)
{
myResult = CY_CRYPTO_HW_ERROR;
tmpResult = CY_CRYPTO_HW_ERROR;
}
cy_crypto_serverContext->isHwErrorOccured = false;
@ -772,7 +772,7 @@ static cy_en_crypto_status_t Cy_Crypto_Core_CheckHwForErrors(cy_stc_crypto_conte
cryptoContext->hwErrorStatus.errorStatus0 = myErrorStatus0;
cryptoContext->hwErrorStatus.errorStatus1 = myErrorStatus1;
return (myResult);
return (tmpResult);
}
#endif /* CY_IP_MXCRYPTO */