void testrun_performance_trivium(void){
uint64_t t;
char str[16];
uint8_t key[10], iv[10];
trivium_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(key, 0, 10);
memset(iv, 0, 10);
startTimer(1);
trivium_init(key, 80, iv, 80, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
trivium_enc(&ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tencrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
void testrun_performance_des(void){
uint64_t t;
char str[16];
uint8_t key[8], data[8];
calibrateTimer();
print_overhead();
memset(key, 0, 8);
memset(data, 0, 8);
startTimer(1);
des_enc(data, data, key);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tencrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
des_dec(data, data, key);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
int8_t lm35_read(struct packet_t *packet) {
uint16_t voltage;
uint16_t temperature;
float tmp;
#ifdef DEBUG
char buf[16];
#endif
voltage = adc_read();
tmp = voltage * 3.3 / 1024;
temperature = tmp * 1000;
#ifdef DEBUG
itoa(voltage,buf,10);
uart_putstr_P(PSTR("Voltage (V): "));
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
itoa(temperature,buf,10);
uart_putstr_P(PSTR("Temperature (°C): "));
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
#endif
return set_data_int16(packet, temperature);
}
void testrun_performance_noekeon(void){
uint64_t t;
char str[16];
uint8_t key[16], data[16];
noekeon_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(key, 0, 16);
memset(data, 0, 16);
startTimer(1);
noekeon_init(key, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
noekeon_enc(data, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tencrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
noekeon_dec(data, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
void hh10d_init(void *cfg) {
// Read calibrate paremeter with TWI
int rc;
char buf[6];
twi_init();
rc = ee24xx_read_bytes(10,4,buf);
if (rc != 4) {
sens = 0;
offset = 0;
return;
}
#ifdef DEBUG
uart_hexdump(buf,4);
uart_putc ('\r');
uart_putc ('\n');
#endif
sens = buf[0] * 256 + buf[1];
offset = buf[2] * 256 + buf[3];
#ifdef DEBUG
itoa(sens,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
itoa(offset,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
#endif
// rising edge
EICRA |= (1 << ISC10) | (1 << ISC11);
// enable INT1
EIMSK |= (1 << INT1);
}
void testrun_performance_arcfour(void){
uint64_t t;
char str[16];
uint8_t key[16];
arcfour_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(key, 0, 16);
startTimer(1);
arcfour_init(key, 16, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
arcfour_gen(&ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tencrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
int main (void){
DEBUG_INIT();
uart_putstr("\r\n");
cli_rx = uart_getc;
cli_tx = uart_putc;
for(;;){
uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
uart_putstr(algo_name);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
void led_set(struct packet_t *packet) {
uart_putstr_P(PSTR("led_set()\r\n"));
// XXX : WTF ??? if (get_data_type(packet)!=0x49) { uart_putstr_P(PSTR("not an integer")); return; }
uart_putc(get_data_type(packet));
if (get_data_int16(packet) == 0) {
uart_putstr_P(PSTR("clr_led()\r\n"));
clr_output(LED1);
} else {
uart_putstr_P(PSTR("set_led()\r\n"));
set_output(LED1);
}
}
int main (void){
DEBUG_INIT();
uart_putstr("\r\n");
cli_rx = uart_getc;
cli_tx = uart_putc;
shavs_algolist=(hfdesc_t**)algolist;
shavs_algo=(hfdesc_t*)&sha256_desc;
for(;;){
uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
uart_putstr(algo_name);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
cmd_interface(cmdlist);
}
}
void send_set(uint8_t dst, uint8_t device, int16_t value) {
uart_putstr_P(PSTR("send_set()\r\n"));
struct packet_t *packet=get_tx_packet();
set_devices(packet,0xff,device);
set_data_int16(packet,value);
send(dst,SET,packet);
}
void send_get(uint8_t dst, uint8_t device) {
uart_putstr_P(PSTR("send_get()\r\n"));
char buf[2];
buf[0]=0xFF;
buf[1]=device;
//send(dst,GET,buf,sizeof(buf));
}
void testrun_stdtest_noekeon(void){
uint8_t key[16], data[16];
uint8_t key3[16];
noekeon_ctx_t ctx;
uart_putstr_P(PSTR("\r\nTest vectors for block cipher Noekeon in Indirect-Key Mode:\r\n"));
memset(key, 0, 16);
memset(data, 0, 16);
testrun_stdtest_runindirect(data, key);
memset(key, 0xFF, 16);
memset(data, 0xFF, 16);
testrun_stdtest_runindirect(data, key);
memset(key, 0, 16);
memset(data, 0, 16);
noekeon_init(key, &ctx);
noekeon_enc(data, &ctx);
memcpy(key3, data, 16);
memset(key, 0xFF, 16);
memset(data, 0xFF, 16);
noekeon_init(key, &ctx);
noekeon_enc(data, &ctx);
testrun_stdtest_runindirect(data, key3);
uart_putstr_P(PSTR("\r\nTest vectors for block cipher Noekeon in Direct-Key Mode:\r\n"));
memset(key, 0, 16);
memset(data, 0, 16);
testrun_stdtest_rundirect(data, key);
memset(key, 0xFF, 16);
memset(data, 0xFF, 16);
testrun_stdtest_rundirect(data, key);
memset(key, 0, 16);
memset(data, 0, 16);
noekeon_enc(data, key);
memcpy(key3, data, 16);
memset(key, 0xFF, 16);
memset(data, 0xFF, 16);
noekeon_enc(data, key);
testrun_stdtest_rundirect(data, key3);
}
void bugone_loop() {
uint8_t *bufcontents;
uint8_t i;
// RFM12 managment
rfm12_tick();
if (rfm12_rx_status() == STATUS_COMPLETE) {
bufcontents=rfm12_rx_buffer();
recv(bufcontents);
}
// Every minutes
if (seconds > 20) {
struct packet_t *packet = get_tx_packet();
application_t *application;
int8_t len;
uart_putstr_P(PSTR("\r\n"));
i=0;
while ( (application = get_app(i)) != NULL) {
i++;
uart_putstr_P(PSTR("#"));
if (application->get == NULL) { continue; }
set_devices(packet,i,0x29);
len=application->get(packet);
if (len > 0) {
//data.remaining_len-=len;
//data.buf+=len;
}
}
send(0xFF,6,packet);
seconds=0;
}
// Asynchronous events
if (wake_me_up > 0) {
struct packet_t *packet = get_tx_packet();
int8_t len;
uart_putstr_P(PSTR("\r\n"));
set_devices(packet,wake_me_up,42);
len=applications[wake_me_up].get(packet);
send(0xFF,VALUE,packet);
wake_me_up = 0;
}
}
void testrun_twister512(void){
twister512_hash_t hash;
char* testv[]={
"",
"a",
"abc",
"message digest",
"abcdefghijklmnopqrstuvwxyz",
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
"12345678901234567890123456789012345678901234567890123456789012345678901234567890"};
uint32_t i;
uart_putstr_P(PSTR("\r\n=== TWISTER-512 test suit (MD5 test values) ==="));
for(i=0; i<7; ++i){
uart_putstr_P(PSTR("\r\n TWISTER-512 (\""));
uart_putstr(testv[i]);
uart_putstr_P(PSTR("\") = \r\n\t"));
twister512(&hash, testv[i], strlen(testv[i])*8);
print_hash(hash);
// return;
}
uart_putstr_P(PSTR("\r\n\r\n=== TWISTER-512 test suit (short test values) ==="));
uint8_t stestv[]= {0x00, 0x00, 0xC0, 0xC0, 0x80, 0x48, 0x50};
uint8_t stestl[]= { 0, 1, 2, 3, 4, 5, 6};
for(i=0; i<7; ++i){
uart_putstr_P(PSTR("\r\n TWISTER-512 (\""));
uart_hexdump(&(stestv[i]), 1);
uart_putstr_P(PSTR("\") = \r\n\t"));
twister512(hash, &(stestv[i]), stestl[i]);
print_hash(hash);
}
#ifdef TWISTER_LONGTEST
uart_putstr_P(PSTR("\r\n\r\n=== TWISTER-512 test suit (long test) ==="));
char* ltest= "abcdefghbcdefghicdefghijdefghijk"
"efghijklfghijklmghijklmnhijklmno";
twister512_ctx_t ctx;
twister512_init(&ctx);
uart_putstr_P(PSTR("\r\n TWISTER-512 ( 16777216 x \""));
uart_putstr(ltest);
uart_putstr_P(PSTR("\") = \r\n\t"));
for(i=0; i<16777216; ++i){
twister512_nextBlock(&ctx, ltest);
}
twister512_ctx2hash(hash, &ctx);
print_hash(hash);
#endif
}
void testrun_performance_twister512(void){
uint64_t t;
char str[16];
uint8_t data[64];
twister_big_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(data, 0, 64);
startTimer(1);
twister_big_init(&ctx, 512);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
twister_big_nextBlock(&ctx, data);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tone-block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
twister_big_lastBlock(&ctx, data, 0);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tlast block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
twister_big_ctx2hash(data, &ctx, 512);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx2hash time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
int8_t hh10d_read(struct packet_t *packet) {
int RH;
char buf[6];
uart_putstr_P(PSTR("hh10d read\r\n"));
RH = (offset - (double)old_cnt) * sens / 4096.0;
#ifdef DEBUG
itoa(old_cnt,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
itoa(RH,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
#endif
if (get_remaining_length(packet) < 2) return -1;
return set_data_int16(packet,RH);
}
void recv_set(struct packet_t *packet) {
uint8_t device_src,device_dst;
application_t* app;
uart_putstr_P(PSTR("recv_set()\r\n"));
while (get_devices(packet,&device_src,&device_dst)) {
app=app_get(device_dst);
if (app == NULL) continue;
if (app->set == NULL) continue;
app->set(packet);
}
}
void testrun_performance_sha256(void){
uint64_t t;
char str[16];
uint8_t data[32];
sha256_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(data, 0, 32);
startTimer(1);
sha256_init(&ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
sha256_nextBlock(&ctx, data);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tone-block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
startTimer(1);
sha256_lastBlock(&ctx, data, 0);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tlast block time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr(str);
uart_putstr_P(PSTR("\r\n"));
}
//hexdump utility
void uart_hexdump(unsigned char *buf, int len)
{
unsigned char x=0;
char sbuf[3];
while(len--){
itoa(*buf++, sbuf, 16);
if (sbuf[1] == 0) uart_putc(' ');
uart_putstr(sbuf);
uart_putc(' ');
if(++x == 16) {
uart_putstr_P(PSTR("\r\n"));
x = 0;
}
}
}
void testrun_stdtest_rundirect(void* data, void* key){
uart_putstr_P(PSTR("\r\n "));
uart_putstr_P(PSTR("k = "));
uart_hexdump(key,16);
uart_putstr_P(PSTR("\r\n "));
uart_putstr_P(PSTR("a = "));
uart_hexdump(data,16);
noekeon_enc(data, key);
uart_putstr_P(PSTR("\r\nafter NESSIEencrypt, b = "));
uart_hexdump(data,16);
noekeon_dec(data, key);
uart_putstr_P(PSTR("\r\nafter NESSIEdecrypt, a?= "));
uart_hexdump(data,16);
uart_putstr_P(PSTR("\r\n"));
}
int main ( void )
{
unsigned char i=0;
char buf[16];
drive(LED1);
drive(LED2);
set_output(LED1);
set_output(LED2);
uart_init();
sei();
uart_putstr_P(PSTR("AVR init complete\r\n"));
while (1) {
_delay_ms(200);
sprintf(buf,"Foo : %d\r\n",i);
uart_putstr(buf);
toggle_output(LED2);
i++;
}
}
/* Initialise board */
void bugone_init(application_t* applications) {
char buf[16];
uint8_t i;
uint8_t nb_devices=0;
application_t *app=applications;
led_init();
uart_init();
rfm12_init();
config_init();
/* Count how many devices are declared */
while (!((app->init == NULL) &&
(app->get == NULL) &&
(app->set == NULL) &&
(app->cfg == NULL))) {
nb_devices++;
app++;
}
set_apps(applications,nb_devices);
uart_putstr_P(PSTR("Firmware version "));
uart_putstr_P(PSTR(FWVERSION_STR));
uart_putstr_P(PSTR("\r\n"));
uart_putstr_P(PSTR("Node address : "));
itoa(config.address,buf,10);
uart_putstr(buf);
uart_putstr_P(PSTR("\r\n"));
for (i=0 ; i < nb_devices; i++) {
uart_putc('*');
if (applications[i].init == NULL) { continue; }
applications[i].init(applications[i].cfg);
}
timer1_init();
sei();
uart_putstr_P(PSTR("AVR init complete\r\n"));
//clr_output(LED1);
//clr_output(LED2);
}
int8_t led_get(struct packet_t *packet) {
uart_putstr_P(PSTR("led_get()\r\n"));
return set_data_int16(packet,get_output(LED1));
}
void print_hash(void* hash){
uart_hexdump(hash, 256/8);
uart_putstr_P(PSTR("\r\n\t"));
uart_hexdump((uint8_t*)hash+256/8, 256/8);
}
