If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.
/*
* Copyright (c) 2017-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.
*/
/*
* ======== sha2hash.c ========
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <ti/sysbios/knl/Task.h> // For Task_construct and task related configuration
#include <ti/drivers/utils/Random.h> // for Random_getNumber()
/* Driver Header files */
#include <ti/drivers/UART.h>
#include <ti/drivers/SHA2.h>
#include <ti/drivers/AESCCM.h> // for AES-CCM
#include <ti/drivers/cryptoutils/cryptokey/CryptoKeyPlaintext.h> // for CryptoKeyPlaintext_initKey()
#include <ti/drivers/dpl/HwiP.h>
const char message[] =
"Premature optimization is the root of all evil (or at least most of it) in programming.";
uint8_t actualDigest[SHA2_DIGEST_LENGTH_BYTES_256];
uint8_t expectedDigest[] = {
0xF2, 0x6A, 0xFF, 0x01,
0x11, 0x6B, 0xF6, 0x77,
0x63, 0x91, 0xFE, 0xD9,
0x47, 0x56, 0x99, 0xB2,
0xAD, 0x7D, 0x64, 0x16,
0xF7, 0x40, 0x1A, 0x5B,
0xCC, 0xC7, 0x08, 0x3D,
0xE8, 0x6B, 0x35, 0x6D,
};
SHA2_Handle handle;
int_fast16_t result;
SHA2_Params params;
/* Driver configuration */
#include "ti_drivers_config.h"
int intState;
/* Defines */
#define MAX_MSG_LENGTH 256
/* UART pre-formated strings */
static const char promptStartup[] = "\n\n\rSHA2 Driver hash demo.";
static const char promptHash[] = "\n\n\rRandom Number: ";
/* Message buffers */
static char formatedMsg[MAX_MSG_LENGTH];
/*
* ======== printHash ========
*/
void printHash(UART_Handle handle, uint8_t* msg)
{
uint32_t i;
/* Format the message as printable hex */
for (i = 0; i < 1; i++) {
sprintf(formatedMsg + (i * 2), "%02X", *(msg + i));
}
/* Print prompt */
UART_write(handle, promptHash, strlen(promptHash));
/* Print result */
UART_write(handle, formatedMsg, strlen(formatedMsg));
}
/*
* ======== mainThread ========
*/
void *mainThread(void *arg0)
{
int_fast16_t result;
/* Driver handles */
UART_Handle uartHandle;
SHA2_Handle sha2Handle;
/* UART variables */
UART_Params uartParams;
/* Call driver initialization functions */
UART_init();
SHA2_init();
/* Open UART for console output */
UART_Params_init(&uartParams);
uartParams.writeDataMode = UART_DATA_BINARY;
uartParams.readDataMode = UART_DATA_BINARY;
uartParams.readReturnMode = UART_RETURN_FULL;
uartParams.readEcho = UART_ECHO_OFF;
uartParams.baudRate = 115200;
uartHandle = UART_open(CONFIG_UART_0, &uartParams);
if (!uartHandle) {
/* UART_open() failed */
while (1);
}
SHA2_Params_init(¶ms);
params.returnBehavior = SHA2_RETURN_BEHAVIOR_BLOCKING;
/* Prompt startup message */
UART_write(uartHandle, promptStartup, strlen(promptStartup));
for(;;)
{
handle = SHA2_open(0, ¶ms);
if(handle == NULL) {while(1);}
// We can configure the driver even after SHA2_open()
result = SHA2_setHashType(handle, SHA2_HASH_TYPE_256);
if(result != SHA2_STATUS_SUCCESS){while(1);}
// Process data in chunks. The driver buffers incomplete blocks internally.
result = SHA2_addData(handle, &message[0], 17);
if(result != SHA2_STATUS_SUCCESS){while(1);}
result = SHA2_addData(handle, &message[17], strlen(message) - 17);
if(result != SHA2_STATUS_SUCCESS){while(1);}
// Compute the resulting digest
result = SHA2_finalize(handle, actualDigest);
if(result != SHA2_STATUS_SUCCESS){while(1);}
// Verify
result = memcmp(actualDigest, expectedDigest, SHA2_DIGEST_LENGTH_BYTES_256);
SHA2_close(handle);
uint32_t randomNumber = Random_getNumber();
randomNumber %= 17;
Task_sleep((xdc_UInt32)randomNumber);
printHash(uartHandle, &randomNumber);
}
}
/*
* ======== mainThread ========
*/
void *mainThread2(void *arg0)
{
//
// SETUP
//
AESCCM_Handle aeshandle;
AESCCM_Params params;
CryptoKey cryptoKey;
AESCCM_Operation operation;
int_fast16_t status = 0;
// Initialize the AES-CCM peripheral
AESCCM_init();
AESCCM_Params_init(¶ms);
params.returnBehavior = AESCCM_RETURN_BEHAVIOR_POLLING;
for(;;)
{
aeshandle = AESCCM_open(0, ¶ms);
if (!aeshandle) {
while (1);
}
uint8_t nonce[] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
uint8_t aad[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
uint8_t plaintext[] = {0x20, 0x21, 0x22, 0x23};
uint8_t keyingMaterial[] = {0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F};
uint8_t mac[4];
uint8_t ciphertext_generated[4];
memset(ciphertext_generated, 0, 4);
uint8_t plaintext_generated[4];
memset(plaintext_generated, 0, 4);
// Create the key
CryptoKeyPlaintext_initKey(&cryptoKey, keyingMaterial, 32);
// Verify Encryption
AESCCM_Operation_init(&operation);
operation.key = &cryptoKey;
operation.aad = &aad[0];
operation.aadLength = 8;
operation.input = &plaintext[0];
operation.output = &ciphertext_generated[0];
operation.inputLength = 4;
operation.nonce = &nonce[0];
operation.nonceLength = 7;
operation.mac = &mac[0];
operation.macLength = 4;
status = AESCCM_oneStepEncrypt(aeshandle, &operation);
AESCCM_close(aeshandle);
// again wait so TDC_REF clock request can be acknowledge
//Task_sleep((xdc_UInt32)100);
uint32_t randomNumber = Random_getNumber();
Task_sleep((xdc_UInt32)randomNumber % 23);
}
}
