CUBEBITE
CEBF746 Module.. with TPM
Dependencies: cube_CEBF746 cube_crypto cube_crc_16
Diff: main.cpp
- Revision:
- 4:85dda8d9a528
- Parent:
- 3:9ab0f5f0ed9e
- Child:
- 5:79ea2d57baf3
--- a/main.cpp Fri Oct 14 04:42:08 2016 +0000
+++ b/main.cpp Wed Oct 19 08:53:08 2016 +0000
@@ -9,8 +9,11 @@
// PB8 - SCL
#include "mbed.h"
+#include "lib_CEBF746.h"
#include "lib_crc.h"
+#define SPI_INTERRUPT 0
+
#define DEBUG_SPI
#ifdef DEBUG_SPI
#define PRINTD(arg1,arg2...) printf(arg1,##arg2)
@@ -37,44 +40,139 @@
Serial pc_serial(USBTX, USBRX);
+#if SPI_INTERRUPT
InterruptIn spi_interrupt(SPI_SSEL); // Falling Edge
-SPISlave spi_slave(SPI_MOSI, SPI_MISO, SPI_SCLK, NC); // MOSI, MISO, SCLK(CLK), SSEL(CS)=NC
+#endif /* SPI_INTERRUPT */
-uint8_t slaveStatus = 0;
+SPISlave spi_slave(SPI_MOSI, SPI_MISO, SPI_SCLK, SPI_SSEL); // MOSI, MISO, SCLK(CLK), SSEL(CS)=NC
+
-typedef struct _spiDataStr{
-#define SIZE_CRC_BYTE 2
- int size; // data length + SIZE_CRC_BYTE
- char * data; // data
- uint16_t crc_16; // crc code(2byte)
-} spiDataStr;
+uint8_t cebStatus; // 1byte Status Register
+uint8_t cebBufEncrypt[CEB_BUF_SIZE] = {}; // 암호화 예정 버퍼
+uint8_t cebBufEncrypted[CEB_BUF_SIZE] = {}; // 암호화 완료된 버퍼
+
+uint8_t cebBufDecrypt[CEB_BUF_SIZE] = {}; // 복호화 예정 버퍼
+uint8_t cebBufDecrypted[CEB_BUF_SIZE] = {}; // 복호화 완료된 버퍼
+
+extern uint8_t readSelfTestValidateData[CEB_BUF_SIZE];
+extern uint8_t writeSelfTestValidateData[CEB_BUF_SIZE];
+
-enum CHIP_COMMAND
-{
- CHIP_COMMAND_STATUS_READ = 1,
- CHIP_COMMAND_STATUS_WRITE,
- CHIP_COMMAND_
-};
-#define COMMAND_STATUS_READ
-
-void execute_spi_slave_isr( void )
+enum cubeMenu
{
- char command = 0;
-// pc_serial.printf("spi 인터럽터 진입!!\n");
- pc_serial.printf("spi inturrupt!!\n");
+ CEBF746_SPI_SELF_TEST = 1,
+ CEBF746_SPI_SELF_TEST2 = 2,
+ CEBF746_READ_STATUS_REG = 3,
+ MENU_EXIT_Program = 9
+};
+
+static char cebf746_status_reg = 0xAA;
+
- while(1)
+bool spi_receive_wait(void)
+{
+#define ISR_TIMEOUT 100
+ int timeout;
+
+ while(!spi_slave.receive()) // wait SPI data input...
{
- if(spi_slave.receive())
+ timeout++;
+ if(ISR_TIMEOUT <= timeout)
{
- command = spi_slave.read(); // current command
- //pc_serial.printf("0x%02X\n", tempBuf);
+ pc_serial.printf("spi isr timeout\n");
+ return false;
}
}
+ return true;
}
+static char retCnt=0xFF;
+
+#if SPI_INTERRUPT
+void execute_spi_slave_isr( void )
+{
+
+ char cebf746Func;
+
+ spi_receive_wait();
+
+ cebf746Func = spi_slave.read();
+
+
+ switch(cebf746Func)
+ {
+ case 0x01: // FUNC_STATUS_REG
+
+ //spi_receive_wait();
+
+
+ //printf("[DEBUG] [M to S] eepAddr=0x%02x\n",eepAddr);
+ //for(int i=0;i<3;i++)
+ {
+ spi_slave.reply( retCnt );
+
+ //++eepAddr;
+ //printf("[0x%02x] ",spiMulti);
+ }
+
+ printf("[DEBUG] [M to S] retCnt [0x%02X]\n", retCnt);
+ retCnt--;
+ break;
+
+
+
+ }
+
+
+
+
+
+ /*
+#define ISR_TIMEOUT 100
+ int timeout;
+ char cebf746Func = 0;
+ //pc_serial.printf("init spi inturrupt!!\n");
+
+
+
+ timeout = 0;
+ while(!spi_slave.receive()) // wiat for cebf746 func byte (first byte)
+ {
+ timeout++;
+ if(ISR_TIMEOUT <= timeout)
+ {
+ pc_serial.printf("spi isr timeout\n");
+ return;
+ }
+ }
+
+ cebf746Func = spi_slave.read(); // read cebf746 func byte
+ //pc_serial.printf("[0x%02X]\n", cebf746Func);
+
+
+
+ switch(cebf746Func)
+ {
+ case 0x01: // FUNC_STATUS_REG
+ while(!spi_slave.receive());
+ spi_slave.reply( retCnt ); // return code
+ while(!spi_slave.receive());
+ spi_slave.reply( retCnt+1 ); // return code
+ while(!spi_slave.receive());
+ spi_slave.reply( retCnt+2 ); // return code
+ break;
+ }
+
+
+
+ pc_serial.printf("return code : 0x%02X \n", 0xBB);
+ pc_serial.printf("data : 0x%02X \n", retCnt);
+ retCnt++;
+ */
+}
+#endif /* SPI_INTERRUPT */
/** @brief slave init
*
@@ -85,10 +183,30 @@
spi_slave.frequency(SPI_CONFIG_FREQUENCY);
PRINTD("SPI Init.. Packet bit size=[%d] Frequency=[%d]Mhz\n", SPI_CONFIG_BIT, (SPI_CONFIG_FREQUENCY/1000000));
- spi_interrupt.mode(PullUp); // Pull up input
- spi_interrupt.fall(&execute_spi_slave_isr); // Attach the isr address to the falling edge interrupt
+ /*
+ spi_slave.reply(0);
+ spi_slave.reply(0);
+ spi_slave.reply(0);
+ spi_slave.reply(0);
+ spi_slave.reply(0);
+ spi_slave.reply(0);
+ */
+ PRINTD("SPI Init.. OK\n");
+
+
+
}
+#if SPI_INTERRUPT
+void SPI_InitInterrupt()
+{
+ spi_interrupt.rise(&execute_spi_slave_isr);
+ spi_interrupt.enable_irq();
+ //spi_interrupt.mode(PullDown); // Pull down input
+ //spi_interrupt.fall(&execute_spi_slave_isr); // Attach the isr address to the falling edge interrupt
+ PRINTD("SPI Interrupt Init.. OK\n");
+}
+#endif /* SPI_INTERRUPT */
void SPI_SlaveWrite()
{
@@ -141,7 +259,7 @@
}
#define EEPROM_SIZE 256
-char statusReg;
+
char eepBuf[EEPROM_SIZE];
/** @brief char buf print
@@ -180,6 +298,172 @@
}
+Timeout receiveTimeOut;
+bool timeOut = false;
+#define CEBF746_TIMEOUT 10 // 1 sec
+
+uint8_t slave_read_byte()
+{
+ while(!spi_slave.receive());
+ return spi_slave.read();
+}
+void slave_write_byte(uint8_t txData)
+{
+ spi_slave.reply( txData );
+ while(!spi_slave.receive());
+ spi_slave.read();
+}
+
+void slave_read_uint16(uint16_t* buf16)
+{
+ uint16_t temp;
+
+ temp = slave_read_byte();
+ *buf16 = temp << 8;
+
+ temp = slave_read_byte();
+ *buf16 |= temp;
+
+ //*buf16 = (slave_read_byte() << 8) | (slave_read_byte());
+}
+void slave_read_multi_byte(uint8_t* buf, int size)
+{
+ for(int iCnt = 0 ; iCnt < size ; ++iCnt)
+ *(buf+iCnt) = slave_read_byte();
+}
+
+void slave_write_multi_byte(uint8_t* buf, int size)
+{
+ for(int iCnt = 0 ; iCnt < size ; ++iCnt)
+ slave_write_byte(*(buf+iCnt));
+}
+
+
+#define YSH_CODE 1
+#if YSH_CODE
+typedef struct // #include <aes.h> -> mbed tls lib
+{
+ int nr; /*!< number of rounds */
+ uint32_t rk; /*!< AES round keys */
+ uint32_t buf[68]; /*!< unaligned data */
+}
+mbedtls_aes_context;
+
+typedef struct
+{
+ uint8_t iv[16];
+ uint8_t key[32];
+ uint8_t key_size;
+ uint16_t key_crc;
+}
+cube_sec_key;
+
+typedef struct
+{
+ uint8_t input_data[16];
+ uint8_t output_data[16];
+ uint8_t input_data_size;
+ uint8_t output_data_size;
+}
+cube_sec_data;
+
+typedef struct
+{
+ mbedtls_aes_context mbed_ctx;
+ uint8_t cmd;
+ cube_sec_data sec_data;
+ cube_sec_key sec_key;
+}
+cube_sec_context;
+
+
+void print_mbedtls_aes_context(mbedtls_aes_context printStr)
+{
+ printf("-------------mbedtls_aes_context---------\n");
+ printf("number of rounds : %d\n", printStr.nr);
+ printf("AES round keys : 0x%X\n", printStr.rk);
+ printf("unaligned data : ");
+ for(int iCnt = 0 ; iCnt < 68 ; iCnt++)
+ {
+ printf("%X",printStr.buf[iCnt]);
+ }
+ printf("\n");
+ //printf("-----------------------------------------\n");
+}
+void print_cube_sec_data(cube_sec_data printStr)
+{
+ printf("--------------cube_sec_data--------------\n");
+ printf("input_data : ");
+ for(int iCnt = 0 ; iCnt < 16 ; iCnt++)
+ {
+ printf("%02X ",printStr.input_data[iCnt]);
+ }
+ printf("\n");
+
+ printf("output_data : ");
+ for(int iCnt = 0 ; iCnt < 16 ; iCnt++)
+ {
+ printf("%02X ",printStr.output_data[iCnt]);
+ }
+ printf("\n");
+
+ printf("input_data_size : %d\n", printStr.input_data_size);
+ printf("output_data_size : %d\n", printStr.output_data_size);
+
+ //printf("-----------------------------------------\n");
+}
+void print_cube_sec_key(cube_sec_key printStr)
+{
+ printf("-------------cube_sec_key------------------\n");
+ printf("iv : ");
+ for(int iCnt = 0 ; iCnt < 16 ; iCnt++)
+ {
+ printf("%02X ",printStr.iv[iCnt]);
+ }
+ printf("\n");
+
+ printf("key : ");
+ for(int iCnt = 0 ; iCnt < 32 ; iCnt++)
+ {
+ printf("%02X ",printStr.key[iCnt]);
+ }
+ printf("\n");
+
+ printf("key_size : %d\n", printStr.key_size);
+ printf("key_crc : %04X\n", printStr.key_crc);
+
+ //printf("-----------------------------------------\n");
+}
+void print_cube_sec_context(cube_sec_context printStr)
+{
+ printf("=============cube sec context print================\n");
+ print_mbedtls_aes_context(printStr.mbed_ctx);
+ printf("---------------- cmd --------------------\n");
+ printf("cmd : %02X\n", printStr.cmd);
+ //printf("-----------------------------------------\n");
+ print_cube_sec_data(printStr.sec_data);
+ print_cube_sec_key(printStr.sec_key);
+ printf("===================================================\n");
+}
+
+bool cube_crypt_spi_cmd_set(cube_sec_context *cube_ctx, uint8_t cmd, // test func
+ uint8_t input_data[16], uint16_t keycrc)
+{
+ bool ret = false;
+
+ cube_ctx->cmd = cmd;
+ for(int iCnt = 0 ; iCnt < 16 ; ++iCnt)
+ cube_ctx->sec_data.input_data[iCnt] = input_data[iCnt];
+ cube_ctx->sec_key.key_crc = keycrc;
+
+ print_cube_sec_context(*cube_ctx);
+
+ return ret;
+}
+
+cube_sec_context tempContext;
+
+#endif
/** @brief main function ###################################################################
@@ -187,122 +471,165 @@
*/
int main()
{
+ uint8_t ret;
+ uint8_t spiMOSIBuf[255];
+ uint8_t spiMISOBuf[255];
char eepAddr = 0;
char eepData = 0;
+ int packetLength = 0;
- int spiRxTempBuf = 0;
+ uint8_t spiRxTempBuf = 0;
+
+
+ bool crcCheck = false;
+ uint16_t size = 0;
+ uint16_t readCrc = 0;
+ uint16_t genCrc = 0;
+ spiDataStr rxData;
+
+ pc_serial.printf("\n\n========== KSS SPI Slave1 [Start] ==========\n");
SPI_InitSlave();
+#if SPI_INTERRUPT
+ SPI_InitInterrupt();
+ while(1);
+#endif /* SPI_INTERRUPT */
- pc_serial.printf("\n\n========== KSS SPI Slave1 [Start] ==========\n");
+ pc_serial.printf("\n\n========== KSS SPI Slave2 [Start] ==========\n");
+ memset(spiMISOBuf, 0, 255);
+ memset(spiMOSIBuf, 0, 255);
+ while(1)
+ {
+ pc_serial.printf("\n\nwaiting CEBF746 cmd...\n");
+
+
+
+
+ spiRxTempBuf = slave_read_byte();
+ printf("menu[%02X]\n", spiRxTempBuf);
+ switch(spiRxTempBuf)
+ {
+ case FUNC_READ_STATUS:
+ slave_write_byte( cebf746_status_reg );
+ printf("[INFO] Response Status reg [%02X]\n", cebf746_status_reg);
+ break;
+
+ case FUNC_WRITE_ENC_DATA:
+
+ uint16_t packetSize = 0;
+ uint8_t tempBuf[CEB_BUF_SIZE] = {0, };
+ uint16_t retCrc = 0;
+
+
+ slave_read_uint16(&packetSize);
+ if(packetSize != CEB_BUF_SIZE)
+ {
+ printf("[ERROR] %s : %d : packet size error, recived packet size[%d]\n", __FILE__, __LINE__, packetSize);
+ continue;
+ }
+ slave_read_multi_byte(tempBuf, CEB_BUF_SIZE);
+ slave_read_uint16(&retCrc);
+
+ cube_crc_16(CEB_BUF_SIZE, tempBuf, &genCrc);
+ crcCheck = cube_crc_compare(retCrc, genCrc);
+ if(true == crcCheck )
+ slave_write_byte(WRITE_SELF_TEST_RET_CODE);
+ else
+ slave_write_byte(0x00);
+
+ _cebf746_print_packet(packetSize, tempBuf, retCrc);
+
+ if(true == crcCheck )
+ {
+ cube_crypt_spi_cmd_set(&tempContext, 0x02,tempBuf, 0);
+ pc_serial.printf("call \"cube_crypt_spi_cmd_set()\"\n");
+ }
+ else
+ {
+ printf("[ERROR] %s : %d : FUNC_WRITE_ENC_DATA CRC Error\n", __FILE__, __LINE__);
+ }
+
+ break;
+
+ case FUNC_READ_ENC_DATA:
+ break;
+
+ case FUNC_WRITE_DEC_DATA:
+ break;
+
+ case FUNC_READ_DEC_DATA:
+ break;
+
+
+ case FUNC_WRITE_SELF_TEST: // 161017_KSS_Test OK
+
+ slave_read_uint16(&rxData.size);
+
+ rxData.buf = (uint8_t*)malloc(rxData.size);
+ slave_read_multi_byte(rxData.buf, rxData.size);
+
+ slave_read_uint16(&rxData.crc16);
+
+
+
+ cube_crc_16(rxData.size, rxData.buf, &genCrc);
+
+ crcCheck = cube_crc_compare(rxData.crc16, genCrc);
+ if(true == crcCheck )
+ slave_write_byte(WRITE_SELF_TEST_RET_CODE);
+ else
+ slave_write_byte(0x00);
+
+ // ----- print rx buf
+ cebf746_print_packet(&rxData);
+
+ pc_serial.printf("crc read[%04X], gen[%04X] check...", rxData.crc16, genCrc);
+ if(true == crcCheck )
+ pc_serial.printf("[OK]\n");
+ else
+ pc_serial.printf("[FAIL]\n");
+
+ // ----- free()
+ free(rxData.buf);
+
+ break;
+
+ case FUNC_READ_SELF_TEST: // 161017_KSS_Test OK
+ //printf("FUNC_READ_SELF_TEST\n");
+ // TODO check status reg
+
+ cube_crc_16(CEB_BUF_SIZE, readSelfTestValidateData, &genCrc);
+
+
+ slave_write_byte((CEB_BUF_SIZE >> 8) & 0xFF);
+ slave_write_byte((CEB_BUF_SIZE ) & 0xFF);
+ slave_write_multi_byte(readSelfTestValidateData, CEB_BUF_SIZE);
+ slave_write_byte((genCrc >> 8) & 0xFF);
+ slave_write_byte((genCrc ) & 0xFF);
+
+
+
+ printf("--send end\n");
+
+ wait_ms(100);
+
+ break;
+
+
- while(1);
- pc_serial.printf("\n\n========== KSS SPI Slave2 [Start] ==========\n");
-
- while(1)
- {
- if(spi_slave.receive()) // wait SPI data input...
- {
- spiRxTempBuf = spi_slave.read();
- //spi_slave.reply( statusReg++ );
- //continue;
-
- switch(spiRxTempBuf)
- {
- case EEPROM_WREN:
- //spi_dummy_reply();
- pc_serial.printf("[INFO] SPI_MOSI(RX) : WREN\n");
- statusReg = statusReg | (1<<1) ;
- pc_serial.printf("[INFO] WREN sucess [0x%02X]\n", statusReg);
- break;
-
- case EEPROM_WRDI:
- //spi_dummy_reply();
- pc_serial.printf("[INFO] SPI_MOSI(RX) : WRDI\n");
- statusReg = statusReg & (~(1 << 1)) ;
- pc_serial.printf("[INFO] WRDI sucess [0x%02X]\n", statusReg);
- break;
-
- case EEPROM_RDSR:
- spi_slave.reply( statusReg );
- pc_serial.printf("[INFO] SPI_MOSI(RX) : RDSR\n");
- pc_serial.printf("[INFO] SPI_MISO(TX) : RDSR[0x%02X] \n", statusReg);
- break;
-
-
- case EEPROM_WRITE:
- // EEPROM Address read..
- while(!spi_slave.receive());
- eepAddr = spi_slave.read();
-
- // EEPROM Data read..
- while(!spi_slave.receive());
- eepData = spi_slave.read();
-
- pc_serial.printf("\n[DEBUG] Addr[0x%02X] Data[0x%02X] \n", eepAddr, eepData);
+ }
- if(statusReg & 0x02)
- {
- statusReg |= 0x01;
- eepBuf[eepAddr] = eepData;
- printBuf(eepBuf, EEPROM_SIZE);
- statusReg &= (~0x01);
-
- }
- else
- {
- pc_serial.printf("\nwrite command is disabled\n");
- }
- break;
-
-
- case EEPROM_READ:
- // EEPROM Address read..
- while(!spi_slave.receive());
- eepAddr = spi_slave.read();
-
- spi_slave.reply( eepBuf[eepAddr] );
-
- pc_serial.printf("\n[DEBUG] Addr[0x%02X]\n", eepAddr);
-
-
-
+
- break;
-
-
- case EEPROM_MULTIREAD:
- // EEPROM_MULTIREAD..
- while(!spi_slave.receive());
- eepAddr = spi_slave.read();
-
- //printf("[DEBUG] [M to S] eepAddr=0x%02x\n",eepAddr);
- for(int i=0;i<5;i++)
- {
- spi_slave.reply( eepBuf[eepAddr++] );
-
- //++eepAddr;
- //printf("[0x%02x] ",spiMulti);
- }
-
- printf("[DEBUG] [M to S] eepAddr=0x%02x\n",eepAddr++);
- break;
-
-
-
- }
-
- //pc_serial.printf("------------------------ end SPI Communication\n");
-
- }
+
}