main-des-test.c

   1 /**
   2  * \file        main-des-test.c
   3  * \author      Daniel Otte
   4  * \date        2007-06-17
   5  * \brief       test suit for DES
   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         des_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         des_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         uint8_t data[]= { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };
  59         testencrypt(data,key);
  60         testdecrypt(data,key);
  61 }
  62
  63 /******************************************************************************/
  64
  65 void nessie_testenc(uint8_t* data, uint8_t* key){
  66         uint16_t i;
  67         uart_putstr("\r\n\t                key = \t"); uart_hexdump(key, 8);
  68         uart_putstr("\r\n\t              plain = \t"); uart_hexdump(data, 8);
  69         des_encrypt(data,data,key);
  70         uart_putstr("\r\n\t             cipher = \t"); uart_hexdump(data, 8);
  71         des_decrypt(data,data,key);
  72         uart_putstr("\r\n\t          decrypted = \t"); uart_hexdump(data, 8);
  73
  74         for(i=0;i<100; ++i)
  75                 des_encrypt(data,data,key);
  76         uart_putstr("\r\n\tIterated  100 times = \t"); uart_hexdump(data, 8);
  77         for(;i<1000; ++i)
  78                 des_encrypt(data,data,key);
  79         uart_putstr("\r\n\tIterated 1000 times = \t"); uart_hexdump(data, 8);
  80
  81 }
  82
  83 /******************************************************************************/
  84 /*
  85 Set 8, vector#  0:
  86                            key=0001020304050607
  87                         cipher=0011223344556677
  88                          plain=41AD068548809D02
  89                      encrypted=0011223344556677
  90 */
  91 void nessie_testdec(uint8_t* data, uint8_t* key){
  92         uint16_t i;
  93         uart_putstr("\r\n\t                key = \t"); uart_hexdump(key, 8);
  94         uart_putstr("\r\n\t             cipher = \t"); uart_hexdump(data, 8);
  95         des_decrypt(data,data,key);
  96         uart_putstr("\r\n\t             plain = \t"); uart_hexdump(data, 8);
  97         des_encrypt(data,data,key);
  98         uart_putstr("\r\n\t          encrypted = \t"); uart_hexdump(data, 8);
  99 }
 100
 101 /******************************************************************************/
 102
 103 void nessie_testrun(void){
 104         /*
 105                 Set 1, vector#  0:
 106                            key=8000000000000000
 107                          plain=0000000000000000
 108                         cipher=95A8D72813DAA94D
 109                      decrypted=0000000000000000
 110             Iterated 100 times=F749E1F8DEFAF605
 111            Iterated 1000 times=F396DD0B33D04244
 112          */
 113         uint8_t key[8];
 114         uint8_t data[8];
 115         uint16_t set=1, vector;
 116         /* set 1 */
 117         for(vector=0;vector<64;++vector){
 118                 memset(key, 0, 8);
 119                 memset(data, 0, 8);
 120                 key[vector/8] = 1<<(7-vector%8);
 121                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 122                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 123                 nessie_testenc(data, key);
 124         }
 125         /* set 2 */
 126         set = 2;
 127         for(vector=0;vector<64;++vector){
 128                 memset(key, 0, 8);
 129                 memset(data, 0, 8);
 130                 data[vector/8] = 1<<(7-vector%8);
 131                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 132                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 133                 nessie_testenc(data, key);
 134         }
 135         /* set 3 */
 136         set = 3;
 137         for(vector=0;vector<256;++vector){
 138                 memset(key, vector, 8);
 139                 memset(data, vector, 8);
 140                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 141                 uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 142                 nessie_testenc(data, key);
 143         }
 144         /* set 4 */
 145         set = 4;
 146         {       uint8_t lk[2][8] = {    /* local keys */
 147                         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 },
 148                         { 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00 } };
 149         uint8_t ld[2][8] = {  /* local data */
 150             { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
 151             { 0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84 } };
 152
 153                 for(vector=0;vector<2;++vector){
 154                         uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 155                         uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 156                         nessie_testenc(ld[vector], lk[vector]);
 157                 }
 158         }
 159         /* set 5 */
 160         set = 5;
 161         for(vector=0;vector<64;++vector){
 162                 memset(key, 0, 8);
 163                 memset(data, 0, 8);
 164                 key[vector/8] = 1<<(7-vector%8);
 165                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 166                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 167                 nessie_testdec(data, key);
 168         }
 169         /* set 6 */
 170         set = 6;
 171         for(vector=0;vector<64;++vector){
 172                 memset(key, 0, 8);
 173                 memset(data, 0, 8);
 174                 data[vector/8] = 1<<(7-vector%8);
 175                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 176                 uart_putstr(", vector# "); uart_hexdump(&vector, 1);
 177                 nessie_testdec(data, key);
 178         }
 179         /* set 7 */
 180         set = 7;
 181         for(vector=0;vector<256;++vector){
 182                 memset(key, vector, 8);
 183                 memset(data, vector, 8);
 184                 uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 185                 uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 186                 nessie_testdec(data, key);
 187         }
 188         /* set 8 */
 189         set = 8;
 190         {       uint8_t lk[2][8] = {    /* local keys */
 191                         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 },
 192                         { 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00 } };
 193         uint8_t ld[2][8] = {  /* local data */
 194             { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 },
 195             { 0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84 } };
 196
 197                 for(vector=0;vector<2;++vector){
 198                         uart_putstr("\r\n Set "); uart_hexdump(&set, 1);
 199                         uart_putstr(", vector# "); uart_hexdump(&vector, 2);
 200                         nessie_testdec(ld[vector], lk[vector]);
 201                 }
 202         }
 203
 204 }
 205
 206 /*****************************************************************************
 207  *  main                                                                                                                                         *
 208  *****************************************************************************/
 209
 210 int main (void){
 211         char str[20];
 212
 213         DEBUG_INIT();
 214         uart_putstr("\r\n");
 215
 216         uart_putstr("\r\n\r\nCrypto-VS (DES; ");
 217         uart_putstr(__DATE__);uart_putstr(", ");uart_putstr(__TIME__);
 218         uart_putstr(")\r\nloaded and running\r\n");
 219
 220 restart:
 221         while(1){
 222                 if (!getnextwordn(str,20))  {DEBUG_S("DBG: W1\r\n"); goto error;}
 223                 if (!strcmp(str, "test"))       { testrun_des(); }
 224                 else if (!strcmp(str, "nessie")) { nessie_testrun();}
 225                 else {DEBUG_S("DBG: 1b\r\n"); goto error;}
 226
 227                 goto restart;
 228                 continue;
 229         error:
 230                 uart_putstr("ERROR\r\n");
 231         }
 232
 233
 234 }
 235