CryptoCC32XX.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2019, 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:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  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.
 *
 * *  Neither the name of Texas Instruments Incorporated 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 OWNER 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 ti_drivers_crypto_CryptoCC32XX__include
#define ti_drivers_crypto_CryptoCC32XX__include

#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <ti/drivers/dpl/HwiP.h>
#include <ti/drivers/dpl/SemaphoreP.h>

#ifdef __cplusplus
extern "C" {
#endif

#define CryptoCC32XX_CMD_RESERVED 32

#define CryptoCC32XX_STATUS_RESERVED -32

#define CryptoCC32XX_STATUS_SUCCESS 0

#define CryptoCC32XX_STATUS_ERROR -1

#define CryptoCC32XX_STATUS_UNDEFINEDCMD -2

#define CryptoCC32XX_STATUS_ERROR_VERIFY -3

#define CryptoCC32XX_STATUS_ERROR_NOT_SUPPORTED -4

#define CryptoCC32XX_MAX_TYPES 3

#define CryptoCC32XX_MD5_BLOCK_SIZE    64
#define CryptoCC32XX_SHA1_BLOCK_SIZE   64
#define CryptoCC32XX_SHA256_BLOCK_SIZE 64

#define CryptoCC32XX_MD5_DIGEST_SIZE    16
#define CryptoCC32XX_SHA1_DIGEST_SIZE   20
#define CryptoCC32XX_SHA256_DIGEST_SIZE 32

#define CryptoCC32XX_MAX_DIGEST_SIZE CryptoCC32XX_SHA256_DIGEST_SIZE
#define CryptoCC32XX_MAX_BLOCK_SIZE  CryptoCC32XX_SHA256_BLOCK_SIZE

typedef enum
{
    CryptoCC32XX_AES  = 0x01, 
    CryptoCC32XX_DES  = 0x02, 
    CryptoCC32XX_HMAC = 0x04, 
} CryptoCC32XX_Type;

typedef enum
{
    CryptoCC32XX_AES_ECB = (CryptoCC32XX_AES << 8) | 1, 
    CryptoCC32XX_AES_CBC,                               
    CryptoCC32XX_AES_CTR,                               
    CryptoCC32XX_AES_ICM,                               
    CryptoCC32XX_AES_CFB,                               
    CryptoCC32XX_AES_GCM,                               
    CryptoCC32XX_AES_CCM,                               
    CryptoCC32XX_DES_ECB = (CryptoCC32XX_DES << 8) | 1, 
    CryptoCC32XX_DES_CBC,                               
    CryptoCC32XX_DES_CFB,                               
} CryptoCC32XX_EncryptMethod;

typedef enum
{
    CryptoCC32XX_HMAC_MD5 = (CryptoCC32XX_HMAC << 8) | 1, 
    CryptoCC32XX_HMAC_SHA1,                               
    CryptoCC32XX_HMAC_SHA224,                             
    CryptoCC32XX_HMAC_SHA256                              
} CryptoCC32XX_HmacMethod;

typedef enum
{
    CryptoCC32XX_AES_KEY_SIZE_128BIT,
    CryptoCC32XX_AES_KEY_SIZE_192BIT,
    CryptoCC32XX_AES_KEY_SIZE_256BIT

} CryptoCC32XX_AesKeySize;

typedef enum
{
    CryptoCC32XX_DES_KEY_SIZE_SINGLE,
    CryptoCC32XX_DES_KEY_SIZE_TRIPLE

} CryptoCC32XX_DesKeySize;

typedef struct
{
    uint8_t *pKey2;                   
    CryptoCC32XX_AesKeySize key2Size; 
    size_t len;                       
} CryptoCC32XX_AesAadInputParams;

typedef union
{
    CryptoCC32XX_AesAadInputParams input; 
    uint8_t tag[16];                      
} CryptoCC32XX_AesAadParams;

typedef struct
{
    const uint8_t *pKey;             
    CryptoCC32XX_AesKeySize keySize; 
    void *pIV;                       
    CryptoCC32XX_AesAadParams aadParams;
} CryptoCC32XX_AesParams;

typedef struct
{
    const uint8_t *pKey;             
    CryptoCC32XX_DesKeySize keySize; 
    void *pIV;                       
} CryptoCC32XX_DesParams;

typedef union
{
    CryptoCC32XX_AesParams aes;
    CryptoCC32XX_DesParams des;
} CryptoCC32XX_EncryptParams;

typedef struct
{
    uint8_t *pKey;
    uint8_t moreData;
    void *pContext;
    uint8_t first;
    uint32_t digestCount;
    uint8_t innerDigest[CryptoCC32XX_MAX_DIGEST_SIZE];
    uint8_t buff[CryptoCC32XX_MAX_BLOCK_SIZE];
    uint32_t buffLen;
    uint32_t blockSize;
} CryptoCC32XX_HmacParams;

typedef struct
{

    void *object;

} CryptoCC32XX_Config;

typedef CryptoCC32XX_Config *CryptoCC32XX_Handle;

typedef struct
{
    HwiP_Handle hwiHandle[CryptoCC32XX_MAX_TYPES];
    bool isOpen;
    SemaphoreP_Handle sem[CryptoCC32XX_MAX_TYPES];
} CryptoCC32XX_Object;

void CryptoCC32XX_close(CryptoCC32XX_Handle handle);

void CryptoCC32XX_init(void);

CryptoCC32XX_Handle CryptoCC32XX_open(uint32_t index, uint32_t types);

void CryptoCC32XX_HmacParams_init(CryptoCC32XX_HmacParams *params);

int32_t CryptoCC32XX_encrypt(CryptoCC32XX_Handle handle,
                             CryptoCC32XX_EncryptMethod method,
                             void *pInBuff,
                             size_t inLen,
                             void *pOutBuff,
                             size_t *outLen,
                             CryptoCC32XX_EncryptParams *pParams);

int32_t CryptoCC32XX_decrypt(CryptoCC32XX_Handle handle,
                             CryptoCC32XX_EncryptMethod method,
                             void *pInBuff,
                             size_t inLen,
                             void *pOutBuff,
                             size_t *outLen,
                             CryptoCC32XX_EncryptParams *pParams);

int32_t CryptoCC32XX_sign(CryptoCC32XX_Handle handle,
                          CryptoCC32XX_HmacMethod method,
                          void *pBuff,
                          size_t len,
                          uint8_t *pSignature,
                          CryptoCC32XX_HmacParams *pParams);

int32_t CryptoCC32XX_verify(CryptoCC32XX_Handle handle,
                            CryptoCC32XX_HmacMethod method,
                            void *pBuff,
                            size_t len,
                            uint8_t *pSignature,
                            CryptoCC32XX_HmacParams *pParams);

#ifdef __cplusplus
}
#endif

#endif /* ti_drivers_CryptoCC32XX__include */