[ModusToolbox™] 【英飞凌CYW20829测评】篇5 CYW20829之AES加密

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

* File Name: main.c

*

* Description: This code provides an implementation of AES Cryptolite,

* demonstrating how to encrypt and decrypt data using the CTR and CFB modes.

*

* Related Document: See README.md

*

*******************************************************************************

* Copyright 2021-2024, Cypress Semiconductor Corporation (an Infineon company) or

* an affiliate of Cypress Semiconductor Corporation.  All rights reserved.

*

* This software, including source code, documentation and related

* materials ("Software") is owned by Cypress Semiconductor Corporation

* or one of its affiliates ("Cypress") and is protected by and subject to

* worldwide patent protection (United States and foreign),

* United States copyright laws and international treaty provisions.

* Therefore, you may use this Software only as provided in the license

* agreement accompanying the software package from which you

* obtained this Software ("EULA").

* If no EULA applies, Cypress hereby grants you a personal, non-exclusive,

* non-transferable license to copy, modify, and compile the Software

* source code solely for use in connection with Cypress's

* integrated circuit products.  Any reproduction, modification, translation,

* compilation, or representation of this Software except as specified

* above is prohibited without the express written permission of Cypress.

*

* Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND,

* EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED

* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress

* reserves the right to make changes to the Software without notice. Cypress

* does not assume any liability arising out of the application or use of the

* Software or any product or circuit described in the Software. Cypress does

* not authorize its products for use in any products where a malfunction or

* failure of the Cypress product may reasonably be expected to result in

* significant property damage, injury or death ("High Risk Product"). By

* including Cypress's product in a High Risk Product, the manufacturer

* of such system or application assumes all risk of such use and in doing

* so agrees to indemnify Cypress against all liability.

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



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

*Header Files

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



#include "cyhal.h"

#include "cybsp.h"

#include "cy_retarget_io.h"

#include "cy_pdl.h"

#include <string.h>



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

* Macros

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

/* The input message size (inclusive of the string terminating character '\0').

 * Edit this macro to suit your message size.

 */

#define MAX_MESSAGE_SIZE                     (100u)



/* Size of the message block that can be processed by Cryptolite hardware for

 * AES encryption.

 */

#define AES128_ENCRYPTION_LENGTH             (uint32_t)(16u)



#define AES128_KEY_LENGTH                    (uint32_t)(16u)



/* Number of bytes per line to be printed on the UART terminal. */

#define BYTES_PER_LINE                       (16u)



/* Time to wait to receive a character from UART terminal. */

#define UART_INPUT_TIMEOUT_MS                (1u)



/* Available commands */

#define CRYPTOLITE_AES_CTR ('1')

#define CRYPTOLITE_AES_CFB ('2')



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

* Data type definitions

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

/* Data type definition to track the state machine accepting the user message */

typedef enum

{

    MESSAGE_ENTER_NEW,

    MESSAGE_READY

} message_status_t;





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

* Global Variables

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



/* UART object used for reading character from terminal */

extern cyhal_uart_t cy_retarget_io_uart_obj;





/* Variables to hold the user message and the corresponding encrypted message */

static uint8_t message[MAX_MESSAGE_SIZE];

static uint8_t encrypted_msg[MAX_MESSAGE_SIZE];

static uint8_t decrypted_msg[MAX_MESSAGE_SIZE];



/* Key used for AES encryption*/

static uint8_t aes_key[AES128_KEY_LENGTH] = {0xAA, 0xBB, 0xCC, 0xDD,

                                            0xEE, 0xFF, 0xFF, 0xEE,

                                            0xDD, 0xCC, 0xBB, 0xAA,

                                            0xAA, 0xBB, 0xCC, 0xDD,};







/******************************CTR Encryption**********************************/

/* AES CFB MODE Initialization Vector*/

static uint8_t AesCtrIV[] =

{

    0x00,0x01,0x02,0x03,

    0x04,0x05,0x06,0x07,

    0x08,0x09,0x0A,0x0B,

    0x0C,0x0D,0x0E,0x0F,

};



static uint8_t AesCtrIV_copied[16];



/********************************CFB Encryption********************************/

/* AES CFB MODE Initialization Vector */

static uint8_t AesCfbIV[] =

{

    0x00,0x01,0x02,0x03,

    0x04,0x05,0x06,0x07,

    0x08,0x09,0x0A,0x0B,

    0x0C,0x0D,0x0E,0x0F,

};



static uint8_t AesCfbIV_copied[16];



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

 *Function Definitions

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



void print_data(uint8_t* data, uint8_t len);

void encrypt_message_cfb(uint8_t* message, uint8_t size);

void decrypt_message_cfb(uint8_t* message, uint8_t size);

void encrypt_message_ctr(uint8_t* message, uint8_t size);

void decrypt_message_ctr(uint8_t* message, uint8_t size);





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

* Function Name: main

********************************************************************************

* Summary:

* This is the main function and entry point to the application.

*

* Parameters:

*  void

*

* Return:

*  int

*

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



int main(void)

{

    cy_rslt_t result;



    uint8_t dst_cmd;

    /* Variable to track the status of the message entered by the user */

    message_status_t msg_status = MESSAGE_ENTER_NEW;

    uint8_t msg_size = 0;



    /* Initialize the device and board peripherals */

    result = cybsp_init();

    /* Board init failed. Stop program execution */

    if (result != CY_RSLT_SUCCESS)

    {

        CY_ASSERT(0);

    }



    /* Enable global interrupts */

    __enable_irq();



    /* Initialize retarget-io to use the debug UART port */

    result = cy_retarget_io_init_fc(    CYBSP_DEBUG_UART_TX,

                                        CYBSP_DEBUG_UART_RX,

                                        CYBSP_DEBUG_UART_CTS,

                                        CYBSP_DEBUG_UART_RTS,

                                        CY_RETARGET_IO_BAUDRATE);

    /* retarget-io init failed. Stop program execution */

    if (result != CY_RSLT_SUCCESS)

    {

        CY_ASSERT(0);

    }

    printf("*****************CE : Cryptolite AES *****************\r\n");

    printf("\r\n\nKey used for Encryption:\r\n");

    print_data(aes_key, AES128_KEY_LENGTH);

    printf("\n\rEnter the message:\r\n");

    for (;;)

    {

        switch (msg_status)

        {

            case MESSAGE_ENTER_NEW:

            {

                result = cyhal_uart_getc(&cy_retarget_io_uart_obj,

                                        &message[msg_size],

                                        UART_INPUT_TIMEOUT_MS);

                if (result == CY_RSLT_SUCCESS)

                    {

                    /* Check if the ENTER Key is pressed. If pressed, set the

                       message status as MESSAGE_READY.*/

                    if (message[msg_size] == '\r' || message[msg_size] == '\n')

                    {

                        message[msg_size]='\0';

                        msg_status = MESSAGE_READY;

                    }

                    else

                    {

                        cyhal_uart_putc(&cy_retarget_io_uart_obj,

                                        message[msg_size]);



                        /* Check if Backspace is pressed by the user. */

                        if(message[msg_size] != '\b')

                        {

                            msg_size++;

                        }

                        else

                        {

                            if(msg_size > 0)

                            {

                                msg_size--;

                            }

                        }

                        /*Check if size of the message  exceeds MAX_MESSAGE_SIZE

                        (inclusive of the string terminating character '\0').*/

                        if (msg_size > (MAX_MESSAGE_SIZE - 1))

                        {

                        printf("\r\n\nMessage length exceeds %d characters!!!"\

                        " Please enter a shorter message\r\nor edit the macro "\

                        "MAX_MESSAGE_SIZE to suit your message size\r\n", MAX_MESSAGE_SIZE);



                        /* Clear the message buffer and set the msg_status to

                            accept new message from the user. */

                        msg_status = MESSAGE_ENTER_NEW;

                        memset(message, 0, MAX_MESSAGE_SIZE);

                        msg_size = 0;

                        printf("\r\nEnter the message when more than limit:\r\n");

                        break;

                        }

                    }

                    }

                    break;

                }



                case MESSAGE_READY:

                {

                printf("\n\n\r Choose one of the following AES Mode :\r\n");

                printf("\n\r (1) CTR (Counter) mode\r\n");

                printf("\n\r (2) CFB (Cipher Feedback Block) mode\r\n");

                while(cyhal_uart_getc(&cy_retarget_io_uart_obj, &dst_cmd, 1)!= CY_RSLT_SUCCESS);

                cyhal_uart_putc(&cy_retarget_io_uart_obj, dst_cmd);



                if (CRYPTOLITE_AES_CTR == dst_cmd)

                {

                    printf("\n\r[Command] : AES CTR Mode\r\n");

                    encrypt_message_ctr(message, msg_size);

                    decrypt_message_ctr(message, msg_size);

                }

                else if (CRYPTOLITE_AES_CFB == dst_cmd)

                {

                    printf("\n\r[Command] : AES CFB Mode\r\n");

                    encrypt_message_cfb(message, msg_size);

                    decrypt_message_cfb(message, msg_size);

                }



                /* Clear the message buffer and set the msg_status to accept

                * new message from the user.

                */



                msg_status = MESSAGE_ENTER_NEW;

                memset(message, 0, MAX_MESSAGE_SIZE);

                msg_size = 0;

                printf("\n\n\rEnter the message again to accept:\r\n");

                break;

                }

            }

        }



}



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

* Function Name: print_data()

********************************************************************************

* Summary: Function used to display the data in hexadecimal format

*

* Parameters:

*  uint8_t* data - Pointer to location of data to be printed

*  uint8_t  len  - length of data to be printed

*

* Return:

*  void

*

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



void print_data(uint8_t* data, uint8_t len)

{

    char print[10];

    for (uint32 i=0; i < len; i++)

    {

        if ((i % BYTES_PER_LINE) == 0)

        {

            printf("\r\n");

        }

        snprintf(print,10,"0x%02X ", *(data+i));

        printf("%s", print);

    }

    printf("\r\n");

}



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

* Function Name: encrypt_message_cfb

********************************************************************************

* Summary: Function used to encrypt the message through cfb mode.

*

* Parameters:

*  char * message - pointer to the message to be encrypted

*  uint8_t size   - size of message to be encrypted.

*

* Return:

*  void

*

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





void encrypt_message_cfb(uint8_t* message, uint8_t size)

{

    cy_stc_cryptolite_aes_state_t aes_state;

    cy_stc_cryptolite_aes_buffers_t aesBuffers;

    uint8_t aes_block_count = 0;

    cy_en_cryptolite_status_t res;

    void* result;



    aes_block_count =  (size % AES128_ENCRYPTION_LENGTH == 0) ?

                       (size / AES128_ENCRYPTION_LENGTH)

                       : (1 + size / AES128_ENCRYPTION_LENGTH);



    /* Initializes the AES operation by setting key and key length */

    res = Cy_Cryptolite_Aes_Init(CRYPTOLITE, aes_key, &aes_state, &aesBuffers);

    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }



    result = memcpy(AesCfbIV_copied, AesCfbIV, sizeof(AesCfbIV));

    if(result == NULL)

    {

        perror("Memory failed\r\n");

    }



    res = Cy_Cryptolite_Aes_Cfb(  CRYPTOLITE,

                            CY_CRYPTOLITE_ENCRYPT,

                            aes_block_count * AES128_ENCRYPTION_LENGTH,

                            AesCfbIV_copied,

                            encrypted_msg,

                            message,

                            &aes_state);



    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }

    res = Cy_Cryptolite_Aes_Free(CRYPTOLITE,&aes_state);

    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }

    printf("\r\nResult of Encryption:\r\n");

    print_data((uint8_t*) encrypted_msg,

                aes_block_count * AES128_ENCRYPTION_LENGTH );



}



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

* Function Name: decrypt_message

********************************************************************************

* Summary: Function used to decrypt the message for cfb mode.

*

* Parameters:

*  char * message - pointer to the message to be decrypted

*  uint8_t size   - size of message to be decrypted.

*

* Return:

*  void

*

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



void decrypt_message_cfb(uint8_t* message, uint8_t size)

{

    cy_stc_cryptolite_aes_state_t aes_state;

    cy_stc_cryptolite_aes_buffers_t aesBuffers;

    uint8_t aes_block_count = 0;

    cy_en_cryptolite_status_t res;

    void* result;



    aes_block_count =  (size % AES128_ENCRYPTION_LENGTH == 0) ?

                       (size / AES128_ENCRYPTION_LENGTH)

                       : (1 + size / AES128_ENCRYPTION_LENGTH);



    /* Initializes the AES operation by setting key and key length */

    res = Cy_Cryptolite_Aes_Init(CRYPTOLITE, aes_key, &aes_state, &aesBuffers);

    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }

    /* Start decryption operation*/

    result = memcpy(AesCfbIV_copied, AesCfbIV, sizeof(AesCfbIV));

    if(result == NULL)

    {

       perror("Memory failed\r\n");

    }

    res = Cy_Cryptolite_Aes_Cfb(CRYPTOLITE,

                            CY_CRYPTOLITE_DECRYPT,

                            aes_block_count * AES128_ENCRYPTION_LENGTH,

                            AesCfbIV_copied,

                            decrypted_msg,

                            encrypted_msg,

                            &aes_state);

    if(res!=CY_CRYPTOLITE_SUCCESS)

        {

            CY_ASSERT(0);

        }

    res = Cy_Cryptolite_Aes_Free(CRYPTOLITE,&aes_state);

    if(res!=CY_CRYPTOLITE_SUCCESS)

        {

            CY_ASSERT(0);

        }

    decrypted_msg[size]='\0';

    /* Print the decrypted message on the UART terminal */

    printf("\r\nResult of Decryption:\r\n\n");

    printf("%s", decrypted_msg);



}



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

* Function Name: encrypt_message_cfb

********************************************************************************

* Summary: Function used to encrypt the message through ctr mode.

*

* Parameters:

*  char * message - pointer to the message to be encrypted

*  uint8_t size   - size of message to be encrypted.

*

* Return:

*  void

*

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



void encrypt_message_ctr(uint8_t* message, uint8_t size)

{

    uint32_t srcOffset;

    cy_stc_cryptolite_aes_state_t aes_state;

    cy_stc_cryptolite_aes_buffers_t aesBuffers;

    uint8_t aes_block_count = 0;

    cy_en_cryptolite_status_t res;

    void* result;



    aes_block_count =  (size % AES128_ENCRYPTION_LENGTH == 0) ?

                       (size / AES128_ENCRYPTION_LENGTH)

                       : (1 + size / AES128_ENCRYPTION_LENGTH);

    /* Initializes the AES operation by setting key and key length */

     res = Cy_Cryptolite_Aes_Init(CRYPTOLITE, aes_key, &aes_state, &aesBuffers);

     if(res!=CY_CRYPTOLITE_SUCCESS)

     {

       CY_ASSERT(0);

     }



     srcOffset = 0;

     result = memcpy(AesCtrIV_copied, AesCtrIV, sizeof(AesCtrIV));

     if(result == NULL)

     {

       perror("Memory failed\r\n");

     }

     res = Cy_Cryptolite_Aes_Ctr( CRYPTOLITE,

                            aes_block_count * AES128_ENCRYPTION_LENGTH,

                            &srcOffset,

                            AesCtrIV_copied,

                            encrypted_msg,

                            message,

                            &aes_state);

     if(res!=CY_CRYPTOLITE_SUCCESS)

     {

       CY_ASSERT(0);

     }

     res = Cy_Cryptolite_Aes_Free(CRYPTOLITE,&aes_state);

     if(res!=CY_CRYPTOLITE_SUCCESS)

     {

       CY_ASSERT(0);

     }

     printf("\r\nResult of Encryption:\r\n");

     print_data((uint8_t*) encrypted_msg,

                aes_block_count * AES128_ENCRYPTION_LENGTH );



}



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

* Function Name: decrypt_message

********************************************************************************

* Summary: Function used to decrypt the message for ctr mode.

*

* Parameters:

*  char * message - pointer to the message to be decrypted

*  uint8_t size   - size of message to be decrypted.

*

* Return:

*  void

*

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



void decrypt_message_ctr(uint8_t* message, uint8_t size)

{

    uint32_t srcOffset;

    cy_stc_cryptolite_aes_state_t aes_state;

    cy_stc_cryptolite_aes_buffers_t aesBuffers;

    uint8_t aes_block_count = 0;

    cy_en_cryptolite_status_t res;

    void* result;

    aes_block_count =  (size % AES128_ENCRYPTION_LENGTH == 0) ?

                       (size / AES128_ENCRYPTION_LENGTH)

                       : (1 + size / AES128_ENCRYPTION_LENGTH);



    /* Initializes the AES operation by setting key and key length */

    res = Cy_Cryptolite_Aes_Init(CRYPTOLITE, aes_key, &aes_state, &aesBuffers);

    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }

    srcOffset = 0;

    /* Start decryption operation*/

    result = memcpy(AesCtrIV_copied, AesCtrIV, sizeof(AesCtrIV));

    if(result == NULL)

    {

        perror("Memory failed\r\n");

    }

    res = Cy_Cryptolite_Aes_Ctr(  CRYPTOLITE,

                            aes_block_count * AES128_ENCRYPTION_LENGTH,

                            &srcOffset,

                            AesCtrIV_copied,

                            decrypted_msg,

                            encrypted_msg,

                            &aes_state);

    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }

    res = Cy_Cryptolite_Aes_Free(CRYPTOLITE,&aes_state);

    if(res!=CY_CRYPTOLITE_SUCCESS)

    {

        CY_ASSERT(0);

    }

    decrypted_msg[size]='\0';

    /* Print the decrypted message on the UART terminal */

    printf("\r\nResult of Decryption:\r\n\n");

    printf("%s", decrypted_msg);



}



/* [] END OF FILE */