test_src/main-camellia-test.c

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