| /****************************************************************************** |
| * Filename: sha2.h |
| * Revised: 2018-04-17 16:04:03 +0200 (Tue, 17 Apr 2018) |
| * Revision: 51893 |
| * |
| * Description: SHA-2 header file. |
| * |
| * Copyright (c) 2015 - 2017, Texas Instruments Incorporated |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * 1) Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * 2) Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * 3) Neither the name of the ORGANIZATION nor the names of its contributors may |
| * be used to endorse or promote products derived from this software without |
| * specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| ******************************************************************************/ |
| |
| //***************************************************************************** |
| // |
| //! \addtogroup peripheral_group |
| //! @{ |
| //! \addtogroup sha2_api |
| //! @{ |
| // |
| //***************************************************************************** |
| |
| #ifndef __SHA2_H__ |
| #define __SHA2_H__ |
| |
| //***************************************************************************** |
| // |
| // If building with a C++ compiler, make all of the definitions in this header |
| // have a C binding. |
| // |
| //***************************************************************************** |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| #include <stdbool.h> |
| #include <stdint.h> |
| #include <stddef.h> |
| #include "../inc/hw_types.h" |
| #include "../inc/hw_memmap.h" |
| #include "../inc/hw_ints.h" |
| #include "../inc/hw_crypto.h" |
| #include "../inc/hw_ccfg.h" |
| #include "debug.h" |
| #include "interrupt.h" |
| #include "cpu.h" |
| |
| //***************************************************************************** |
| // |
| // Support for DriverLib in ROM: |
| // This section renames all functions that are not "static inline", so that |
| // calling these functions will default to implementation in flash. At the end |
| // of this file a second renaming will change the defaults to implementation in |
| // ROM for available functions. |
| // |
| // To force use of the implementation in flash, e.g. for debugging: |
| // - Globally: Define DRIVERLIB_NOROM at project level |
| // - Per function: Use prefix "NOROM_" when calling the function |
| // |
| //***************************************************************************** |
| #if !defined(DOXYGEN) |
| #define SHA2StartDMAOperation NOROM_SHA2StartDMAOperation |
| #define SHA2WaitForIRQFlags NOROM_SHA2WaitForIRQFlags |
| #define SHA2ComputeInitialHash NOROM_SHA2ComputeInitialHash |
| #define SHA2ComputeIntermediateHash NOROM_SHA2ComputeIntermediateHash |
| #define SHA2ComputeFinalHash NOROM_SHA2ComputeFinalHash |
| #define SHA2ComputeHash NOROM_SHA2ComputeHash |
| #endif |
| |
| //***************************************************************************** |
| // |
| // Values that can be passed to SHA2IntEnable, SHA2IntDisable, and SHA2IntClear |
| // as the intFlags parameter, and returned from SHA2IntStatus. |
| // Only SHA2_DMA_IN_DONE and SHA2_RESULT_RDY are routed to the NVIC. Check each |
| // function to see if it supports other interrupt status flags. |
| // |
| //***************************************************************************** |
| #define SHA2_DMA_IN_DONE (CRYPTO_IRQEN_DMA_IN_DONE_M) |
| #define SHA2_RESULT_RDY (CRYPTO_IRQEN_RESULT_AVAIL_M) |
| #define SHA2_DMA_BUS_ERR (CRYPTO_IRQCLR_DMA_BUS_ERR_M) |
| |
| |
| //***************************************************************************** |
| // |
| // General constants |
| // |
| //***************************************************************************** |
| |
| // SHA-2 module return codes |
| #define SHA2_SUCCESS 0 |
| #define SHA2_INVALID_ALGORITHM 1 |
| #define SHA2_DMA_BUSY 3 |
| #define SHA2_DMA_ERROR 4 |
| #define SHA2_DIGEST_NOT_READY 5 |
| #define SHA2_OLD_DIGEST_NOT_READ 6 |
| |
| // SHA-2 output digest lengths in bytes. |
| #define SHA2_SHA224_DIGEST_LENGTH_BYTES (224 / 8) |
| #define SHA2_SHA256_DIGEST_LENGTH_BYTES (256 / 8) |
| #define SHA2_SHA384_DIGEST_LENGTH_BYTES (384 / 8) |
| #define SHA2_SHA512_DIGEST_LENGTH_BYTES (512 / 8) |
| |
| //Selectable SHA-2 modes. They determine the algorithm used and if initial |
| //values will be set to the default constants or not |
| #define SHA2_MODE_SELECT_SHA224 (CRYPTO_HASHMODE_SHA224_MODE_M) |
| #define SHA2_MODE_SELECT_SHA256 (CRYPTO_HASHMODE_SHA256_MODE_M) |
| #define SHA2_MODE_SELECT_SHA384 (CRYPTO_HASHMODE_SHA384_MODE_M) |
| #define SHA2_MODE_SELECT_SHA512 (CRYPTO_HASHMODE_SHA512_MODE_M) |
| #define SHA2_MODE_SELECT_NEW_HASH (CRYPTO_HASHMODE_NEW_HASH_M) |
| |
| // SHA-2 block lengths. When hashing block-wise, they define the size of each |
| // block provided to the new and intermediate hash functions. |
| #define SHA2_SHA224_BLOCK_SIZE_BYTES (512 / 8) |
| #define SHA2_SHA256_BLOCK_SIZE_BYTES (512 / 8) |
| #define SHA2_SHA384_BLOCK_SIZE_BYTES (1024 / 8) |
| #define SHA2_SHA512_BLOCK_SIZE_BYTES (1024 / 8) |
| |
| // DMA status codes |
| #define SHA2_DMA_CHANNEL0_ACTIVE (CRYPTO_DMASTAT_CH0_ACT_M) |
| #define SHA2_DMA_CHANNEL1_ACTIVE (CRYPTO_DMASTAT_CH1_ACT_M) |
| #define SHA2_DMA_PORT_ERROR (CRYPTO_DMASTAT_PORT_ERR_M) |
| |
| // Crypto module DMA operation types |
| #define SHA2_ALGSEL_SHA256 0x04 |
| #define SHA2_ALGSEL_SHA512 0x08 |
| #define SHA2_ALGSEL_TAG (CRYPTO_ALGSEL_TAG_M) |
| |
| |
| |
| //***************************************************************************** |
| // |
| // API Functions and prototypes |
| // |
| //***************************************************************************** |
| |
| //***************************************************************************** |
| // |
| //! \brief Start a crypto DMA operation |
| //! |
| //! Enable the crypto DMA channels, configure the channel addresses, |
| //! and set the length of the data transfer. |
| //! Setting the length of the data transfer automatically starts the |
| //! transfer. It is also used by the hardware module as a signal to |
| //! begin the encryption, decryption, or MAC operation. |
| //! |
| //! \param [in] channel0Addr |
| //! A pointer to the address channel 0 shall use. |
| //! |
| //! \param [in] channel0Length |
| //! Length of the data in bytes to be read from or written to at |
| //! \c channel0Addr. Set to 0 to not set up this channel. |
| //! |
| //! \param [out] channel1Addr |
| //! A pointer to the address channel 1 shall use. |
| //! |
| //! \param [in] channel1Length |
| //! Length of the data in bytes to be read from or written to at |
| //! \c channel1Addr. Set to 0 to not set up this channel. |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| extern void SHA2StartDMAOperation(uint8_t *channel0Addr, uint32_t channel0Length, uint8_t *channel1Addr, uint32_t channel1Length); |
| |
| //***************************************************************************** |
| // |
| //! \brief Poll the interrupt status register and clear when done. |
| //! |
| //! This function polls until one of the bits in the \c irqFlags is |
| //! asserted. Only \ref SHA2_DMA_IN_DONE and \ref SHA2_RESULT_RDY can actually |
| //! trigger the interrupt line. That means that one of those should |
| //! always be included in \c irqFlags and will always be returned together |
| //! with any error codes. |
| //! |
| //! \param [in] irqFlags |
| //! IRQ flags to poll and mask that the status register will be |
| //! masked with. Consists of any bitwise OR of the flags |
| //! below that includes at least one of |
| //! \ref SHA2_DMA_IN_DONE or \ref SHA2_RESULT_RDY : |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| //! - \ref SHA2_DMA_BUS_ERR |
| //! |
| //! \return Returns the IRQ status register masked with \c irqFlags. May be any |
| //! bitwise OR of the following masks: |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| //! - \ref SHA2_DMA_BUS_ERR |
| // |
| //***************************************************************************** |
| extern uint32_t SHA2WaitForIRQFlags(uint32_t irqFlags); |
| |
| //***************************************************************************** |
| // |
| //! \brief Start a new SHA-2 hash operation. |
| //! |
| //! This function begins a new piecewise hash operation. |
| //! |
| //! Call this function when starting a new hash operation and the |
| //! entire message is not yet available. |
| //! |
| //! Call SHA2ComputeIntermediateHash() or SHA2ComputeFinalHash() |
| //! after this call. |
| //! |
| //! If the device shall go into standby in between calls to this |
| //! function and either SHA2ComputeIntermediateHash() or |
| //! SHA2ComputeFinalHash(), the intermediate digest must be saved in |
| //! system RAM. |
| //! |
| //! \param [in] message |
| //! Byte array containing the start of the message to hash. |
| //! Must be exactly as long as the block length of the selected |
| //! algorithm. |
| //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES |
| //! |
| //! \param [out] intermediateDigest |
| //! Pointer to intermediate digest. |
| //! - NULL The intermediate digest will be stored in the internal |
| //! registers of the SHA module. |
| //! - Not NULL Specifies the location the intermediate digest will |
| //! be written to. |
| //! |
| //! Must be of a length equal to the digest length of the selected |
| //! hash algorithm. |
| //! Must be 32-bit aligned. \c intermediateDigest is copied into the |
| //! registers through the AHB slave interface in |
| //! SHA2ComputeIntermediateHash() and SHA2ComputeFinalHash(). |
| //! This can only be done word-by-word. |
| //! |
| //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: |
| //! - \ref SHA2_MODE_SELECT_SHA224 |
| //! - \ref SHA2_MODE_SELECT_SHA256 |
| //! - \ref SHA2_MODE_SELECT_SHA384 |
| //! - \ref SHA2_MODE_SELECT_SHA512 |
| //! |
| //! \param [in] initialMessageLength The length in bytes of the first |
| //! section of the message to process. Must be a multiple of the |
| //! block size. |
| //! |
| //! \return Returns a SHA-2 return code. |
| //! - \ref SHA2_SUCCESS |
| //! - \ref SHA2_INVALID_ALGORITHM |
| //! |
| //! \sa SHA2ComputeIntermediateHash() |
| //! \sa SHA2ComputeFinalHash() |
| // |
| //***************************************************************************** |
| extern uint32_t SHA2ComputeInitialHash(const uint8_t *message, uint32_t *intermediateDigest, uint32_t hashAlgorithm, uint32_t initialMessageLength); |
| |
| //***************************************************************************** |
| // |
| //! \brief Resume a SHA-2 hash operation but do not finalize it. |
| //! |
| //! This function resumes a previous hash operation. |
| //! |
| //! Call this function when continuing a hash operation and the |
| //! message is not yet complete. |
| //! |
| //! Call this function again or SHA2ComputeFinalHash() |
| //! after this call. |
| //! |
| //! If the device shall go into standby in between calls to this |
| //! function and SHA2ComputeFinalHash(), the intermediate |
| //! digest must be saved in system RAM. |
| //! |
| //! \param [in] message |
| //! Byte array containing the start of the current block of the |
| //! message to hash. |
| //! Must be exactly as long as the block length of the selected |
| //! algorithm. |
| //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES |
| //! |
| //! \param [in, out] intermediateDigest |
| //! Pointer to intermediate digest. |
| //! - NULL The intermediate digest will be sourced from the internal |
| //! registers of the SHA module and stored there after the |
| //! operation completes. |
| //! - Not NULL Specifies the location the intermediate digest will |
| //! be read from and written to. |
| //! |
| //! Must be of a length equal to the digest length of the selected |
| //! hash algorithm. |
| //! Must be 32-bit aligned. \c intermediateDigest is copied from and |
| //! to the registers through the AHB slave interface. |
| //! This can only be done word-by-word. |
| //! |
| //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: |
| //! - \ref SHA2_MODE_SELECT_SHA224 |
| //! - \ref SHA2_MODE_SELECT_SHA256 |
| //! - \ref SHA2_MODE_SELECT_SHA384 |
| //! - \ref SHA2_MODE_SELECT_SHA512 |
| //! |
| //! \param [in] intermediateMessageLength The length in bytes of this |
| //! section of the message to process. Must be a multiple of the |
| //! block size. |
| //! |
| //! \return Returns a SHA-2 return code. |
| //! - \ref SHA2_SUCCESS |
| //! - \ref SHA2_INVALID_ALGORITHM |
| //! |
| //! \sa SHA2ComputeInitialHash() |
| //! \sa SHA2ComputeFinalHash() |
| // |
| //***************************************************************************** |
| extern uint32_t SHA2ComputeIntermediateHash(const uint8_t *message, uint32_t *intermediateDigest, uint32_t hashAlgorithm, uint32_t intermediateMessageLength); |
| |
| //***************************************************************************** |
| // |
| //! \brief Resume a SHA-2 hash operation and finalize it. |
| //! |
| //! This function resumes a previous hash session. |
| //! |
| //! Call this function when continuing a hash operation and the |
| //! message is complete. |
| //! |
| //! \param [in] message |
| //! Byte array containing the final block of the message to hash. |
| //! Any length <= the block size is acceptable. |
| //! The DMA finalize the message as necessary. |
| //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES |
| //! |
| //! \param [out] resultDigest |
| //! Byte array that the final digest will be written to. Must be of |
| //! a length equal to the digest length of the selected hash algorithm. |
| //! |
| //! \param [in] intermediateDigest |
| //! Pointer to intermediate digest. |
| //! - NULL The intermediate digest will be sourced from the internal |
| //! registers of the SHA module. |
| //! - Not NULL Specifies the location the intermediate digest will |
| //! be read from. |
| //! Must be of a length equal to the digest length of the selected |
| //! hash algorithm. |
| //! Must be 32-bit aligned. \c intermediateDigest is copied from and |
| //! to the registers through the AHB slave interface. |
| //! This can only be done word-by-word. |
| //! |
| //! \param [in] totalMsgLength |
| //! The length in bytes of the entire \c message including the sections |
| //! passed to previous calls to SHA2ComputeInitialHash() and |
| //! SHA2ComputeIntermediateHash(). |
| //! |
| //! \param [in] messageLength The length in bytes of the last |
| //! section of the message to process. Does not need to be |
| //! a multiple of the block size. |
| //! |
| //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: |
| //! - \ref SHA2_MODE_SELECT_SHA224 |
| //! - \ref SHA2_MODE_SELECT_SHA256 |
| //! - \ref SHA2_MODE_SELECT_SHA384 |
| //! - \ref SHA2_MODE_SELECT_SHA512 |
| //! |
| //! \return Returns a SHA-2 return code. |
| //! - \ref SHA2_SUCCESS |
| //! - \ref SHA2_INVALID_ALGORITHM |
| //! |
| //! \sa SHA2ComputeInitialHash() |
| //! \sa SHA2ComputeIntermediateHash() |
| // |
| //***************************************************************************** |
| extern uint32_t SHA2ComputeFinalHash(const uint8_t *message, uint8_t *resultDigest, uint32_t *intermediateDigest, uint32_t totalMsgLength, uint32_t messageLength, uint32_t hashAlgorithm); |
| |
| //***************************************************************************** |
| // |
| //! \brief Start a SHA-2 hash operation and return the finalized digest. |
| //! |
| //! This function starts a hash operation and returns the finalized |
| //! digest. |
| //! |
| //! Use this function if the entire message is available when starting |
| //! the hash. |
| //! |
| //! \param [in] message |
| //! Byte array containing the message that will be hashed. |
| //! Any length <= the block size is acceptable. |
| //! The DMA will finalize the message as necessary. |
| //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES |
| //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES |
| //! |
| //! \param [out] resultDigest |
| //! Byte array that the final digest will be written to. Must be of a |
| //! length equal to the digest length of the selected hash algorithm. |
| //! |
| //! \param [in] totalMsgLength |
| //! The length in bytes of the entire \c message. |
| //! |
| //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: |
| //! - \ref SHA2_MODE_SELECT_SHA224 |
| //! - \ref SHA2_MODE_SELECT_SHA256 |
| //! - \ref SHA2_MODE_SELECT_SHA384 |
| //! - \ref SHA2_MODE_SELECT_SHA512 |
| //! |
| //! \return Returns a SHA-2 return code. |
| //! - \ref SHA2_SUCCESS |
| //! - \ref SHA2_INVALID_ALGORITHM |
| //! |
| // |
| //***************************************************************************** |
| extern uint32_t SHA2ComputeHash(const uint8_t *message, uint8_t *resultDigest, uint32_t totalMsgLength, uint32_t hashAlgorithm); |
| |
| //***************************************************************************** |
| // |
| //! \brief Configure the crypto DMA for a particular operation. |
| //! |
| //! \param algorithm |
| //! Configures the crypto DMA for a particular operation. |
| //! It also powers on the respective part of the system. |
| //! \ref SHA2_ALGSEL_TAG may be combined with another flag. All other |
| //! flags are mutually exclusive. |
| //! - 0 : Reset the module and turn off all sub-modules. |
| //! - \ref SHA2_ALGSEL_SHA256 Configure for a SHA224 or SHA256 operation. |
| //! - \ref SHA2_ALGSEL_SHA512 Configure for a SHA384 or SHA512 operation. |
| //! - \ref SHA2_ALGSEL_TAG Read out hash via DMA rather than the slave interface |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2SelectAlgorithm(uint32_t algorithm) |
| { |
| ASSERT((algorithm == SHA2_ALGSEL_SHA256) || |
| (algorithm == SHA2_ALGSEL_SHA512) || |
| (algorithm == SHA2_ALGSEL_SHA256 | SHA2_ALGSEL_TAG) || |
| (algorithm == SHA2_ALGSEL_SHA512 | SHA2_ALGSEL_TAG)); |
| |
| HWREG(CRYPTO_BASE + CRYPTO_O_ALGSEL) = algorithm; |
| } |
| |
| |
| |
| //***************************************************************************** |
| // |
| //! \brief Specify the total length of the message. |
| //! |
| //! Despite specifying it here, the crypto DMA must still be |
| //! set up with the correct data length. |
| //! |
| //! Call this function only when setting up the final hash operation to |
| //! enable finalization. |
| //! |
| //! \param length Total message length in bits. |
| //! |
| //! \return None |
| //! |
| //! \sa SHA2StartDMAOperation() |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2SetMessageLength(uint32_t length) |
| { |
| HWREG(CRYPTO_BASE + CRYPTO_O_HASHINLENL) = length; |
| // CRYPTO_O_HASHINLENH is automatically set to 0. No need for the extra write. |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Load an intermediate digest. |
| //! |
| //! \param [in] digestLength |
| //! Length of the digest in bytes. Must be one of: |
| //! - \ref SHA2_SHA224_DIGEST_LENGTH_BYTES |
| //! - \ref SHA2_SHA256_DIGEST_LENGTH_BYTES |
| //! - \ref SHA2_SHA384_DIGEST_LENGTH_BYTES |
| //! - \ref SHA2_SHA512_DIGEST_LENGTH_BYTES |
| //! |
| //! \param [in] digest |
| //! Pointer to an intermediate digest. Must be 32-bit aligned. |
| //! |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2SetDigest(uint32_t *digest, uint8_t digestLength) |
| { |
| // Check the arguments. |
| ASSERT(!(digest == NULL) && !((uint32_t)digest & 0x03)); |
| ASSERT((digestLength == SHA2_SHA224_DIGEST_LENGTH_BYTES) || |
| (digestLength == SHA2_SHA256_DIGEST_LENGTH_BYTES) || |
| (digestLength == SHA2_SHA384_DIGEST_LENGTH_BYTES) || |
| (digestLength == SHA2_SHA512_DIGEST_LENGTH_BYTES)); |
| |
| // Write digest |
| uint32_t i = 0; |
| for (i = 0; i < (digestLength / sizeof(uint32_t)); i++) { |
| HWREG(CRYPTO_BASE + CRYPTO_O_HASHDIGESTA + (i * sizeof(uint32_t))) = digest[i]; |
| } |
| |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Read the intermediate or final digest. |
| //! |
| //! \param [in] digestLength Length of the digest in bytes. Must be one of: |
| //! - ref SHA2_SHA224_DIGEST_LENGTH_BYTES |
| //! - ref SHA2_SHA256_DIGEST_LENGTH_BYTES |
| //! - ref SHA2_SHA384_DIGEST_LENGTH_BYTES |
| //! - ref SHA2_SHA512_DIGEST_LENGTH_BYTES |
| //! |
| //! \param [out] digest |
| //! Pointer to an intermediate digest. Must be 32-bit aligned. |
| //! |
| //! \return Returns a status code. |
| //! - \ref SHA2_OLD_DIGEST_NOT_READ |
| //! - \ref SHA2_SUCCESS |
| // |
| //***************************************************************************** |
| __STATIC_INLINE uint32_t SHA2GetDigest(uint32_t *digest, uint8_t digestLength) |
| { |
| // Check the arguments. |
| ASSERT(!(digest == NULL) && !((uint32_t)digest & 0x03)); |
| ASSERT((digestLength == SHA2_SHA224_DIGEST_LENGTH_BYTES) || |
| (digestLength == SHA2_SHA256_DIGEST_LENGTH_BYTES) || |
| (digestLength == SHA2_SHA384_DIGEST_LENGTH_BYTES) || |
| (digestLength == SHA2_SHA512_DIGEST_LENGTH_BYTES)); |
| |
| if (HWREG(CRYPTO_BASE + CRYPTO_O_HASHIOBUFCTRL) & CRYPTO_HASHIOBUFCTRL_OUTPUT_FULL_M) { |
| return SHA2_OLD_DIGEST_NOT_READ; |
| } |
| else { |
| // Read digest |
| uint32_t i = 0; |
| for (i = 0; i < (digestLength / sizeof(uint32_t)); i++) { |
| digest[i] = HWREG(CRYPTO_BASE + CRYPTO_O_HASHDIGESTA + (i * sizeof(uint32_t))); |
| } |
| return SHA2_SUCCESS; |
| } |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Confirm digest was read. |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2ClearDigestAvailableFlag(void) |
| { |
| HWREG(CRYPTO_BASE + CRYPTO_O_HASHIOBUFCTRL) = HWREG(CRYPTO_BASE + CRYPTO_O_HASHIOBUFCTRL); |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Enable individual crypto interrupt sources. |
| //! |
| //! This function enables the indicated crypto interrupt sources. Only the |
| //! sources that are enabled can be reflected to the processor interrupt. |
| //! Disabled sources have no effect on the processor. |
| //! |
| //! \param intFlags is the bitwise OR of the interrupt sources to be enabled. |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2IntEnable(uint32_t intFlags) |
| { |
| // Check the arguments. |
| ASSERT((intFlags & SHA2_DMA_IN_DONE) || |
| (intFlags & SHA2_RESULT_RDY)); |
| |
| // Using level interrupt. |
| HWREG(CRYPTO_BASE + CRYPTO_O_IRQTYPE) = CRYPTO_IRQTYPE_LEVEL_M; |
| |
| // Enable the specified interrupts. |
| HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN) |= intFlags; |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Disable individual crypto interrupt sources. |
| //! |
| //! This function disables the indicated crypto interrupt sources. Only the |
| //! sources that are enabled can be reflected to the processor interrupt. |
| //! Disabled sources have no effect on the processor. |
| //! |
| //! \param intFlags is the bitwise OR of the interrupt sources to be enabled. |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2IntDisable(uint32_t intFlags) |
| { |
| // Check the arguments. |
| ASSERT((intFlags & SHA2_DMA_IN_DONE) || |
| (intFlags & SHA2_RESULT_RDY)); |
| |
| // Disable the specified interrupts. |
| HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN) &= ~intFlags; |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Get the current masked interrupt status. |
| //! |
| //! This function returns the masked interrupt status of the crypto module. |
| //! |
| //! \return Returns the status of the masked lines when enabled: |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| // |
| //***************************************************************************** |
| __STATIC_INLINE uint32_t SHA2IntStatusMasked(void) |
| { |
| uint32_t mask; |
| |
| // Return the masked interrupt status |
| mask = HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN); |
| return(mask & HWREG(CRYPTO_BASE + CRYPTO_O_IRQSTAT)); |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Get the current raw interrupt status. |
| //! |
| //! This function returns the raw interrupt status of the crypto module. |
| //! It returns both the status of the lines routed to the NVIC as well as the |
| //! error flags. |
| //! |
| //! \return Returns the raw interrupt status: |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| //! - \ref SHA2_DMA_BUS_ERR |
| // |
| //***************************************************************************** |
| __STATIC_INLINE uint32_t SHA2IntStatusRaw(void) |
| { |
| // Return either the raw interrupt status |
| return(HWREG(CRYPTO_BASE + CRYPTO_O_IRQSTAT)); |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Clear crypto interrupt sources. |
| //! |
| //! The specified crypto interrupt sources are cleared, so that they no longer |
| //! assert. This function must be called in the interrupt handler to keep the |
| //! interrupt from being recognized again immediately upon exit. |
| //! |
| //! \note Due to write buffers and synchronizers in the system it may take several |
| //! clock cycles from a register write clearing an event in the module until the |
| //! event is actually cleared in the NVIC of the system CPU. It is recommended to |
| //! clear the event source early in the interrupt service routine (ISR) to allow |
| //! the event clear to propagate to the NVIC before returning from the ISR. |
| //! |
| //! \param intFlags is a bit mask of the interrupt sources to be cleared. |
| //! - \ref SHA2_DMA_IN_DONE |
| //! - \ref SHA2_RESULT_RDY |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2IntClear(uint32_t intFlags) |
| { |
| // Check the arguments. |
| ASSERT((intFlags & SHA2_DMA_IN_DONE) || |
| (intFlags & SHA2_RESULT_RDY)); |
| |
| // Clear the requested interrupt sources, |
| HWREG(CRYPTO_BASE + CRYPTO_O_IRQCLR) = intFlags; |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Register an interrupt handler for a crypto interrupt in the dynamic interrupt table. |
| //! |
| //! \note Only use this function if you want to use the dynamic vector table (in SRAM)! |
| //! |
| //! This function registers a function as the interrupt handler for a specific |
| //! interrupt and enables the corresponding interrupt in the interrupt controller. |
| //! |
| //! Specific crypto interrupts must be enabled via \ref SHA2IntEnable(). It is the |
| //! interrupt handler's responsibility to clear the interrupt source. |
| //! |
| //! \param handlerFxn is a pointer to the function to be called when the |
| //! crypto interrupt occurs. |
| //! |
| //! \return None |
| //! |
| //! \sa \ref IntRegister() for important information about registering interrupt |
| //! handlers. |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2IntRegister(void (*handlerFxn)(void)) |
| { |
| // Register the interrupt handler. |
| IntRegister(INT_CRYPTO_RESULT_AVAIL_IRQ, handlerFxn); |
| |
| // Enable the crypto interrupt. |
| IntEnable(INT_CRYPTO_RESULT_AVAIL_IRQ); |
| } |
| |
| //***************************************************************************** |
| // |
| //! \brief Unregister an interrupt handler for a crypto interrupt in the dynamic interrupt table. |
| //! |
| //! This function does the actual unregistering of the interrupt handler. It |
| //! clears the handler called when a crypto interrupt occurs. This |
| //! function also masks off the interrupt in the interrupt controller so that |
| //! the interrupt handler no longer is called. |
| //! |
| //! \return None |
| //! |
| //! \sa \ref IntRegister() for important information about registering interrupt |
| //! handlers. |
| // |
| //***************************************************************************** |
| __STATIC_INLINE void SHA2IntUnregister(void) |
| { |
| // Disable the interrupt. |
| IntDisable(INT_CRYPTO_RESULT_AVAIL_IRQ); |
| |
| // Unregister the interrupt handler. |
| IntUnregister(INT_CRYPTO_RESULT_AVAIL_IRQ); |
| } |
| |
| //***************************************************************************** |
| // |
| // Support for DriverLib in ROM: |
| // Redirect to implementation in ROM when available. |
| // |
| //***************************************************************************** |
| #if !defined(DRIVERLIB_NOROM) && !defined(DOXYGEN) |
| #include "../driverlib/rom.h" |
| #ifdef ROM_SHA2StartDMAOperation |
| #undef SHA2StartDMAOperation |
| #define SHA2StartDMAOperation ROM_SHA2StartDMAOperation |
| #endif |
| #ifdef ROM_SHA2WaitForIRQFlags |
| #undef SHA2WaitForIRQFlags |
| #define SHA2WaitForIRQFlags ROM_SHA2WaitForIRQFlags |
| #endif |
| #ifdef ROM_SHA2ComputeInitialHash |
| #undef SHA2ComputeInitialHash |
| #define SHA2ComputeInitialHash ROM_SHA2ComputeInitialHash |
| #endif |
| #ifdef ROM_SHA2ComputeIntermediateHash |
| #undef SHA2ComputeIntermediateHash |
| #define SHA2ComputeIntermediateHash ROM_SHA2ComputeIntermediateHash |
| #endif |
| #ifdef ROM_SHA2ComputeFinalHash |
| #undef SHA2ComputeFinalHash |
| #define SHA2ComputeFinalHash ROM_SHA2ComputeFinalHash |
| #endif |
| #ifdef ROM_SHA2ComputeHash |
| #undef SHA2ComputeHash |
| #define SHA2ComputeHash ROM_SHA2ComputeHash |
| #endif |
| #endif |
| |
| //***************************************************************************** |
| // |
| // Mark the end of the C bindings section for C++ compilers. |
| // |
| //***************************************************************************** |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif // __SHA2_H__ |
| |
| //***************************************************************************** |
| // |
| //! Close the Doxygen group. |
| //! @} |
| //! @} |
| // |
| //***************************************************************************** |
