/* * The Clear BSD License * Copyright (c) 2015, Freescale Semiconductor, Inc. * Copyright 2016-2018 NXP * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted (subject to the limitations in the disclaimer below) provided * that the following conditions are met: * * o Redistributions of source code must retain the above copyright notice, this list * of conditions and the following disclaimer. * * o 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. * * o Neither the name of the copyright holder nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. * 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 _FSL_LTC_EDMA_H_ #define _FSL_LTC_EDMA_H_ #include "fsl_common.h" #include "fsl_edma.h" #include "fsl_ltc.h" /*! * @addtogroup ltc_edma_driver * @{ */ /******************************************************************************* * Definitions ******************************************************************************/ /*! @name Driver version */ /*@{*/ /*! @brief LTC EDMA driver version. Version 2.0.5. */ #define FSL_LTC_EDMA_DRIVER_VERSION (MAKE_VERSION(2, 0, 5)) /*@}*/ /* @brief The LTC eDMA handle type. */ typedef struct _ltc_edma_handle ltc_edma_handle_t; /*! @brief LTC eDMA callback function. */ typedef void (*ltc_edma_callback_t)(LTC_Type *base, ltc_edma_handle_t *handle, status_t status, void *userData); /*! @brief LTC eDMA state machine function. It is defined only for private usage inside LTC eDMA driver. */ typedef status_t (*ltc_edma_state_machine_t)(LTC_Type *base, ltc_edma_handle_t *handle); /*! * @brief LTC eDMA handle. It is defined only for private usage inside LTC eDMA driver. */ struct _ltc_edma_handle { ltc_edma_callback_t callback; /*!< Callback function. */ void *userData; /*!< LTC callback function parameter.*/ edma_handle_t *inputFifoEdmaHandle; /*!< The eDMA TX channel used. */ edma_handle_t *outputFifoEdmaHandle; /*!< The eDMA RX channel used. */ ltc_edma_state_machine_t state_machine; /*!< State machine. */ uint32_t state; /*!< Internal state. */ const uint8_t *inData; /*!< Input data. */ uint8_t *outData; /*!< Output data. */ uint32_t size; /*!< Size of input and output data in bytes.*/ uint32_t modeReg; /*!< LTC mode register.*/ /* Used by AES CTR*/ uint8_t *counter; /*!< Input counter (updates on return)*/ const uint8_t *key; /*!< Input key to use for forward AES cipher*/ uint32_t keySize; /*!< Size of the input key, in bytes. Must be 16, 24, or 32.*/ uint8_t *counterlast; /*!< Output cipher of last counter, for chained CTR calls. NULL can be passed if chained calls are not used.*/ uint32_t *szLeft; /*!< Output number of bytes in left unused in counterlast block. NULL can be passed if chained calls are not used.*/ uint32_t lastSize; /*!< Last size.*/ }; /******************************************************************************* * API ******************************************************************************/ #if defined(__cplusplus) extern "C" { #endif /*! * @brief Init the LTC eDMA handle which is used in transcational functions * @param base LTC module base address * @param handle Pointer to ltc_edma_handle_t structure * @param callback Callback function, NULL means no callback. * @param userData Callback function parameter. * @param inputFifoEdmaHandle User requested eDMA handle for Input FIFO eDMA. * @param outputFifoEdmaHandle User requested eDMA handle for Output FIFO eDMA. */ void LTC_CreateHandleEDMA(LTC_Type *base, ltc_edma_handle_t *handle, ltc_edma_callback_t callback, void *userData, edma_handle_t *inputFifoEdmaHandle, edma_handle_t *outputFifoEdmaHandle); /*! @}*/ /******************************************************************************* * AES API ******************************************************************************/ /*! * @addtogroup ltc_edma_driver_aes * @{ */ /*! * @brief Encrypts AES using the ECB block mode. * * Encrypts AES using the ECB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plain text to encrypt * @param[out] ciphertext Output cipher text * @param size Size of input and output data in bytes. Must be multiple of 16 bytes. * @param key Input key to use for encryption * @param keySize Size of the input key, in bytes. Must be 16, 24, or 32. * @return Status from encrypt operation */ status_t LTC_AES_EncryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t *key, uint32_t keySize); /*! * @brief Decrypts AES using ECB block mode. * * Decrypts AES using ECB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input cipher text to decrypt * @param[out] plaintext Output plain text * @param size Size of input and output data in bytes. Must be multiple of 16 bytes. * @param key Input key. * @param keySize Size of the input key, in bytes. Must be 16, 24, or 32. * @param keyType Input type of the key (allows to directly load decrypt key for AES ECB decrypt operation.) * @return Status from decrypt operation */ status_t LTC_AES_DecryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t *key, uint32_t keySize, ltc_aes_key_t keyType); /*! * @brief Encrypts AES using CBC block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plain text to encrypt * @param[out] ciphertext Output cipher text * @param size Size of input and output data in bytes. Must be multiple of 16 bytes. * @param iv Input initial vector to combine with the first input block. * @param key Input key to use for encryption * @param keySize Size of the input key, in bytes. Must be 16, 24, or 32. * @return Status from encrypt operation */ status_t LTC_AES_EncryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_AES_IV_SIZE], const uint8_t *key, uint32_t keySize); /*! * @brief Decrypts AES using CBC block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input cipher text to decrypt * @param[out] plaintext Output plain text * @param size Size of input and output data in bytes. Must be multiple of 16 bytes. * @param iv Input initial vector to combine with the first input block. * @param key Input key to use for decryption * @param keySize Size of the input key, in bytes. Must be 16, 24, or 32. * @param keyType Input type of the key (allows to directly load decrypt key for AES CBC decrypt operation.) * @return Status from decrypt operation */ status_t LTC_AES_DecryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_AES_IV_SIZE], const uint8_t *key, uint32_t keySize, ltc_aes_key_t keyType); /*! * @brief Encrypts or decrypts AES using CTR block mode. * * Encrypts or decrypts AES using CTR block mode. * AES CTR mode uses only forward AES cipher and same algorithm for encryption and decryption. * The only difference between encryption and decryption is that, for encryption, the input argument * is plain text and the output argument is cipher text. For decryption, the input argument is cipher text * and the output argument is plain text. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param input Input data for CTR block mode * @param[out] output Output data for CTR block mode * @param size Size of input and output data in bytes * @param[in,out] counter Input counter (updates on return) * @param key Input key to use for forward AES cipher * @param keySize Size of the input key, in bytes. Must be 16, 24, or 32. * @param[out] counterlast Output cipher of last counter, for chained CTR calls. NULL can be passed if chained calls are * not used. * @param[out] szLeft Output number of bytes in left unused in counterlast block. NULL can be passed if chained calls * are not used. * @return Status from encrypt operation */ status_t LTC_AES_CryptCtrEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *input, uint8_t *output, uint32_t size, uint8_t counter[LTC_AES_BLOCK_SIZE], const uint8_t *key, uint32_t keySize, uint8_t counterlast[LTC_AES_BLOCK_SIZE], uint32_t *szLeft); /*! AES CTR decrypt is mapped to the AES CTR generic operation */ #define LTC_AES_DecryptCtrEDMA(base, handle, input, output, size, counter, key, keySize, counterlast, szLeft) \ LTC_AES_CryptCtrEDMA(base, handle, input, output, size, counter, key, keySize, counterlast, szLeft) /*! AES CTR encrypt is mapped to the AES CTR generic operation */ #define LTC_AES_EncryptCtrEDMA(base, handle, input, output, size, counter, key, keySize, counterlast, szLeft) \ LTC_AES_CryptCtrEDMA(base, handle, input, output, size, counter, key, keySize, counterlast, szLeft) /*! *@} */ /******************************************************************************* * DES API ******************************************************************************/ /*! * @addtogroup ltc_edma_driver_des * @{ */ /*! * @brief Encrypts DES using ECB block mode. * * Encrypts DES using ECB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param key Input key to use for encryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_EncryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts DES using ECB block mode. * * Decrypts DES using ECB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param key Input key to use for decryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_DecryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts DES using CBC block mode. * * Encrypts DES using CBC block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Ouput ciphertext * @param size Size of input and output data in bytes * @param iv Input initial vector to combine with the first plaintext block. * The iv does not need to be secret, but it must be unpredictable. * @param key Input key to use for encryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_EncryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts DES using CBC block mode. * * Decrypts DES using CBC block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input data in bytes * @param iv Input initial vector to combine with the first plaintext block. * The iv does not need to be secret, but it must be unpredictable. * @param key Input key to use for decryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_DecryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts DES using CFB block mode. * * Encrypts DES using CFB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param size Size of input data in bytes * @param iv Input initial block. * @param key Input key to use for encryption * @param[out] ciphertext Output ciphertext * @return Status from encrypt/decrypt operation */ status_t LTC_DES_EncryptCfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts DES using CFB block mode. * * Decrypts DES using CFB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes * @param iv Input initial block. * @param key Input key to use for decryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_DecryptCfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts DES using OFB block mode. * * Encrypts DES using OFB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes * @param iv Input unique input vector. The OFB mode requires that the IV be unique * for each execution of the mode under the given key. * @param key Input key to use for encryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_EncryptOfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts DES using OFB block mode. * * Decrypts DES using OFB block mode. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param iv Input unique input vector. The OFB mode requires that the IV be unique * for each execution of the mode under the given key. * @param key Input key to use for decryption * @return Status from encrypt/decrypt operation */ status_t LTC_DES_DecryptOfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using ECB block mode with two keys. * * Encrypts triple DES using ECB block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_EncryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using ECB block mode with two keys. * * Decrypts triple DES using ECB block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_DecryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using CBC block mode with two keys. * * Encrypts triple DES using CBC block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes * @param iv Input initial vector to combine with the first plaintext block. * The iv does not need to be secret, but it must be unpredictable. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_EncryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using CBC block mode with two keys. * * Decrypts triple DES using CBC block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes * @param iv Input initial vector to combine with the first plaintext block. * The iv does not need to be secret, but it must be unpredictable. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_DecryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using CFB block mode with two keys. * * Encrypts triple DES using CFB block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes * @param iv Input initial block. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_EncryptCfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using CFB block mode with two keys. * * Decrypts triple DES using CFB block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes * @param iv Input initial block. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_DecryptCfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using OFB block mode with two keys. * * Encrypts triple DES using OFB block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes * @param iv Input unique input vector. The OFB mode requires that the IV be unique * for each execution of the mode under the given key. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_EncryptOfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using OFB block mode with two keys. * * Decrypts triple DES using OFB block mode with two keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes * @param iv Input unique input vector. The OFB mode requires that the IV be unique * for each execution of the mode under the given key. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES2_DecryptOfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using ECB block mode with three keys. * * Encrypts triple DES using ECB block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_EncryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using ECB block mode with three keys. * * Decrypts triple DES using ECB block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes. Must be multiple of 8 bytes. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_DecryptEcbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using CBC block mode with three keys. * * Encrypts triple DES using CBC block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input data in bytes * @param iv Input initial vector to combine with the first plaintext block. * The iv does not need to be secret, but it must be unpredictable. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_EncryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using CBC block mode with three keys. * * Decrypts triple DES using CBC block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes * @param iv Input initial vector to combine with the first plaintext block. * The iv does not need to be secret, but it must be unpredictable. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_DecryptCbcEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using CFB block mode with three keys. * * Encrypts triple DES using CFB block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and ouput data in bytes * @param iv Input initial block. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_EncryptCfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using CFB block mode with three keys. * * Decrypts triple DES using CFB block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input data in bytes * @param iv Input initial block. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_DecryptCfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Encrypts triple DES using OFB block mode with three keys. * * Encrypts triple DES using OFB block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param plaintext Input plaintext to encrypt * @param[out] ciphertext Output ciphertext * @param size Size of input and output data in bytes * @param iv Input unique input vector. The OFB mode requires that the IV be unique * for each execution of the mode under the given key. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_EncryptOfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *plaintext, uint8_t *ciphertext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! * @brief Decrypts triple DES using OFB block mode with three keys. * * Decrypts triple DES using OFB block mode with three keys. * * @param base LTC peripheral base address * @param handle pointer to ltc_edma_handle_t structure which stores the transaction state. * @param ciphertext Input ciphertext to decrypt * @param[out] plaintext Output plaintext * @param size Size of input and output data in bytes * @param iv Input unique input vector. The OFB mode requires that the IV be unique * for each execution of the mode under the given key. * @param key1 First input key for key bundle * @param key2 Second input key for key bundle * @param key3 Third input key for key bundle * @return Status from encrypt/decrypt operation */ status_t LTC_DES3_DecryptOfbEDMA(LTC_Type *base, ltc_edma_handle_t *handle, const uint8_t *ciphertext, uint8_t *plaintext, uint32_t size, const uint8_t iv[LTC_DES_IV_SIZE], const uint8_t key1[LTC_DES_KEY_SIZE], const uint8_t key2[LTC_DES_KEY_SIZE], const uint8_t key3[LTC_DES_KEY_SIZE]); /*! *@} */ #if defined(__cplusplus) } #endif #endif /* _FSL_LTC_EDMA_H_ */