biweekly can you crack this? thread

Hey prog, I wrote a simple xor cipher that takes the exclusive or of the plain text with the key, but it also takes some state from the previous calculation.


cipher[i] = plain[i] ^ key[i] ^ prev_state[i - 1]

prev_state[i] = (cipher[i] + plain[i]) mod 256

The first value of prev_state is always zero. That is, prev_state[-1] = 0.


The cipher text and cipher implementation is below, cut among many posts to avoid long post detection.

Here is an implementation of the cipher in C:


#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <malloc.h>
#include <stdlib.h>

#define BUFFER_LENGTH 2048

struct linked_buffer {
  struct linked_buffer* next;
  size_t string_length;
  char buffer[BUFFER_LENGTH];
};

void read_file(FILE* input, struct linked_buffer* output) {
  output->next = NULL;
  struct linked_buffer* current = output;
  for(;;) {
    struct linked_buffer* next;
    size_t count = fread(current->buffer, sizeof(char), BUFFER_LENGTH, input);
    current->string_length = count;
    if(count != BUFFER_LENGTH) break;
    next = malloc(sizeof(struct linked_buffer));
    assert(next);
    next->next = NULL;
    current->next = next;
    current = next;
  }
}

void write_file(struct linked_buffer* input, FILE* output) {
  while(input) {
    fwrite(input->buffer, sizeof(char), input->string_length, output);
    input = input->next;
  }
}

void free_contained_buffers(struct linked_buffer* root) {
  struct linked_buffer* current = root->next;
  while(current) {
    struct linked_buffer* next = current->next;
    free(current);
    current = next;
  }
}


enum exit_values {
  ALRIGHTY = 0,
  WRONG_USAGE_BRO,
  COULD_NOT_OPEN_KEY_FILE_BRO,
  COULD_NOT_OPEN_PLAIN_TEXT_FILE_BRO,
  I_DON_KNOW_WHAT_HAPPENED_BRO
};


char* program_name;
int main(int argc, char** argv) {
  program_name = argv[0];
  if(argc != 3) {
    fprintf(stderr, "%s: usage: %s key-file input-file\n",
                    program_name, program_name);
    exit(WRONG_USAGE_BRO);
  }

  char* key_file_name = argv[1];
  FILE* key_file = fopen(key_file_name, "r");
  if(!key_file) {
    fprintf(stderr, "%s: could not open the key for %s, for reading, bro: %s\n",
                    program_name, key_file_name, strerror(errno));
    exit(COULD_NOT_OPEN_KEY_FILE_BRO);
  }

  struct linked_buffer key;
  read_file(key_file, &key);
  fclose(key_file);


  char* plain_text_file_name = argv[2];
  FILE* plain_text_file = fopen(plain_text_file_name, "r");
  if(!plain_text_file) {
    fprintf(stderr, "%s: could not open the plain text file, %s, bro: %s\n",
                    program_name, plain_text_file_name, strerror(errno));
    exit(COULD_NOT_OPEN_PLAIN_TEXT_FILE_BRO);
  }

  struct linked_buffer* current_key_section = &key;
  char previous_character = '\0';
  char input_buffer[BUFFER_LENGTH];
  char output_buffer[BUFFER_LENGTH];

  for(;;) {
    size_t index;
    size_t count = fread(input_buffer, sizeof(char), BUFFER_LENGTH, plain_text_file);
    if(count == 0) break;

    for(index = 0; index < count; ++index) {
      char current_plain_text_character = input_buffer[index];
      char current_key_character = current_key_section->buffer[index];
      char current_encrypted_character = current_plain_text_character ^ current_key_character ^ previous_character;
      output_buffer[index] = current_plain_text_character ^ current_key_character ^ previous_character;
      previous_character = current_plain_text_character + current_encrypted_character; // The previous character must be a result of a commutative
                                                                                       // operation between the plain text and cipher text in order
                                                                                       // for the encryption to be symmetric.
    }

    size_t output_count = fwrite(output_buffer, sizeof(char), count, stdout);
    if(output_count != count) {
      fprintf(stderr, "%s: whoa, I can't write to the stdout man! What the fuck is going on!: %s\n",
                      program_name, strerror(errno));
      exit(I_DON_KNOW_WHAT_HAPPENED_BRO);
    }

    current_key_section = current_key_section->next;
    if(!current_key_section) current_key_section = &key;
  }
 
  fclose(plain_text_file);

  free_contained_buffers(&key);

  return ALRIGHTY;
}

And here is the cipher text! The plain text contains a rather large amount of english in ascii. There are various punctuation marks, and a few underscores and < > signs. The key is a single ascii english word, terminated with a newline. All newlines are unix style. It is cut among 3 posts. Sorry for the inconvenience of copying it out of the browser, but if the plain text was shorter, it might be more difficult to crack.

cipher text, part 1 of 3

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cipher text part 2 of 3

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cipher text part 3 of 3

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Here is a simple hex file to bin file converter, if you don't have one appropriate for the format above:


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>

#define OUTPUT_BUFFER_LENGTH 2048
#define INPUT_BUFFER_LENGTH (OUTPUT_BUFFER_LENGTH*2)

char* program_name;

enum exit_status {
  ALRIGHTY = 0,
  WRONG_USAGE_BROSKI,
  COULD_NOT_OPEN_HEX_FILE_BROSKI,
  THERE_WAS_LIKE_AN_ODD_NUMBER_OF_HEX_CHARACTERS_IN_YOUR_HEX_FILE_BROSKI,
  WHAT_WAS_THAT_ALL_ABOUT_BRO
};



#define THAT_WAS_TOTALLY_NOT_A_HEX_CHARACTER_BRO -1

int ascii_to_word(char symbol) {
  if(symbol >= '0' && symbol <= '9') {
    return symbol - '0';
  } else if(symbol >= 'A' && symbol <= 'F') {
    return symbol - 'A' + 10;
  } else if(symbol >= 'a' && symbol <= 'f') {
    return symbol - 'a' + 10;
  } else {
    return THAT_WAS_TOTALLY_NOT_A_HEX_CHARACTER_BRO;
  }
}

int main(int argc, char** argv) {
  program_name = argv[0];
  if(argc != 2) {
    fprintf(stderr, "%s: usage: %s hex-file\n",
                    program_name, program_name);
    exit(WRONG_USAGE_BROSKI);
  }

  char* hex_file_name = argv[1];
  FILE* hex_file = fopen(hex_file_name, "r");
  if(!hex_file) {
    fprintf(stderr, "%s: could not open the hex file, %s, broski: %s\n",
                    program_name, program_name, hex_file_name);
    exit(COULD_NOT_OPEN_HEX_FILE_BROSKI);
  }


  char input_buffer[INPUT_BUFFER_LENGTH];
  char output_buffer[OUTPUT_BUFFER_LENGTH];

  char output_character;
  int output_character_is_empty = 1;

  for(;;) {
    size_t output_index = 0;
    size_t input_index;
    size_t count = fread(input_buffer, sizeof(char), INPUT_BUFFER_LENGTH, hex_file);
    if(count == 0) break;

    for(input_index = 0; input_index < count; ++input_index) {
      int current_word = ascii_to_word(input_buffer[input_index]);
      if(current_word == THAT_WAS_TOTALLY_NOT_A_HEX_CHARACTER_BRO) continue;
      if(output_character_is_empty) {
        output_character = (unsigned char)current_word << 4;
      } else {
        assert(current_word < 0x10);
        assert(current_word >= 0);
        output_character |= (unsigned char)current_word;
        output_buffer[output_index] = output_character;
        ++output_index;
      }
      output_character_is_empty = !output_character_is_empty;
    }

    size_t output_count = fwrite(output_buffer, sizeof(char), output_index, stdout);
    if(output_count != output_index) {
      fprintf(stderr, "%s: What's going on bro? std isn't taking my shit!: %s\n",
                      program_name, strerror(errno));
      exit(WHAT_WAS_THAT_ALL_ABOUT_BRO);
    }
  }
 
  fclose(hex_file);

  if(!output_character_is_empty) {
    fprintf(stderr, "%s: warning: there was like, an odd number of hex characters in your hex file bro. I didn't include that last word in the output.\n",
                    program_name);
    exit(THERE_WAS_LIKE_AN_ODD_NUMBER_OF_HEX_CHARACTERS_IN_YOUR_HEX_FILE_BROSKI);
  }

  return ALRIGHTY;
}

And for the sake of completeness, here is a binary to hex converter that is compatible with hex to binary converter above:


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>

#define INPUT_BUFFER_LENGTH 2048
#define OUTPUT_BUFFER_LENGTH (INPUT_BUFFER_LENGTH*2)

char* program_name;

enum exit_status {
  ALRIGHTY = 0,
  WRONG_USAGE_BRA,
  COULD_NOT_OPEN_BINARY_FILE_BRA,
  WHATS_UP_WITH_THAT
};


char word_to_hex_digit(int word) {
  assert(word >= 0);
  assert(word < 0x10);
  if(word < 10) {
    return '0' + word;
  } else {
    return 'A' + word - 10;
  }
}

void byte_to_hex(char byte, char* hex_string) {
  assert(hex_string);
  hex_string[0] = word_to_hex_digit((unsigned char)byte >> 4);
  hex_string[1] = word_to_hex_digit((unsigned char)byte & 0x0F);
}

int main(int argc, char** argv) {
  program_name = argv[0];
  if(argc != 2) {
    fprintf(stderr, "%s: usage: %s bin-file\n",
                    program_name, program_name);
    exit(WRONG_USAGE_BRA);
  }

  char* binary_file_name = argv[1];
  FILE* binary_file = fopen(binary_file_name, "r");
  if(!binary_file) {
    fprintf(stderr, "%s: could not open the binary file, %s, broski: %s\n",
                    program_name, program_name, binary_file_name);
    exit(COULD_NOT_OPEN_BINARY_FILE_BRA);
  }


  char input_buffer[INPUT_BUFFER_LENGTH];
  char output_buffer[OUTPUT_BUFFER_LENGTH];

  for(;;) {
    size_t index;
    size_t count = fread(input_buffer, sizeof(char), INPUT_BUFFER_LENGTH, binary_file);
    if(count == 0) break;

    for(index = 0; index < count; ++index) {
      byte_to_hex(input_buffer[index], &(output_buffer[2*index]));
    }

    size_t output_size = 2*count;
    size_t output_written = fwrite(output_buffer, sizeof(char), output_size, stdout);
    if(output_written != output_size) {
      fprintf(stderr, "%s: I don't know why, but stdout isn't interested in having my data bro: %s\n",
                      program_name, strerror(errno));
      exit(WHATS_UP_WITH_THAT);
    }
  }
 
  fclose(binary_file);

  return ALRIGHTY;
}

Good luck proggies!

>>1

aww shucks, I forgot to mention that the key was supposed to repeat.


cipher[i] = plain[i] ^ key[i mod key_length] ^ prev_state[i - 1]

prev_state[i] = (cipher[i] + plain[i]) mod 256

But there is actually a bug in my program where uninitialized data is used for the key. woops. So I guess that makes the key as long as the plain text, and it probably wont be breakable unless you can accurately predict the value of the uninitialized data. My bad. I'd fix the bug and reupload the updated cipher text, but it doesn't really feel worth the effort now. Oh well. Tune in in two weeks for the next biweekly CAN YOU CRACK THIS? thread

"Those who don't know RC4 are doomed to reinvent it poorly."

The key is a single ascii english word, terminated with a newline

while read W ; do
 echo $W > key
 if cipher key plaintxt | grep -q "[\x80-\xFF]" ; then
  continue
 fi
 echo key is `cat key`
 break
done < /usr/share/dict/words

CRACK MY ANUS

>>22 nice dubs bro

>>9

did it work?