[re:Runion] Брутфорсоустойчивое шифрование

#include <stdio.h>
#include <string.h>
#include <stdint.h>    /* uint32_t */
#include <arpa/inet.h> /* ntohl()  */

struct utf_ctx {
  int unread;
  FILE *f;
  int argc;
  char **argv;
  char utf_buf [4];
  int misc_print;
  char word [200];
  char word_caps [200];
  char word_low [200];
  int cap_state;
  int caps_leading;
  int caps_trailing;
  int caps_error;
  int word_len;
  int word_ftell;
  int word_ftell_found;
  int multibyte_ftell;
  int utf_state;
  int russian;
  int big;
  int multibyte_len;
  int end_of_stream;
} fctx = {0}, actx = {0};


#define F_WORD_MAX 160000
int arg_text = 1,
arg_readpos = 0, enc = 0,
wordmode = 0, discard = 0;
char keyblock[4];
int f_word [F_WORD_MAX];


int read_options (int argc, char **argv) {
  if (argc < 2) {
    fprintf(stderr, "!!! LEM ERROR arguments missing\n");
    return 0;
  } else if (argv[1][0] != '-') return 1;
  else {
    arg_text++;
    if (strstr(argv[1], "e")) enc = 1;
    if (strstr(argv[1], "w")) wordmode = 1;
    if (strstr(argv[1], "i")) discard = 1;
  }
  return 1;
}


int read_byte(struct utf_ctx *s) {
  int ret;
  if (s->f) {
    ret = fread(s->utf_buf + s->multibyte_len, 1, 1, s->f);
    if (!ret) return 0;
    //fprintf(stderr, "writing to s->utf_buf at %i\n", s->multibyte_len);
  } else if (s->argv && s->argv[arg_text]) {
    char c = s->argv[arg_text][arg_readpos];
    if (!c) {
      arg_text++;
      arg_readpos = 0;
      if (arg_text < s->argc) {
        /* fprintf(stderr, "insert space\n"); */
        c = ' '; /* insert space */
        s->utf_buf[s->multibyte_len] = c;
        s->multibyte_len++;
        return 1;
      }
      else return 0;
    }
    s->utf_buf[s->multibyte_len] = c;
    arg_readpos++;
  } else return 0;
  s->multibyte_len++;
  return 1;
}


void utf_encode_and_write_word (struct utf_ctx *s, int c) {
  int big_c = c;
  int low_c = c;
  if (!s->big) big_c -= 0x20; /* upper */
  else low_c += 0x20; /* lower */
  s->word[s->word_len + 1] = (c & 0b00111111) | 0b10000000;
  s->word[s->word_len] = (c >> 6) | 0b11000000;
  s->word_caps[s->word_len + 1] = (big_c & 0b00111111) | 0b10000000;
  s->word_caps[s->word_len] = (big_c >> 6) | 0b11000000;
  
  s->word_low[s->word_len + 1] = (low_c & 0b00111111) | 0b10000000;
  s->word_low[s->word_len] = (low_c >> 6) | 0b11000000;
  
  s->word_len += 2;
}


int read_utf_multibyte (struct utf_ctx *s) {
  if (s->unread) {
    s->unread = 0;
    return 1;
  }
  s->multibyte_len = 0;
  s->big = 0;
  s->russian = 0;
  if (s->f) s->multibyte_ftell = ftell(s->f);
  int ret = read_byte(s);
  if (!ret) return 0;
  
  int i;
  int j = 0;
  for (i = 7; (i > 3) && (s->utf_buf[0] & (1 << i)); i--) j++;
  /* fprintf(stderr, "multibyte %i bytes\n", j); */
  if (j == 1) {
    s->utf_buf[0] = '^';
    j = 0;
  }
  if (j > 0) j--;
  
  while (j--) {
    /* fprintf(stderr, "reading additional byte\n"); */
    ret = read_byte(s);
    if (!ret) return 0;
  }
  
  /* check this multibyte */
  if (s->multibyte_len == 2) {
    char *b = s->utf_buf;
    int c = (b[0] & 0b00011111) << 6;
    c += (b[1] & 0b00111111);
    /* fprintf(stderr, "decoded UTF-8 character 0x%04x\n", c); */
    
    if (c == 0x0401) c = 0x0415; /* E */
    if (c == 0x0451) c = 0x0435; /* e */
    
    if (c >= 0x0410 && c < 0x0450) {
      s->russian = 1;
      if (c < 0x0430) s->big = 1;
      utf_encode_and_write_word(s, c);
    } else {
      s->multibyte_len = 1;
      s->utf_buf[0] = '^';
    }
  }
  
  if (s->multibyte_len > 2) {
    s->multibyte_len = 1;
    s->utf_buf[0] = '^';
  }
  
  return 1;
}



int read_utf_word (struct utf_ctx *s) {
  if (s->end_of_stream) return 0;
  s->cap_state = 0;
  s->caps_leading = 0;
  s->caps_trailing = 0;
  s->caps_error = 0;
  s->word_len = 0;
  s->word_ftell_found = 0;
  while ((s->word_len < sizeof(s->word) - 1)) {
    if (!read_utf_multibyte(s)) {
      s->end_of_stream = 1;
      break;
    }
    if (s->russian) {
      if (s->f && !s->word_ftell_found) {
        s->word_ftell_found = 1;
        s->word_ftell = s->multibyte_ftell;
      }
      if (s->big) {
        if (s->cap_state == 0) s->cap_state = 1;
        if (s->cap_state == 1) s->caps_leading++;
        else s->caps_trailing++;
      } else {
        s->cap_state = 2;
        if (s->caps_trailing) s->caps_error = 1;
      }
      /* sequence is already written into the s->word[] array */
    } else if (!s->cap_state) {
      /* s->multibyte_len must be 1! */
      if (s->misc_print) printf("%c", (int) s->utf_buf[0]);
    } else {
      s->unread = 1; /* push character back */
      break;
    }
  }
  if (s->word_len >= sizeof(s->word)) s->word_len = sizeof(s->word) - 1;
  s->word[s->word_len] = '\0';
  s->word_caps[s->word_len] = '\0';
  s->word_low[s->word_len] = '\0';
  return (s->word_len) ? 1 : 0;
}


int prepare_words (void) {
  fprintf(stderr, ">>> LEM WORDMODE outputing words to stdout,\n"
  ">>> use the command sort|uniq > lem_words.txt\n");
  fctx.f = stdin;
  long int count = 0;
  while (read_utf_word(&fctx)) {
    printf("%s\n", fctx.word_caps);
    /* printf("DEBUG lead=%i trail=%i e=%i\n",
    fctx.caps_leading, fctx.caps_trailing, fctx.caps_error); */
    count++;
  }
  fprintf(stderr, "*** LEM %li words processed\n", count);
  return 0;
}



int read_key_block (void) {
  int ret = fread(keyblock, sizeof(keyblock), 1, stdin);
  if (!ret) {
    fprintf(stderr, "!!! LEM ERROR stdin key error\n\n");
    return 0;
  }
  return 1;
}


int lem_compare (void) {
  if (strncmp(fctx.word_caps, actx.word_caps,
  sizeof(actx.word)) == 0) return 2; /* exact */
  
  int cmpn = actx.caps_leading * 2; /* two bytes per UTF sequence */
  
  if (actx.caps_leading && (strncmp(fctx.word_caps,
  actx.word, cmpn) != 0)) return 0;

  cmpn = actx.caps_trailing * 2;
  if (actx.caps_trailing) {
    int a = actx.word_len - cmpn;
    int f = fctx.word_len - cmpn;
    if (f < 0) return 0;
    if (0 != strncmp(actx.word + a, fctx.word_caps + f,
      cmpn)) return 0;
  }
  
  return 1;
}


void modify_lower (void) {
  int lead = actx.caps_leading * 2;
  int trail = actx.caps_trailing * 2;
  int trail_begin = fctx.word_len - trail;
  if (lead) mem*****y(fctx.word_low, fctx.word_caps, lead);
  if (trail) mem*****y(fctx.word_low + trail_begin,
    fctx.word_caps + trail_begin, trail);
  /* fprintf(stderr, "LOWER_DEBUG lead %i trail_begin %i trail %i\n",
  lead, trail_begin, trail); */
}


int rotate_word (void) {
  fprintf(stderr, "key %02x-%02x-%02x-%02x word %s\n",
  keyblock[0], keyblock[1], keyblock[2], keyblock[3], actx.word);
  
  if (!fctx.f) fctx.f = fopen("lem_words.txt", "r");
  if (!fctx.f) {
    perror("!!! LEM can't open file lem_words.txt");
    fprintf(stderr, "*** LEM NOTE: use the -w key to filter words\n\n");
    return 0;
  }
  
  rewind(fctx.f);
  fctx.end_of_stream = 0;
  memset(f_word, 0, sizeof(f_word));
  
  /* int debug = 1; */
  int exact_num;
  int exact_pos_found = 0;
  int f_count = 0;
  int ret;
  
  while (read_utf_word(&fctx) && (f_count < F_WORD_MAX)) {
    ret = lem_compare();
    if (ret) {
      /* if (debug) fprintf(stderr, "dict %s (%i) %s\n",
        (ret == 2) ? "EXAC" : "    ", fctx.word_ftell, fctx.word); */
      f_word[f_count] = fctx.word_ftell;
      /* if (debug && f_count > 30) {
        debug = 0;
        fprintf(stderr, ".. there is more ..\n");
      } */
      if (ret == 2) {
        if (exact_pos_found) fprintf(stderr,
          "!!! LEM WARNING multiple entries\n");
        exact_num = f_count;
        exact_pos_found = 1;
      }
      f_count++;
    }
  }
  
  if (read_utf_word(&fctx)) fprintf(stderr,
      "!!! LEM WARNING dictionary is large, can't read more,\n"
      "!!! you have to adjust F_WORD_MAX setting on both sides\n");
  
  /* ROTATE THE WORD !! */
  uint32_t *k = (uint32_t *) keyblock;
  uint32_t host_k = ntohl(*k);
  
  unsigned int step = 0;
  
  if (f_count) {
    /* modulus computations */
    unsigned int a = host_k / f_count;
    unsigned int b = f_count * a;
    step = host_k - b;
    
    /* slow checking routine */
    unsigned int step_check = host_k;
    if (1) {
      while (step_check > f_count) step_check -= f_count;
      
      if (step != step_check) {
        fprintf(stderr,
          "!!! LEM ERROR modulus computing is broken!\n"
          "try it without compiler optimizations!\n");
        return 0;
      }
    }
  }
  
  if (exact_pos_found) {
    /* fprintf(stderr, "exact %s num %i f_count %i\n",
    actx.word, exact_num, f_count); */
  
    int new_number = exact_num + ((enc) ? step : -step);
    /* fprintf(stderr, "DEBUGGG exa=%i, step=%u, new=%i\n",
    exact_num, step, new_number); */
    if (new_number < 0) new_number += f_count;
    if (new_number >= f_count) new_number -= f_count;
    
    if ((new_number < 0) || (new_number > f_count)) {
      fprintf(stderr, "!!! LEM ERROR bad new_number\n");
      return 0;
    }
  
    fseek(fctx.f, f_word[new_number], SEEK_SET);
    fctx.end_of_stream = 0;
    read_utf_word(&fctx);
    
    modify_lower();
    /* fctx.word_low was MODifiED */
    printf("%s", (discard) ? fctx.word_caps : fctx.word_low);
    /* fprintf(stderr, "res %s, step %i, new num %i\n",
    fctx.word_low, (enc) ? step : -step, new_number); */
  } else {
    printf("%s", actx.word);
    fprintf(stderr, ">>> unknown %s\n", actx.word);
  }
  
  return 1;
}



int main (int argc, char **argv) {
  fprintf(stderr, "\n*** LEM v0.01\n"
  "*** Format-Preserving Encription Tool for Russian Language\n"
  "*** Use it with care. Read manual. Be vigilant.\n\n");
  int ret = read_options(argc, argv);
  if (!ret) return 3;
  if (wordmode) return prepare_words();

  fprintf(stderr, "*** LEM %sCRYPT mode\n", (enc) ? "EN" : "DE");
  fprintf(stderr, "*** LEM reading keystream from stdin...\n");
  actx.argc = argc;
  actx.argv = argv;
  actx.misc_print = 1;
  while(read_utf_word(&actx)) {
    ret = read_key_block();
    if (!ret) return 1;
    if (!rotate_word()) break;
  }
  
  printf("\n");
  if (fctx.f) fclose(fctx.f);
  return 0;
}

#include <stdio.h>
#include "tiny-AES-c-master/aes.c"

struct AES_ctx ctx;
uint8_t key[32];
uint8_t buf[64];
uint8_t iv[16];
int i, ret;

int main (void) {
  memset(key, 0, sizeof(key));
  fprintf(stderr, "aesstream: reading password from stdin...\n");
  fgets((char *)key, sizeof(key), stdin);
  memset(iv, 0, sizeof(iv));
  AES_init_ctx_iv(&ctx, iv, key);
  while(1) {
    memset(buf, 0, sizeof(buf));
    AES_CTR_xcrypt_buffer(&ctx, buf, sizeof(buf));
    for (i = 0; i < sizeof(buf); i++) {
      ret = fwrite(buf + i, 1, 1, stdout);
      if (!ret) return 0;
    }
  }
  return 0;
}

bash make.sh

cat *.txt | ./lem -w > large_temp_file.txt
sort large_temp_file.txt | uniq > lem_words.txt
echo Готово!

./aesstream | ./lem -e "руКИ вверХ!"

*** LEM v0.01
*** Format-Preserving Encription Tool for Russian Language
*** Use it with care. Read manual. Be vigilant.

*** LEM ENCRYPT mode
*** LEM reading keystream from stdin...
aesstream: reading password from stdin...
xyzzy
key f7-38-fe-cb word руКИ
key f8-fe-f5-ec word вверХ
метеоритчиКИ платежаХ!

./aesstream | ./lem метеоритчиКИ платежаХ!

*** LEM v0.01
*** Format-Preserving Encription Tool for Russian Language
*** Use it with care. Read manual. Be vigilant.

aesstream: reading password from stdin...
*** LEM DECRYPT mode
*** LEM reading keystream from stdin...
xyzzy
key f7-38-fe-cb word метеоритчиКИ
key f8-fe-f5-ec word платежаХ
руКИ вверХ!

rm bruteforced.txt
while read p; do
  echo -n -e "$p: \t" >> bruteforced.txt
  echo "$p" | sha256sum | ./aesstream | ./lem метеоритчиКИ платежаХ! >> bruteforced.txt
done < lem_words.txt