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 "performance_test.h"
  31 #include "cli.h"
  32 #include "bcal_camellia128.h"
  33 #include "bcal-performance.h"
  34 #include "bcal-nessie.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* const algolist[] PROGMEM = {
  43         (bcdesc_t*)&camellia128_desc,
  44         NULL
  45 };
  46
  47 /*****************************************************************************
  48  *  additional validation-functions                                                                                      *
  49  *****************************************************************************/
  50
  51 void testrun_nessie_camellia(void){
  52         bcal_nessie_multiple(algolist);
  53 }
  54
  55 /*
  56  * P No.001 : 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  57  */
  58
  59 const uint8_t test_keys[] PROGMEM = {
  60         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  61         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  62         0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
  63         0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
  64         0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
  65         0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
  66         0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
  67         0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
  68         0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01,
  69         0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01, 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE
  70 };
  71
  72 void hexdump128(void* data){
  73         uint8_t i;
  74         for(i=0; i<16; ++i){
  75                 cli_hexdump(data, 1);
  76                 cli_putc(' ');
  77                 data = (uint8_t*)data +1;
  78         }
  79 }
  80
  81 void testrun_camellia128(void){
  82         uint8_t data[16];
  83         uint8_t data2[16];
  84         uint8_t key[16];
  85         char str[4];
  86         uint8_t i,j;
  87         str[3]= '\0';
  88         for(j=0; j<10; ++j){
  89                 str[0] = ('0'+(j+1)/100);
  90                 str[1] = ('0'+((j+1)/10)%10);
  91                 str[2] = ('0'+(j+1)%10);
  92                 memcpy_P(key, test_keys+j*16, 16);
  93                 cli_putstr_P(PSTR("\r\nK No."));
  94                 cli_putstr(str);
  95                 cli_putstr_P(PSTR(" : "));
  96                 hexdump128(key);
  97                 camellia128_ctx_t ctx;
  98                 camellia128_init(key, &ctx);
  99                 for(i=0; i<128; ++i){
 100                         memset(data, 0x00, 16);
 101                         data[i/8] = 0x80>>i%8;
 102                         memcpy(data2, data, 16);
 103                         str[0] = ('0'+(i+1)/100);
 104                         str[1] = ('0'+((i+1)/10)%10);
 105                         str[2] = ('0'+(i+1)%10);
 106                         cli_putstr_P(PSTR("\r\nP No."));
 107                         cli_putstr(str);
 108                         cli_putstr_P(PSTR(" : "));
 109                         hexdump128(data);
 110                         camellia128_enc(data, &ctx);
 111                         cli_putstr_P(PSTR("\r\nC No."));
 112                         cli_putstr(str);
 113                         cli_putstr_P(PSTR(" : "));
 114                         hexdump128(data);
 115                         camellia128_dec(data, &ctx);
 116                         if(memcmp(data, data2, 16)){
 117                                 cli_putstr_P(PSTR("\r\n DECRYPTION ERROR !!!"));
 118                         }
 119                 }
 120         }
 121 }
 122
 123 void test_performance_camellia(void){
 124         bcal_performance_multiple(algolist);
 125 }
 126
 127
 128 /*****************************************************************************
 129  *  self tests                                                                                                                           *
 130  *****************************************************************************/
 131 /*
 132 128-bit key
 133 key         01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
 134 plaintext   01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
 135 ciphertext  67 67 31 38 54 96 69 73 08 57 06 56 48 ea be 43
 136 */
 137 void testrun_camellia(void){
 138
 139   uint8_t data[16] = { 0x01, 0x23, 0x45, 0x67,
 140                        0x89, 0xab, 0xcd, 0xef,
 141                        0xfe, 0xdc, 0xba, 0x98,
 142                        0x76, 0x54, 0x32, 0x10 };
 143
 144   uint8_t key[16] = { 0x01, 0x23, 0x45, 0x67,
 145                        0x89, 0xab, 0xcd, 0xef,
 146                        0xfe, 0xdc, 0xba, 0x98,
 147                        0x76, 0x54, 0x32, 0x10 };
 148
 149
 150   camellia128_ctx_t ctx;
 151   camellia128_init(key, &ctx);
 152   cli_putstr_P(PSTR("\r\n key:        "));
 153   cli_hexdump(data, 16);
 154   cli_putstr_P(PSTR("\r\n plaintext:  "));
 155   cli_hexdump(data, 16);
 156   camellia128_enc(data, &ctx);
 157   cli_putstr_P(PSTR("\r\n ciphertext: "));
 158   cli_hexdump(data, 16);
 159   camellia128_dec(data, &ctx);
 160   cli_putstr_P(PSTR("\r\n decrypted:  "));
 161   cli_hexdump(data, 16);
 162
 163 }
 164
 165
 166 /*****************************************************************************
 167  * main                                                                      *
 168  *****************************************************************************/
 169
 170 const char nessie_str[]      PROGMEM = "nessie";
 171 const char test_str[]        PROGMEM = "test";
 172 const char test128_str[]     PROGMEM = "test128";
 173 const char performance_str[] PROGMEM = "performance";
 174 const char echo_str[]        PROGMEM = "echo";
 175
 176 const cmdlist_entry_t cmdlist[] PROGMEM = {
 177         { nessie_str,      NULL, testrun_nessie_camellia },
 178         { test_str,        NULL, testrun_camellia},
 179         { test128_str,     NULL, testrun_camellia128},
 180         { performance_str, NULL, test_performance_camellia},
 181         { echo_str,    (void*)1, (void_fpt)echo_ctrl},
 182         { NULL,            NULL, NULL}
 183 };
 184
 185 int main (void){
 186         DEBUG_INIT();
 187
 188         cli_rx = (cli_rx_fpt)uart0_getc;
 189         cli_tx = (cli_tx_fpt)uart0_putc;
 190         for(;;){
 191                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 192                 cli_putstr(algo_name);
 193                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 194                 cmd_interface(cmdlist);
 195         }
 196 }
 197