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