CC3200 AES 代码

只看该作者 · 2019-7-31 21:37

概述
推进加密标准(AES)安全模块，提供硬件加速数据的加密和解密基于二进制的 AES 是一
个对称密码模块,它支持 128,192,或 256 位密钥加密和解密的硬件。 AES 模块是基于对称算
法，这意味着加密和解密密钥是相同的。加密数据意味着从纯文本转换为一种特殊的形式称
为密文。解密密文意味着将加密的数据改回到原来的纯文本形式。

只看该作者 · 2019-7-31 21:37

应用说明
应用程序的引用使用 AES DriverLib 函数。开发人员/用户可以参考这个简单的应
用程序和重用这个功能在应用程序。这个应用程序在有或没有“Uart 终端” 的情况下都
可以使用。

只看该作者 · 2019-7-31 21:38

如果用户希望使用“Uart 终端”输入，按照下面操作，通过定义“USER_INPUT”
在 aes_main.c 文件中。
• aesdemo: 此命令允许用户运行 AES 功能。需要两个参数 aes-mode 和 key-len。
-aes-mode 是用户可以选择的 AES 算法，值可以是 ECB、 CBC、 CTR、 ICM 或者 CFB。
-key-len 是用户需要定义的长度，值可以使 128、 192、或者 256。
接下来，系统将提示用户输入” key” 和” 纯文本输入” ,没有定义 USER-INPUT,将允许
用户按照执行路径在 IAR 或 CCS 集成开发环境,在“调试” 模式,用户不需要输入

只看该作者 · 2019-7-31 21:38

设置一个串行通信程序(超级终端/ TeraTerm)。终端设置如下：

只看该作者 · 2019-7-31 21:39

运行参考程序(Flashing the bin/IAR/CCS)。在超级终端上，出现一个提示：需要下达 AES 命令，可以看到结果。运行结果如下图所示

只看该作者 · 2019-7-31 21:40

static volatile bool g_bContextInIntFlag;
static volatile bool g_bDataInIntFlag;
static volatile bool g_bContextOutIntFlag;
static volatile bool g_bDataOutIntFlag;

#if defined(ccs)
extern void (* const g_pfnVectors[])(void);
#endif
#if defined(ewarm)
extern uVectorEntry __vector_table;
#endif

只看该作者 · 2019-7-31 21:40

void AESCrypt(unsigned int uiConfig,unsigned int uiKeySize,unsigned int *puiKey1,
                  unsigned int *puiData, unsigned int *puiResult,
                  unsigned int uiDataLength,unsigned int *uiIV);
void AESIntHandler(void);
unsigned int * LoadDefaultValues(unsigned int ui32Config,unsigned int *uiConfig,
                        unsigned int *uiKeySize, unsigned int **uiIV,
                        unsigned int **puiKey1,unsigned int *uiDataLength,
                        unsigned int **puiResult);
static void BoardInit(void);

只看该作者 · 2019-7-31 21:40

void
AESCrypt(unsigned int uiConfig,unsigned int uiKeySize,unsigned int *puiKey1,
         unsigned int *puiData,unsigned int *puiResult,
         unsigned int uiDataLength,unsigned int *uiIV)
{
//
// Step1:  Enable Interrupts
// Step2:  Wait for Context Ready Inteerupt
// Step3:  Set the Configuration Parameters (Direction,AES Mode and Key Size)
// Step4:  Set the Initialization Vector
// Step5:  Write Key
// Step6:  Start the Crypt Process
//

//
// Clear the flags.
//
g_bContextInIntFlag = false;
g_bDataInIntFlag = false;
g_bContextOutIntFlag = false;
g_bDataOutIntFlag = false;

//
// Enable all interrupts.
//
MAP_AESIntEnable(AES_BASE, AES_INT_CONTEXT_IN |
                     AES_INT_CONTEXT_OUT | AES_INT_DATA_IN |
                     AES_INT_DATA_OUT);

//
// Wait for the context in flag, the flag will be set in the Interrupt handler.
//
while(!g_bContextInIntFlag)
{
}

//
// Configure the AES module with direction (encryption or decryption) and
// the key size.
//
MAP_AESConfigSet(AES_BASE, uiConfig |uiKeySize);

//
// Write the initial value registers if needed, depends on the mode.
//
if(((uiConfig & AES_CFG_MODE_M) == AES_CFG_MODE_CBC) ||
            ((uiConfig & AES_CFG_MODE_M) == AES_CFG_MODE_CFB) ||
            ((uiConfig & AES_CFG_MODE_M) == AES_CFG_MODE_CTR) ||
            ((uiConfig & AES_CFG_MODE_M) == AES_CFG_MODE_ICM)
            )
{
MAP_AESIVSet(AES_BASE, (unsigned char *)uiIV);
}

//
// Write key1.
//
MAP_AESKey1Set(AES_BASE,(unsigned char *)puiKey1,uiKeySize);

//
// Start Crypt Process
//
MAP_AESDataProcess(AES_BASE, (unsigned char *)puiData,
                     (unsigned char *)puiResult, uiDataLength);
}

只看该作者 · 2019-7-31 21:41

void
AESIntHandler(void)
{
uint32_t uiIntStatus;

//
// Read the AES masked interrupt status.
//
uiIntStatus = MAP_AESIntStatus(AES_BASE, true);

//
// Set Different flags depending on the interrupt source.
//
if(uiIntStatus & AES_INT_CONTEXT_IN)
{
      MAP_AESIntDisable(AES_BASE, AES_INT_CONTEXT_IN);
      g_bContextInIntFlag = true;
}
if(uiIntStatus & AES_INT_DATA_IN)
{
      MAP_AESIntDisable(AES_BASE, AES_INT_DATA_IN);
      g_bDataInIntFlag = true;
}
if(uiIntStatus & AES_INT_CONTEXT_OUT)
{
      MAP_AESIntDisable(AES_BASE, AES_INT_CONTEXT_OUT);
      g_bContextOutIntFlag = true;
}
if(uiIntStatus & AES_INT_DATA_OUT)
{
      MAP_AESIntDisable(AES_BASE, AES_INT_DATA_OUT);
      g_bDataOutIntFlag = true;
}

}

只看该作者 · 2019-7-31 21:41

unsigned int *
LoadDefaultValues(unsigned int ui32Config,unsigned int *uiConfig,
                  unsigned int *uiKeySize,
                  unsigned int **uiIV,unsigned int **puiKey1,
                  unsigned int *uiDataLength,unsigned int **puiResult)
{
unsigned int *uiData;

//
// Populate all the out parameters from pre-defined vector
//
*uiConfig=ui32Config;

//
// Read Key and Key size
//
*puiKey1=psAESCBCTestVectors.pui32Key1;
*uiKeySize=psAESCBCTestVectors.ui32KeySize;

//
// Read Initialization Vector
//
*uiIV=&psAESCBCTestVectors.pui32IV[0];

//
// Read Data Length and allocate Result and Data variables accordingly
//
*uiDataLength=psAESCBCTestVectors.ui32DataLength;
*puiResult=(unsigned int*)malloc(*uiDataLength);
if(*puiResult != NULL)
{
      memset(*puiResult,0,*uiDataLength);
}
else
{
      //Failed to allocate memory
      UART_PRINT("Failed to allocate memory");
      return 0;
}
uiData=(unsigned int*)malloc(*uiDataLength);
if(uiData != NULL)
{
      memset(uiData,0,*uiDataLength);
}
else
{
      //Failed to allocate memory
      UART_PRINT("Failed to allocate memory");
      return 0;
}
//
// Copy Plain Text or Cipher Text into the variable Data
//
if(ui32Config & AES_CFG_DIR_ENCRYPT)
      memcpy(uiData,psAESCBCTestVectors.pui32PlainText,*uiDataLength);
else
      memcpy(uiData,psAESCBCTestVectors.pui32CipherText,*uiDataLength);

return uiData;
}

只看该作者 · 2019-7-31 21:42

static void
DisplayBanner(char * AppName)
{
Report("\n\n\n\r");
Report("\t\t *************************************************\n\r");
Report("\t\t CC3200 %s Application \n\r", AppName);
Report("\t\t *************************************************\n\r");
Report("\n\n\n\r");
}

只看该作者 · 2019-7-31 21:42

static void
BoardInit(void)
{
/* In case of TI-RTOS vector table is initialize by OS itself */
#ifndef USE_TIRTOS
//
// Set vector table base
//
#if defined(ccs)
MAP_IntVTableBaseSet((unsigned long)&g_pfnVectors[0]);
#endif
#if defined(ewarm)
MAP_IntVTableBaseSet((unsigned long)&__vector_table);
#endif
#endif
//
// Enable Processor
//
MAP_IntMasterEnable();
MAP_IntEnable(FAULT_SYSTICK);

PRCMCC3200MCUInit();
}

只看该作者 · 2019-7-31 21:42

void
main()
{
unsigned int uiConfig,uiKeySize,*puiKey1,*puiData,*puiResult,
uiDataLength,uiIV[4]={0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c};

#ifdef USER_INPUT
unsigned int ui32CharCount;
unsigned char* pui8Result;
#else
unsigned int *puiIV;
puiIV=&uiIV[0];

#endif
BoardInit();

//
// Configuring UART for Receiving input and displaying output
// 1. PinMux setting
// 2. Initialize UART
// 3. Displaying Banner
//
PinMuxConfig();
InitTerm();
DisplayBanner(APP_NAME);

//
// Enable AES Module
//
MAP_PRCMPeripheralClkEnable(PRCM_DTHE, PRCM_RUN_MODE_CLK);

//
// Enable AES interrupts.
//
MAP_AESIntRegister(AES_BASE, AESIntHandler);
#ifdef USER_INPUT
while(FOREVER)
{
      //
      // Read values either from User or from Vector based on macro USER_INPUT
      // defined or not
      //

      //
      // Read the values from the user over uart and Populate the variables
      //
      puiData = ReadFromUser(&uiConfig,&uiKeySize,&puiKey1,&uiDataLength,\
                              &puiResult);
      if(puiData==NULL)
      {
         UART_PRINT("\n\rInvalid Input. Please try again. \n\r");
         continue;
      }
#else
      //
      // Load Default values
      //
      puiData = LoadDefaultValues(AES_CFG_DIR_ENCRYPT | AES_CFG_MODE_CBC ,
                                 &uiConfig,&uiKeySize,&puiIV,&puiKey1,
                                 &uiDataLength,&puiResult);
#endif

      //
      // Carry out Encryption
      //
      UART_PRINT("\n\r Encryption in progress....");
      AESCrypt(uiConfig,uiKeySize,puiKey1,puiData,puiResult,uiDataLength,uiIV);
      UART_PRINT("\n\r Encryption done, cipher text created");

      //
      // Copy Result into Data Vector to continue with Decryption. and change
      // config value
      //
      memcpy(puiData,puiResult,uiDataLength);
      uiConfig &= ~(1 << 2);
      //
      // Carry out Decryption
      //
      UART_PRINT("\n\r\n\r Decryption in progress....");
      AESCrypt(uiConfig,uiKeySize,puiKey1,puiData,puiResult,uiDataLength,uiIV);
      UART_PRINT("\n\r Decryption done");

      //
      // Display/Verify Result
      //

#ifdef USER_INPUT
      //
      // Display Plain Text
      //
      UART_PRINT("\n\r Text after decryption ");
      pui8Result = (unsigned char *)puiResult;
      for(ui32CharCount=0;ui32CharCount<uiDataLength;ui32CharCount++)
      {
         UART_PRINT("%c",*(pui8Result+ui32CharCount));
      }
      UART_PRINT("\n\r");
}
#else
      //
      // Compare Cipher Text and Plain Text with the expected values from
      // predefined vector
      //
      if(memcmp(puiData,psAESCBCTestVectors.pui32CipherText,
                     psAESCBCTestVectors.ui32DataLength)==0)
      {
         UART_PRINT("\n\r\n\r Encryption verification Successful");
      }
      else
      {
         UART_PRINT("\n\r\n\r Error in Encryption");
      }

      if(memcmp(puiResult,psAESCBCTestVectors.pui32PlainText,
                     psAESCBCTestVectors.ui32DataLength)==0)
      {
         UART_PRINT("\n\r Decryption verification Successful");
      }
      else
      {
         UART_PRINT("\n\r\n\r Error in Decryption");
      }
      while(FOREVER);
#endif

}

只看该作者 · 2019-7-31 21:43

bool
AESParser( char *ucCMD,unsigned int *uiConfig,unsigned int *uiKeySize)
{
char *ucInpString;
ucInpString = strtok(ucCMD, " ");

//
// Check Whether Command is valid
//
if((ucInpString != NULL) && ((!strcmp(ucInpString,"aesdemo"))))
{

      *uiConfig=AES_CFG_DIR_ENCRYPT;
      ucInpString=strtok(NULL," ");

      //
      // Get which Algorithm you are using for Encryption or Decryption
      //
      if(ucInpString != NULL && ((!strcmp(ucInpString,"ECB")) || \
                              !strcmp(ucInpString,"ecb")))
      {
         *uiConfig|=AES_CFG_MODE_ECB;
         ui32aes_mode = AES_CFG_MODE_ECB;

      }
      else if(ucInpString != NULL && (!strcmp(ucInpString,"CBC") || \
                              !strcmp(ucInpString,"cbc")))
      {
         *uiConfig|=AES_CFG_MODE_CBC;
         ui32aes_mode = AES_CFG_MODE_CBC;

      }
      else if(ucInpString != NULL && (!strcmp(ucInpString,"CTR") || \
                              !strcmp(ucInpString,"ctr")))
      {
         *uiConfig|=AES_CFG_MODE_CTR;
         ui32aes_mode = AES_CFG_MODE_CTR;

      }
      else if(ucInpString != NULL && (!strcmp(ucInpString,"ICM") || \
                              !strcmp(ucInpString,"icm")))
      {
         *uiConfig|=AES_CFG_MODE_ICM;
         ui32aes_mode = AES_CFG_MODE_ICM;

      }
      else if(ucInpString != NULL && (!strcmp(ucInpString,"CFB") || \
                              !strcmp(ucInpString,"cfb")))
      {
         *uiConfig|=AES_CFG_MODE_CFB;
         ui32aes_mode = AES_CFG_MODE_CFB;
      }
      else
      {
         UART_PRINT("\n\r Invalid Algorithm\n\r");
         return false;
      }

      //
      // Get Key Length
      //
      ucInpString=strtok(NULL,"");
      if(ucInpString != NULL)
      {
         *uiKeySize=strtoul(ucInpString, NULL, 10);
      }
      if(*uiKeySize==128)
         *uiKeySize=AES_CFG_KEY_SIZE_128BIT;
      else if(*uiKeySize==192)
         *uiKeySize=AES_CFG_KEY_SIZE_192BIT;
      else if(*uiKeySize==256)
         *uiKeySize=AES_CFG_KEY_SIZE_256BIT;
      else
      {
         UART_PRINT("\n\r Invalid KeySize \n\r");
         return false;
      }
      return true;
}
else
{
      UART_PRINT("\n\r Invalid Command \n\r");
      return false;
}
}

只看该作者 · 2019-7-31 21:44

bool
GetKey(unsigned int uiKeySize, char *pucKeyBuff)
{
  char cChar;
  unsigned int uiMsgLen;
  UART_PRINT("\n\r Do you want to use Pre-Defined Key ???(y/n) \n\r");

  //
  // Get the option
  //
  cChar = MAP_UARTCharGet(UARTA0_BASE);

  //
  // Echo the received character
  //
  MAP_UARTCharPut(UARTA0_BASE, cChar);
  UART_PRINT("\n\r");
  if(cChar=='y' || cChar=='Y' )
  {
   //
   // Fetch the key
   //
   if(uiKeySize==AES_CFG_KEY_SIZE_128BIT)
   {
      UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r "
               "Press 3 for Key - %s\n\r",AES128Key1,AES128Key2,AES128Key3);
      cChar = MAP_UARTCharGet(UARTA0_BASE);

      //
      // Echo the received character
      //
      MAP_UARTCharPut(UARTA0_BASE, cChar);
      UART_PRINT("\n\r");
      if(cChar=='1' )
      memcpy(&uiKey128,AES128Key1,16);
      else if(cChar=='2')
      memcpy(&uiKey128,AES128Key2,16);
      else if(cChar=='3')
      memcpy(&uiKey128,AES128Key3,16);
      else
      {
      UART_PRINT("\n\r Invalid Input \n\r");
      return false;
      }
   }
   else if(uiKeySize==AES_CFG_KEY_SIZE_192BIT)
   {
      UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r "
               "Press 3 for Key - %s\n\r",AES192Key1,AES192Key2,AES192Key3);
      cChar = MAP_UARTCharGet(UARTA0_BASE);

      //
      // Echo the received character
      //
      MAP_UARTCharPut(UARTA0_BASE, cChar);
      UART_PRINT("\n\r");
      if(cChar=='1' )
      memcpy(&uiKey192,AES192Key1,24);
      else if(cChar=='2')
      memcpy(&uiKey192,AES192Key2,24);
      else if(cChar=='3')
      memcpy(&uiKey192,AES192Key3,24);
      else
      {
      UART_PRINT("\n\r Invalid Input \n\r");
      return false;
      }
   }
   else if(uiKeySize==AES_CFG_KEY_SIZE_256BIT)
   {
      UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r"
               " Press 3 for Key - %s\n\r",AES256Key1,AES256Key2,AES256Key3);
      cChar = MAP_UARTCharGet(UARTA0_BASE);

      //
      // Echo the received character
      //
      MAP_UARTCharPut(UARTA0_BASE, cChar);
      UART_PRINT("\n\r");
      if(cChar=='1' )
      memcpy(&uiKey256,AES256Key1,32);
      else if(cChar=='2')
      memcpy(&uiKey256,AES256Key2,32);
      else if(cChar=='3')
      memcpy(&uiKey256,AES256Key3,32);
      else
      {
      UART_PRINT("\n\r Invalid Input \n\r");
      return false;
      }
   }

  }

  else if(cChar=='n' || cChar=='N')
  {
   //
   // Ask for the Key
   //
   UART_PRINT("\n\rEnter the Key \n\r");
   uiMsgLen=GetCmd(pucKeyBuff,520);
   if(uiMsgLen!=uiKeySize)
   {
      UART_PRINT("\n\r Enter Valid Key of length %d\n\r",uiKeySize);
      return false;
   }

  }
  else
  {
UART_PRINT("\n\r Invalid Input \n\r");
return false;
  }
  return true;
}

只看该作者 · 2019-7-31 21:44

unsigned int*
GetMsg( char *pucMsgBuff,unsigned int *uiDataLength)
{

int iMod=0;
unsigned int uiMsgLen,iSize;
unsigned int *uiData;
UART_PRINT("\n\r Enter the Message \n\r");
uiMsgLen=GetCmd(pucMsgBuff, 520);
if(uiMsgLen == 0)
{
return 0;
}

//
// For ECB and CBC mode, message should be blocks of 16 bytes.
//
iSize=uiMsgLen;
if((ui32aes_mode==AES_CFG_MODE_ECB)||(ui32aes_mode==AES_CFG_MODE_CBC))
{
      iMod = uiMsgLen%16;
      if(iMod!=0)
      {
         iSize = ((uiMsgLen/16)+1)*16;
      }
}

//
// Allocate Memory Buffer
//
*uiDataLength=iSize;
uiData=(unsigned int *)malloc(*uiDataLength);
memset(uiData,0,*uiDataLength);
memcpy(uiData,pucMsgBuff,(uiMsgLen));
return uiData;
}

只看该作者 · 2019-7-31 21:44

void
UsageDisplay()
{

UART_PRINT("\nCommand Usage \n\r");
UART_PRINT("-------------- \n\r");
UART_PRINT("aesdemo <aes_mode> <key_len> - AES Encryption and Decryption\n\r");
UART_PRINT("\n\r");
UART_PRINT("Parameters \n\r");
UART_PRINT("-------------- \n\r");
UART_PRINT("aes_mode - AES algorithm to be selected by the user [ECB|CBC|"
"CTR|ICM|CFB] \n\r");
UART_PRINT("key_len - Key length for decryption [128|192|256] \n\r");
UART_PRINT("--------------------------------------------------------------"
"----------- \n\r\n\r");
UART_PRINT("\n\r");

}

只看该作者 · 2019-7-31 21:44

unsigned int*
ReadFromUser(unsigned int *uiConfig,unsigned int *uiKeySize,unsigned int **uiKey
         ,unsigned int *uiDataLength,unsigned int **puiResult)
{
char ucCmdBuffer[520],*pucKeyBuff,*pucMsgBuff;
unsigned int *uiData;
pui32AESPlainMsg[0] = '\0';
pucMsgBuff=( char*)&pui32AESPlainMsg[0];

//
//Set the default keys.
//
SetKeys();
UsageDisplay();
UART_PRINT("cmd# ");
GetCmd(ucCmdBuffer,520);
if(AESParser(ucCmdBuffer,uiConfig,uiKeySize))
{
      //
      // Get Key Length
      //
      if(*uiKeySize==AES_CFG_KEY_SIZE_128BIT)
      {
         pucKeyBuff=(char*)&uiKey128[0];
         *uiKey=(unsigned int*)&uiKey128[0];
      }
      else if(*uiKeySize==AES_CFG_KEY_SIZE_192BIT)
      {
         pucKeyBuff=( char*)&uiKey192[0];
         *uiKey=(unsigned int*)&uiKey192[0];
      }
      else if(*uiKeySize==AES_CFG_KEY_SIZE_256BIT)
      {
         pucKeyBuff=( char*)&uiKey256[0];
         *uiKey=(unsigned int*)&uiKey256[0];
      }
      else
      {
         pucKeyBuff = (char *) malloc(BUFFER_LEN);
      }

      if(GetKey(*uiKeySize,pucKeyBuff))
      {
         uiData=GetMsg(pucMsgBuff,uiDataLength);
         if(uiData == 0)
         {
            return NULL;
         }
         *puiResult=(unsigned int *)malloc(*uiDataLength);
         memset(*puiResult,0,*uiDataLength);
      }
      else
      {
         UART_PRINT("\n\r Invalid Key \n\r");
         return NULL;
      }
}
else
{
      return NULL;
}
return uiData;
}

只看该作者 · 2019-7-31 21:45

void
SetKeys()
{
AES128Key1 = MemAllocAndCpy(16, "abcdefghijklmnpq");
AES128Key2 = MemAllocAndCpy(16, "rstuvwxyz1234567");
AES128Key3 = MemAllocAndCpy(16, "12345678abcdefgh");

AES192Key1 = MemAllocAndCpy(24, "abcdefghijklmnpqrstuvwxy");
AES192Key2 = MemAllocAndCpy(24, "rstuvwxyz1234567abcdefgh");
AES192Key3 = MemAllocAndCpy(24, "12345678abcdefghrstuvwxy");

AES256Key1 = MemAllocAndCpy(32, "abcdefghijklmnpqrstuvwxy12345678");
AES256Key2 = MemAllocAndCpy(32, "rstuvwxyz1234567abcdefghijklmnpq");
AES256Key3 = MemAllocAndCpy(32, "12345678abcdefghrstuvwxyijklmnpq");
}

只看该作者 · 2019-7-31 21:47

char *
MemAllocAndCpy(int size, char *keyVal)
{
  char * key =( char*)malloc(size);
  strcpy(key, keyVal);
  return key;
}

CC3200 AES 代码

相关下载

相关帖子