main-tdes-test.c

   1 /**
   2  * \file        main-tdes-test.c
   3  * \author      Daniel Otte
   4  * \date        2007-06-17
   5  * \brief       test suit for TDES/TDEA
   6  * \par License
   7  * GPL
   8  *
   9  */
  10 #include "config.h"
  11 #include "serial-tools.h"
  12 #include "uart.h"
  13 #include "debug.h"
  14
  15 #include "des.h"
  16
  17 #include <stdint.h>
  18 #include <string.h>
  19
  20
  21 /*****************************************************************************
  22  *  additional validation-functions                                                                                      *
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  *  self tests                                                                                                                           *
  27  *****************************************************************************/
  28
  29 void testencrypt(uint8_t* block, uint8_t* key){
  30         uart_putstr("\r\n==testy-encrypt==\r\n key: ");
  31         uart_hexdump(key,8);
  32         uart_putstr("\r\n plain: ");
  33         uart_hexdump(block,8);
  34         tdes_encrypt(block,block,key);
  35         uart_putstr("\r\n crypt: ");
  36         uart_hexdump(block,8);
  37 }
  38
  39 void testdecrypt(uint8_t* block, uint8_t* key){
  40         uart_putstr("\r\n==testy-decrypt==\r\n key: ");
  41         uart_hexdump(key,8);
  42         uart_putstr("\r\n crypt: ");
  43         uart_hexdump(block,8);
  44         tdes_decrypt(block,block,key);
  45         uart_putstr("\r\n plain: ");
  46         uart_hexdump(block,8);
  47 }
  48
  49 /******************************************************************************/
  50
  51 void testrun_des(void){
  52
  53 /*      uint8_t key[]= { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; */
  54 /*      uint8_t data[]={ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; */
  55
  56
  57         uint8_t key[] = { 0x3b, 0x38, 0x98, 0x37, 0x15, 0x20, 0xf7, 0x5e,
  58                                           0x92, 0x2f, 0xb5, 0x10, 0xc7, 0x1f, 0x43, 0x6e,
  59                                           0x3b, 0x38, 0x98, 0x37, 0x15, 0x20, 0xf7, 0x5e
  60                                         };
  61         uint8_t data[]= { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };
  62         testencrypt(data,key);
  63         testdecrypt(data,key);
  64 }
  65
  66 /******************************************************************************/
  67
  68 void nessie_testenc(uint8_t* data, uint8_t* key){
  69         uint16_t i;
  70         uart_putstr("\r\n\t                key = \t"); uart_hexdump(key, 24);
  71         uart_putstr("\r\n\t              plain = \t"); uart_hexdump(data, 8);
  72         tdes_encrypt(data,data,key);
  73         uart_putstr("\r\n\t             cipher = \t"); uart_hexdump(data, 8);
  74         tdes_decrypt(data,data,key);
  75         uart_putstr("\r\n\t          decrypted = \t"); uart_hexdump(data, 8);
  76
  77         for(i=0;i<100; ++i)
  78                 tdes_encrypt(data,data,key);
  79         uart_putstr("\r\n\tIterated  100 times = \t"); uart_hexdump(data, 8);
  80         for(;i<1000; ++i)
  81                 tdes_encrypt(data,data,key);
  82         uart_putstr("\r\n\tIterated 1000 times = \t"); uart_hexdump(data, 8);
  83
  84 }
  85
  86 /******************************************************************************/
  87 /*
  88 Set 8, vector#  0:
  89                            key=0001020304050607
  90                         cipher=0011223344556677
  91                          plain=41AD068548809D02
  92                      encrypted=0011223344556677
  93 */
  94 void nessie_testdec(uint8_t* data, uint8_t* key){
  95         uart_putstr("\r\n\t                key = \t"); uart_hexdump(key, 24);
  96         uart_putstr("\r\n\t             cipher = \t"); uart_hexdump(data, 8);
  97         tdes_decrypt(data,data,key);
  98         uart_putstr("\r\n\t             plain = \t"); uart_hexdump(data, 8);
  99         tdes_encrypt(data,data,key);
 100         uart_putstr("\r\n\t          encrypted = \t"); uart_hexdump(data, 8);
 101 }
 102
 103 /******************************************************************************/
 104
 105 void nessie_testrun(void){
 106         /*
 107                 Set 1, vector#  0:
 108                            key=8000000000000000
 109                          plain=0000000000000000
 110                         cipher=95A8D72813DAA94D
 111                      decrypted=0000000000000000
 112             Iterated 100 times=F749E1F8DEFAF605
 113            Iterated 1000 times=F396DD0B33D04244
 114          */
 115         uint8_t key[24];
 116         uint8_t data[8];
 117         uint16_t set=1, vector;
 118         /* set 1 */
 119         for(vector=0;vector<192;++vector){
 120                 memset(key, 0, 24);
 121                 memset(data, 0, 8);
 122                 key[vector/8] = 1<<(7-vector%8);
 123                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 124                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 125                 nessie_testenc(data, key);
 126         }
 127         /* set 2 */
 128         set = 2;
 129         for(vector=0;vector<64;++vector){
 130                 memset(key, 0, 24);
 131                 memset(data, 0, 8);
 132                 data[vector/8] = 1<<(7-vector%8);
 133                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 134                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 135                 nessie_testenc(data, key);
 136         }
 137         /* set 3 */
 138         set = 3;
 139         for(vector=0;vector<256;++vector){
 140                 memset(key, vector, 24);
 141                 memset(data, vector, 8);
 142                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 143                 uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 144                 nessie_testenc(data, key);
 145         }
 146         /* set 4 */
 147         set = 4;
 148         {       uint8_t lk[2][24] = {   /* local keys */
 149                         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 150                           0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 151                           0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17  },
 152                         { 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
 153                           0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48,
 154                           0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00  } };
 155         uint8_t ld[2][8] = {  /* local data */
 156             { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
 157             { 0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84 } };
 158
 159                 for(vector=0;vector<2;++vector){
 160                         uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 161                         uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 162                         nessie_testenc(ld[vector], lk[vector]);
 163                 }
 164         }
 165         /* set 5 */
 166         set = 5;
 167         for(vector=0;vector<192;++vector){
 168                 memset(key, 0, 24);
 169                 memset(data, 0, 8);
 170                 key[vector/8] = 1<<(7-vector%8);
 171                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 172                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 173                 nessie_testdec(data, key);
 174         }
 175         /* set 6 */
 176         set = 6;
 177         for(vector=0;vector<64;++vector){
 178                 memset(key, 0, 24);
 179                 memset(data, 0, 8);
 180                 data[vector/8] = 1<<(7-vector%8);
 181                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 182                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 183                 nessie_testdec(data, key);
 184         }
 185         /* set 7 */
 186         set = 7;
 187         for(vector=0;vector<256;++vector){
 188                 memset(key, vector, 24);
 189                 memset(data, vector, 8);
 190                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 191                 uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 192                 nessie_testdec(data, key);
 193         }
 194         /* set 8 */
 195         set = 8;
 196         {       uint8_t lk[2][24] = {
 197                         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 198                           0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 199                           0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17  },
 200                         { 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
 201                           0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48,
 202                           0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00  } };
 203         uint8_t ld[2][8] = {  /* local data */
 204             { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
 205             { 0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84 } };
 206
 207                 for(vector=0;vector<2;++vector){
 208                         uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 209                         uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 210                         nessie_testdec(ld[vector], lk[vector]);
 211                 }
 212         }
 213
 214 }
 215
 216 /*****************************************************************************
 217  *  main                                                                                                                                         *
 218  *****************************************************************************/
 219
 220 int main (void){
 221         char str[20];
 222
 223         DEBUG_INIT();
 224         uart_putstr("\r\n");
 225
 226         uart_putstr("\r\n\r\nCrypto-VS (TDES/TDEA; ");
 227         uart_putstr(__DATE__);uart_putstr(", ");uart_putstr(__TIME__);
 228         uart_putstr(")\r\nloaded and running\r\n");
 229
 230 restart:
 231         while(1){
 232                 if (!getnextwordn(str,20))  {DEBUG_S("DBG: W1\r\n"); goto error;}
 233                 if (!strcmp(str, "test"))       { testrun_des(); }
 234                 else if (!strcmp(str, "nessie")) { nessie_testrun();}
 235                 else {DEBUG_S("DBG: 1b\r\n"); goto error;}
 236
 237                 goto restart;
 238                 continue;
 239         error:
 240                 uart_putstr("ERROR\r\n");
 241         }
 242
 243
 244 }
 245