test_src/main-camellia-test.c

   1 /* main-camellia-test.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2008  Daniel Otte (daniel.otte@rub.de)
   5
   6     This program is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 /*
  20  * camellia test-suit
  21  *
  22  */
  23
  24 #include "config.h"
  25
  26 #include "uart_i.h"
  27 #include "debug.h"
  28
  29 #include "camellia.h"
  30 #include "nessie_bc_test.h"
  31 #include "performance_test.h"
  32 #include "cli.h"
  33 #include "bcal/bcal_camellia128.h"
  34 #include "bcal/bcal-performance.h"
  35 #include <stdint.h>
  36 #include <string.h>
  37 #include <stdlib.h>
  38 #include <avr/pgmspace.h>
  39
  40 char* algo_name = "Camellia";
  41
  42 const bcdesc_t* algolist[] PROGMEM = {
  43         (bcdesc_t*)&camellia128_desc,
  44         NULL
  45 };
  46
  47 /*****************************************************************************
  48  *  additional validation-functions                                                                                      *
  49  *****************************************************************************/
  50 void camellia128_init_dummy(void* key, uint16_t keysize_b, void* ctx){
  51         camellia128_init(key, ctx);
  52 }
  53
  54 void testrun_nessie_camellia(void){
  55         nessie_bc_ctx.blocksize_B =  16;
  56         nessie_bc_ctx.keysize_b   = 128;
  57         nessie_bc_ctx.name        = algo_name;
  58         nessie_bc_ctx.ctx_size_B  = sizeof(camellia128_ctx_t);
  59         nessie_bc_ctx.cipher_enc  = (nessie_bc_enc_fpt)camellia128_enc;
  60         nessie_bc_ctx.cipher_dec  = (nessie_bc_dec_fpt)camellia128_dec;
  61         nessie_bc_ctx.cipher_genctx  = (nessie_bc_gen_fpt)camellia128_init_dummy;
  62
  63         nessie_bc_run();
  64 }
  65
  66 /*
  67  * P No.001 : 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  68  */
  69
  70 uint8_t test_keys[] PROGMEM = {
  71         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  72         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  73         0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
  74         0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
  75         0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
  76         0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
  77         0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
  78         0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
  79         0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01,
  80         0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01, 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE
  81 };
  82
  83 void hexdump128(void* data){
  84         uint8_t i;
  85         for(i=0; i<16; ++i){
  86                 cli_hexdump(data, 1);
  87                 cli_putc(' ');
  88                 data = (uint8_t*)data +1;
  89         }
  90 }
  91
  92 void testrun_camellia128(void){
  93         uint8_t data[16];
  94         uint8_t data2[16];
  95         uint8_t key[16];
  96         char str[4];
  97         uint8_t i,j;
  98         str[3]= '\0';
  99         for(j=0; j<10; ++j){
 100                 str[0] = ('0'+(j+1)/100);
 101                 str[1] = ('0'+((j+1)/10)%10);
 102                 str[2] = ('0'+(j+1)%10);
 103                 memcpy_P(key, test_keys+j*16, 16);
 104                 cli_putstr_P(PSTR("\r\nK No."));
 105                 cli_putstr(str);
 106                 cli_putstr_P(PSTR(" : "));
 107                 hexdump128(key);
 108                 camellia128_ctx_t ctx;
 109                 camellia128_init(key, &ctx);
 110                 for(i=0; i<128; ++i){
 111                         memset(data, 0x00, 16);
 112                         data[i/8] = 0x80>>i%8;
 113                         memcpy(data2, data, 16);
 114                         str[0] = ('0'+(i+1)/100);
 115                         str[1] = ('0'+((i+1)/10)%10);
 116                         str[2] = ('0'+(i+1)%10);
 117                         cli_putstr_P(PSTR("\r\nP No."));
 118                         cli_putstr(str);
 119                         cli_putstr_P(PSTR(" : "));
 120                         hexdump128(data);
 121                         camellia128_enc(data, &ctx);
 122                         cli_putstr_P(PSTR("\r\nC No."));
 123                         cli_putstr(str);
 124                         cli_putstr_P(PSTR(" : "));
 125                         hexdump128(data);
 126                         camellia128_dec(data, &ctx);
 127                         if(memcmp(data, data2, 16)){
 128                                 cli_putstr_P(PSTR("\r\n DECRYPTION ERROR !!!"));
 129                         }
 130                 }
 131         }
 132 }
 133
 134 void test_performance_camellia(void){
 135         bcal_performance_multiple(algolist);
 136 }
 137
 138
 139 /*****************************************************************************
 140  *  self tests                                                                                                                           *
 141  *****************************************************************************/
 142 /*
 143 128-bit key
 144 key         01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
 145 plaintext   01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
 146 ciphertext  67 67 31 38 54 96 69 73 08 57 06 56 48 ea be 43
 147 */
 148 void testrun_camellia(void){
 149
 150   uint8_t data[16] = { 0x01, 0x23, 0x45, 0x67,
 151                        0x89, 0xab, 0xcd, 0xef,
 152                        0xfe, 0xdc, 0xba, 0x98,
 153                        0x76, 0x54, 0x32, 0x10 };
 154
 155   uint8_t key[16] = { 0x01, 0x23, 0x45, 0x67,
 156                        0x89, 0xab, 0xcd, 0xef,
 157                        0xfe, 0xdc, 0xba, 0x98,
 158                        0x76, 0x54, 0x32, 0x10 };
 159
 160
 161   camellia128_ctx_t ctx;
 162   camellia128_init(key, &ctx);
 163   cli_putstr_P(PSTR("\r\n key:        "));
 164   cli_hexdump(data, 16);
 165   cli_putstr_P(PSTR("\r\n plaintext:  "));
 166   cli_hexdump(data, 16);
 167   camellia128_enc(data, &ctx);
 168   cli_putstr_P(PSTR("\r\n ciphertext: "));
 169   cli_hexdump(data, 16);
 170   camellia128_dec(data, &ctx);
 171   cli_putstr_P(PSTR("\r\n decrypted:  "));
 172   cli_hexdump(data, 16);
 173
 174 }
 175
 176
 177 /*****************************************************************************
 178  * main                                                                      *
 179  *****************************************************************************/
 180
 181 const char nessie_str[]      PROGMEM = "nessie";
 182 const char test_str[]        PROGMEM = "test";
 183 const char test128_str[]     PROGMEM = "test128";
 184 const char performance_str[] PROGMEM = "performance";
 185 const char echo_str[]        PROGMEM = "echo";
 186
 187 cmdlist_entry_t cmdlist[] PROGMEM = {
 188         { nessie_str,      NULL, testrun_nessie_camellia },
 189         { test_str,        NULL, testrun_camellia},
 190         { test128_str,     NULL, testrun_camellia128},
 191         { performance_str, NULL, test_performance_camellia},
 192         { echo_str,    (void*)1, (void_fpt)echo_ctrl},
 193         { NULL,            NULL, NULL}
 194 };
 195
 196 int main (void){
 197         DEBUG_INIT();
 198
 199         cli_rx = (cli_rx_fpt)uart0_getc;
 200         cli_tx = (cli_tx_fpt)uart0_putc;
 201         for(;;){
 202                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 203                 cli_putstr(algo_name);
 204                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 205                 cmd_interface(cmdlist);
 206         }
 207 }
 208