crypto.h

Go to the documentation of this file.

/******************************************************************************
*  Filename:       crypto.h
*  Revised:        2016-04-24 00:47:02 +0200 (Sun, 24 Apr 2016)
*  Revision:       46129
*
*  Description:    AES header file.
*
*  Copyright (c) 2015 - 2016, 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.
*
******************************************************************************/

//*****************************************************************************
//
//
//*****************************************************************************

#ifndef __CRYPTO_H__
#define __CRYPTO_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 <inc/hw_types.h>
#include <inc/hw_memmap.h>
#include <inc/hw_ints.h>
#include <inc/hw_crypto.h>
#include <driverlib/debug.h>
#include <driverlib/interrupt.h>
#include <driverlib/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 CRYPTOAesLoadKey                NOROM_CRYPTOAesLoadKey
    #define CRYPTOAesCbc                    NOROM_CRYPTOAesCbc
    #define CRYPTOAesCbcStatus              NOROM_CRYPTOAesCbcStatus
    #define CRYPTOAesEcb                    NOROM_CRYPTOAesEcb
    #define CRYPTOAesEcbStatus              NOROM_CRYPTOAesEcbStatus
    #define CRYPTOCcmAuthEncrypt            NOROM_CRYPTOCcmAuthEncrypt
    #define CRYPTOCcmAuthEncryptStatus      NOROM_CRYPTOCcmAuthEncryptStatus
    #define CRYPTOCcmAuthEncryptResultGet   NOROM_CRYPTOCcmAuthEncryptResultGet
    #define CRYPTOCcmInvAuthDecrypt         NOROM_CRYPTOCcmInvAuthDecrypt
    #define CRYPTOCcmInvAuthDecryptStatus   NOROM_CRYPTOCcmInvAuthDecryptStatus
    #define CRYPTOCcmInvAuthDecryptResultGet NOROM_CRYPTOCcmInvAuthDecryptResultGet
    #define CRYPTODmaEnable                 NOROM_CRYPTODmaEnable
    #define CRYPTODmaDisable                NOROM_CRYPTODmaDisable
#endif

//*****************************************************************************
//
// Length of AES Electronic Code Book (ECB) block in bytes
//
//*****************************************************************************
#define AES_ECB_LENGTH  16

//*****************************************************************************
//
// Values that can be passed to CryptoIntEnable, CryptoIntDisable, and CryptoIntClear
// as the ui32IntFlags parameter, and returned from CryptoIntStatus.
//
//*****************************************************************************
#define CRYPTO_DMA_IN_DONE      0x00000002  // DMA done interrupt mask
#define CRYPTO_RESULT_RDY       0x00000001  // Result ready interrupt mask
#define CRYPTO_DMA_BUS_ERR      0x80000000  // DMA Bus error
#define CRYPTO_KEY_ST_WR_ERR    0x40000000  // Key Store Write failed
#define CRYPTO_KEY_ST_RD_ERR    0x20000000  // Key Store Read failed

#define CRYPTO_IRQTYPE_LEVEL    0x00000001  // Crypto Level interrupt enabled
#define CRYPTO_IRQTYPE_PULSE    0x00000000  // Crypto pulse interrupt enabled

#define CRYPTO_DMA_CHAN0        0x00000001  // Crypto DMA Channel 0
#define CRYPTO_DMA_CHAN1        0x00000002  // Crypto DMA Channel 1

#define CRYPTO_AES128_ENCRYPT   0x0000000C  //
#define CRYPTO_AES128_DECRYPT   0x00000008  //

#define CRYPTO_DMA_READY        0x00000000  // DMA ready
#define CRYPTO_DMA_BSY          0x00000003  // DMA busy
#define CRYPTO_DMA_BUS_ERROR    0x00020000  // DMA encountered bus error

//*****************************************************************************
//
//  General constants
//
//*****************************************************************************

// AES module return codes
#define AES_SUCCESS                      0
#define AES_KEYSTORE_READ_ERROR          1
#define AES_KEYSTORE_WRITE_ERROR         2
#define AES_DMA_BUS_ERROR                3
#define CCM_AUTHENTICATION_FAILED        4
#define AES_ECB_TEST_ERROR               8
#define AES_NULL_ERROR                   9
#define AES_CCM_TEST_ERROR              10
#define AES_DMA_BSY                     11

// Key store module defines
#define STATE_BLENGTH                   16  // Number of bytes in State
#define KEY_BLENGTH                     16  // Number of bytes in Key
#define KEY_EXP_LENGTH                 176  // Nb * (Nr+1) * 4

#define KEY_STORE_SIZE_128      0x00000001
#define KEY_STORE_SIZE_192      0x00000002
#define KEY_STORE_SIZE_256      0x00000003
#define KEY_STORE_SIZE_BITS     0x00000003

//*****************************************************************************
//
// For 128 bit key all 8 Key Area locations from 0 to 8 are valid
// However for 192 bit and 256 bit keys, only even Key Areas 0, 2, 4, 6
// are valid.
//
//*****************************************************************************
#define CRYPTO_KEY_AREA_0       0
#define CRYPTO_KEY_AREA_1       1
#define CRYPTO_KEY_AREA_2       2
#define CRYPTO_KEY_AREA_3       3
#define CRYPTO_KEY_AREA_4       4
#define CRYPTO_KEY_AREA_5       5
#define CRYPTO_KEY_AREA_6       6
#define CRYPTO_KEY_AREA_7       7

//*****************************************************************************
//
// Defines for the current AES operation
//
//*****************************************************************************
#define CRYPTO_AES_NONE         0
#define CRYPTO_AES_KEYL0AD      1
#define CRYPTO_AES_ECB          2
#define CRYPTO_AES_CCM          3
#define CRYPTO_AES_RNG          4
#define CRYPTO_AES_CBC          5

//*****************************************************************************
//
// Defines for the AES-CTR mode counter width
//
//*****************************************************************************
#define CRYPTO_AES_CTR_32       0x0
#define CRYPTO_AES_CTR_64       0x1
#define CRYPTO_AES_CTR_96       0x2
#define CRYPTO_AES_CTR_128      0x3

//*****************************************************************************
//
// API Functions and prototypes
//
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOAesLoadKey(uint32_t *pui32AesKey,
                                 uint32_t ui32KeyLocation);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOAesCbc(uint32_t *pui32MsgIn, uint32_t *pui32MsgOut,
                             uint32_t ui32MsgLength, uint32_t *pui32Nonce,
                             uint32_t ui32KeyLocation, bool bEncrypt,
                             bool bIntEnable);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOAesCbcStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOAesEcb(uint32_t *pui32MsgIn, uint32_t *pui32MsgOut,
                             uint32_t ui32KeyLocation, bool bEncrypt,
                             bool bIntEnable);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOAesEcbStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOAesEcbFinish(void)
{
    //
    // Result has already been copied to the output buffer by DMA.
    // Disable master control/DMA clock and clear the operating mode.
    //
    HWREG(CRYPTO_BASE + CRYPTO_O_ALGSEL) = 0x00000000;
    HWREG(CRYPTO_BASE + CRYPTO_O_AESCTL) = 0x00000000;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOAesCbcFinish(void)
{
    //
    // Result has already been copied to the output buffer by DMA.
    // Disable master control/DMA clock and clear the operating mode.
    //
    HWREG(CRYPTO_BASE + CRYPTO_O_ALGSEL) = 0x00000000;
    HWREG(CRYPTO_BASE + CRYPTO_O_AESCTL) = 0x00000000;
}

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOCcmAuthEncrypt(bool bEncrypt, uint32_t ui32AuthLength,
                                     uint32_t *pui32Nonce,
                                     uint32_t *pui32PlainText,
                                     uint32_t ui32PlainTextLength,
                                     uint32_t *pui32Header,
                                     uint32_t ui32HeaderLength,
                                     uint32_t ui32KeyLocation,
                                     uint32_t ui32FieldLength,
                                     bool bIntEnable);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOCcmAuthEncryptStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOCcmAuthEncryptResultGet(uint32_t ui32TagLength,
                                              uint32_t *pui32CcmTag);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOCcmInvAuthDecrypt(bool bDecrypt, uint32_t ui32AuthLength,
                                        uint32_t *pui32Nonce,
                                        uint32_t *pui32CipherText,
                                        uint32_t ui32CipherTextLength,
                                        uint32_t *pui32Header,
                                        uint32_t ui32HeaderLength,
                                        uint32_t ui32KeyLocation,
                                        uint32_t ui32FieldLength,
                                        bool bIntEnable);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOCcmInvAuthDecryptStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t CRYPTOCcmInvAuthDecryptResultGet(uint32_t ui32AuthLength,
                                                 uint32_t *pui32CipherText,
                                                 uint32_t ui32CipherTextLength,
                                                 uint32_t *pui32CcmTag);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
CRYPTODmaStatus(void)
{
    //
    // Return the value of the status register.
    //
    return (HWREG(CRYPTO_BASE + CRYPTO_O_DMASTAT));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void CRYPTODmaEnable(uint32_t ui32Channels);

//*****************************************************************************
//
//
//*****************************************************************************
extern void CRYPTODmaDisable(uint32_t ui32Channels);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOIntEnable(uint32_t ui32IntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT((ui32IntFlags & CRYPTO_DMA_IN_DONE) |
           (ui32IntFlags & CRYPTO_RESULT_RDY));

    //
    // Using level interrupt.
    //
    HWREG(CRYPTO_BASE + CRYPTO_O_IRQTYPE) = CRYPTO_IRQTYPE_LEVEL;

    //
    // Enable the specified interrupts.
    //
    HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN) |= ui32IntFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOIntDisable(uint32_t ui32IntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT((ui32IntFlags & CRYPTO_DMA_IN_DONE) |
           (ui32IntFlags & CRYPTO_RESULT_RDY));

    //
    // Disable the specified interrupts.
    //
    HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN) &= ~ui32IntFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
CRYPTOIntStatus(bool bMasked)
{
    uint32_t ui32Mask;

    //
    // Return either the interrupt status or the raw interrupt status as
    // requested.
    //
    if(bMasked)
    {
        ui32Mask = HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN);
        return(ui32Mask & HWREG(CRYPTO_BASE + CRYPTO_O_IRQSTAT));
    }
    else
    {
        return(HWREG(CRYPTO_BASE + CRYPTO_O_IRQSTAT) & 0x00000003);
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOIntClear(uint32_t ui32IntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT((ui32IntFlags & CRYPTO_DMA_IN_DONE) |
           (ui32IntFlags & CRYPTO_RESULT_RDY));

    //
    // Clear the requested interrupt sources,
    //
    HWREG(CRYPTO_BASE + CRYPTO_O_IRQCLR) = ui32IntFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOIntRegister(void (*pfnHandler)(void))
{
    //
    // Register the interrupt handler.
    //
    IntRegister(INT_CRYPTO_RESULT_AVAIL_IRQ, pfnHandler);

    //
    // Enable the UART interrupt.
    //
    IntEnable(INT_CRYPTO_RESULT_AVAIL_IRQ);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
CRYPTOIntUnregister(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_CRYPTOAesLoadKey
        #undef  CRYPTOAesLoadKey
        #define CRYPTOAesLoadKey                ROM_CRYPTOAesLoadKey
    #endif
    #ifdef ROM_CRYPTOAesCbc
        #undef  CRYPTOAesCbc
        #define CRYPTOAesCbc                    ROM_CRYPTOAesCbc
    #endif
    #ifdef ROM_CRYPTOAesCbcStatus
        #undef  CRYPTOAesCbcStatus
        #define CRYPTOAesCbcStatus              ROM_CRYPTOAesCbcStatus
    #endif
    #ifdef ROM_CRYPTOAesEcb
        #undef  CRYPTOAesEcb
        #define CRYPTOAesEcb                    ROM_CRYPTOAesEcb
    #endif
    #ifdef ROM_CRYPTOAesEcbStatus
        #undef  CRYPTOAesEcbStatus
        #define CRYPTOAesEcbStatus              ROM_CRYPTOAesEcbStatus
    #endif
    #ifdef ROM_CRYPTOCcmAuthEncrypt
        #undef  CRYPTOCcmAuthEncrypt
        #define CRYPTOCcmAuthEncrypt            ROM_CRYPTOCcmAuthEncrypt
    #endif
    #ifdef ROM_CRYPTOCcmAuthEncryptStatus
        #undef  CRYPTOCcmAuthEncryptStatus
        #define CRYPTOCcmAuthEncryptStatus      ROM_CRYPTOCcmAuthEncryptStatus
    #endif
    #ifdef ROM_CRYPTOCcmAuthEncryptResultGet
        #undef  CRYPTOCcmAuthEncryptResultGet
        #define CRYPTOCcmAuthEncryptResultGet   ROM_CRYPTOCcmAuthEncryptResultGet
    #endif
    #ifdef ROM_CRYPTOCcmInvAuthDecrypt
        #undef  CRYPTOCcmInvAuthDecrypt
        #define CRYPTOCcmInvAuthDecrypt         ROM_CRYPTOCcmInvAuthDecrypt
    #endif
    #ifdef ROM_CRYPTOCcmInvAuthDecryptStatus
        #undef  CRYPTOCcmInvAuthDecryptStatus
        #define CRYPTOCcmInvAuthDecryptStatus   ROM_CRYPTOCcmInvAuthDecryptStatus
    #endif
    #ifdef ROM_CRYPTOCcmInvAuthDecryptResultGet
        #undef  CRYPTOCcmInvAuthDecryptResultGet
        #define CRYPTOCcmInvAuthDecryptResultGet ROM_CRYPTOCcmInvAuthDecryptResultGet
    #endif
    #ifdef ROM_CRYPTODmaEnable
        #undef  CRYPTODmaEnable
        #define CRYPTODmaEnable                 ROM_CRYPTODmaEnable
    #endif
    #ifdef ROM_CRYPTODmaDisable
        #undef  CRYPTODmaDisable
        #define CRYPTODmaDisable                ROM_CRYPTODmaDisable
    #endif
#endif

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

#endif  // __CRYPTO_H__

//*****************************************************************************
//
//
//*****************************************************************************