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