OneRoundIoT/EnhancedOneRound/Simon_speck/C/user_tool.c

   1 //user simon_64_32 12 -e key tests tests.cip
   2
   3 //
   4 // Created by Calvin McCoy on 9/2/17.
   5 //
   6
   7 #include <stdint.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include "string.h"
  11
  12 #include "cipher_constants.h"
  13 #include "simon.h"
  14 #include "speck.h"
  15 #include <sys/time.h>
  16
  17 /* Usage
  18  $ ./user simon_256_128 ECB -e keyfile input output
  19 */
  20
  21 #define SIMON 0
  22 #define SPECK 1
  23 #define ENCRYPT 0
  24 #define DECRYPT 1
  25
  26 #ifndef VERSION
  27 #define VERSION "custom_build"
  28 #endif
  29
  30 const static struct {
  31     const char *str;
  32     uint8_t     index;
  33     uint8_t     cipher;
  34 } valid_cfgs [] = {
  35         {"simon_64_32", 0, SIMON},
  36         {"simon_72_48", 1, SIMON},
  37         {"simon_96_48", 2, SIMON},
  38         {"simon_96_64", 3, SIMON},
  39         {"simon_128_64", 4, SIMON},
  40         {"simon_96_96", 5, SIMON},
  41         {"simon_144_96", 6, SIMON},
  42         {"simon_128_128", 7, SIMON},
  43         {"simon_192_128", 8, SIMON},
  44         {"simon_256_128", 9, SIMON},
  45         {"speck_64_32", 0, SPECK},
  46         {"speck_72_48", 1, SPECK},
  47         {"speck_96_48", 2, SPECK},
  48         {"speck_96_64", 3, SPECK},
  49         {"speck_128_64", 4, SPECK},
  50         {"speck_96_96", 5, SPECK},
  51         {"speck_144_96", 6, SPECK},
  52         {"speck_128_128", 7, SPECK},
  53         {"speck_192_128", 8, SPECK},
  54         {"speck_256_128", 9, SPECK}
  55 };
  56
  57
  58 double TimeStart()
  59 {
  60   struct timeval tstart;
  61   gettimeofday(&tstart,0);
  62   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  63 }
  64
  65 double TimeStop(double t)
  66 {
  67   struct timeval tend;
  68
  69   gettimeofday(&tend,0);
  70   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  71   return (t);
  72 }
  73
  74
  75
  76
  77 void print_usage(void);
  78
  79
  80 int main(int argc, char *argv[]) {
  81
  82     /* Test That The Minumum Number of Arguments are Provided */
  83     if (argc < 6) {
  84         fprintf(stderr, "Missing All Required Inputs!!\n");
  85         print_usage();
  86         return -1;
  87     }
  88
  89     uint8_t cfg_index = 255;
  90     uint8_t cfg_cipher = SIMON;
  91     uint8_t cfg_dir;
  92
  93     for (int j = 0;  j < sizeof (valid_cfgs) / sizeof (valid_cfgs[0]);  ++j) {
  94         if (!strcmp(argv[1], valid_cfgs[j].str)) {
  95             cfg_index = valid_cfgs[j].index;
  96             cfg_cipher = valid_cfgs[j].cipher;
  97             break;
  98         }
  99     }
 100     if (255 == cfg_index) {
 101         fprintf(stderr, "Not a Valid Simon/Speck Cipher Configuration");
 102         return -1;
 103     }
 104
 105     const uint16_t key_size_bits = key_sizes[cfg_index];
 106     const uint8_t block_size_bits = block_sizes[cfg_index];
 107     const uint8_t  block_size = block_size_bits >> 3;
 108
 109
 110     // Set Cipher Direction: -e -> Encrypt, -d -> Decrypt
 111     if (!strncmp(argv[3], "-e", 2)) cfg_dir = ENCRYPT;
 112     else if (!strncmp(argv[3], "-d", 2)) cfg_dir = DECRYPT;
 113     else {
 114         fprintf(stderr, "Can Only Encrypt or Decrypt");
 115         return -1;
 116     }
 117
 118     uint8_t (*initPtr)(SimSpk_Cipher *, enum cipher_config_t, enum mode_t, void *, uint8_t *, uint8_t *);
 119     uint8_t (*operationPtr)(SimSpk_Cipher, const void *, void *);
 120
 121     if (SIMON == cfg_cipher) {
 122         initPtr = &Simon_Init;
 123         if (ENCRYPT == cfg_dir) operationPtr = &Simon_Encrypt;
 124         else operationPtr = &Simon_Decrypt;
 125     }
 126     else {
 127         initPtr = &Speck_Init;
 128         if (ENCRYPT == cfg_dir) operationPtr = &Speck_Encrypt;
 129         else operationPtr = &Speck_Decrypt;
 130     }
 131
 132
 133     // Read In Key Bytes
 134     FILE *key_fd;
 135     key_fd = fopen(argv[4],"rb");
 136     fseek(key_fd, 0L, SEEK_END);
 137     size_t key_file_size = (size_t)ftell(key_fd);
 138     size_t  key_size = key_size_bits >> 3;
 139     printf("Key File Size (Bits): %zu\n", key_file_size*8);
 140     if (key_size > key_file_size) {
 141         fprintf(stderr, "Insufficient Key Bytes! Found:%zu  Need %zu\n", key_file_size, key_size);
 142         return -1;
 143     }
 144     rewind(key_fd);
 145     uint8_t *key_buffer = malloc((size_t)key_size);
 146     fread(key_buffer, 1, key_size, key_fd);
 147     fclose(key_fd);
 148
 149
 150     // Read in Input Data to Allocated Array
 151     FILE *in_fd;
 152     in_fd = fopen(argv[5],"rb");
 153     fseek(in_fd, 0L, SEEK_END);
 154     size_t input_size = (size_t)ftell(in_fd);
 155     printf("File Size: %zX\n", input_size);
 156     rewind(in_fd);
 157     uint8_t *working_buffer = malloc((size_t)input_size);
 158     fread(working_buffer, 1, input_size, in_fd);
 159     fclose(in_fd);
 160
 161     SimSpk_Cipher my_cipher;
 162     int result = (*initPtr)(&my_cipher, (enum cipher_config_t)cfg_index, ECB, key_buffer, NULL, NULL);
 163     if (result) {
 164         fprintf(stderr, "Failed to Init Cipher\n");
 165         return result;
 166     }
 167     printf("Key Size: %d\n", my_cipher.key_size);
 168     printf("Block Size: %d\n", my_cipher.block_size);
 169
 170
 171     double t=TimeStart();
 172
 173     uint8_t *backup_buffer = working_buffer;
 174     for(int block=0; block < input_size / block_size; block++){
 175         (*operationPtr)(my_cipher, working_buffer, working_buffer);
 176         working_buffer += block_size;
 177     }
 178
 179
 180     double time=TimeStop(t);
 181     printf("ratio %e\n",(double)input_size/time);
 182
 183     FILE *out_fd;
 184     out_fd = fopen(argv[6],"wb");
 185     fwrite(backup_buffer, 1, input_size, out_fd);
 186     fclose(out_fd);
 187
 188     /* Free ALl Buffers */
 189     free(key_buffer);
 190     free(backup_buffer);
 191     printf("All done!\n");
 192     return  0;
 193 }
 194
 195
 196 void print_usage(void){
 197     printf("Simon/Speck User Tool\n");
 198     printf("Version: %s\n", VERSION);
 199     printf("usage: user <CIPHER_CONFIGURATION> <BLOCK_MODE> <CIPHER_DIRECTION> <KEYFILE> <INPUT_FILE> <OUTPUT>\n");
 200 }