/**
 * Compile with: g++ -g --std=gnu++0x sampleProg.cpp -lssl -lcrypto
 */

#include <unistd.h>
#include <iostream>
#include <openssl/md4.h>
#include <openssl/des.h>
#include <string>
#include <cstring>
#include <mutex>
#include <vector>
#include <pthread.h>
#include <cmath>

#define atoll DONT_USE_THIS_FUNCTION
#define MESSAGE_SIZE 8
#define HEX  16

using namespace std;

typedef unsigned int u64 __attribute__((mode(DI)));

u64 cHash;
u64 endHash;

//a POW function better suited for large integers
u64 long_pow(u64 base, u64 power){
  long long toReturn = 1;

  if(power > 0)
    while(power--) toReturn *= base;
  else if(power < 0)
    while(power++) toReturn /= base;

  return toReturn;
}

//a local reimplementation of atoll
u64 local_atoll(const char* input, unsigned int base){

  if(base < 1 || base > 16 || input == NULL){
    errno = EINVAL;
    return 0;
  }

  long long toReturn = 0;
  bool neg = false;

  for(int power = 0; power < strlen(input); power++){
    long long digit;
    switch(input[power]){
      case '-' : neg = !neg; break;
      case '0' : digit = 0; break;
      case '1' : digit = 1; break;
      case '2' : digit = 2; break;
      case '3' : digit = 3; break;
      case '4' : digit = 4; break;
      case '5' : digit = 5; break;
      case '6' : digit = 6; break;
      case '7' : digit = 7; break;
      case '8' : digit = 8; break;
      case '9' : digit = 9; break;
      case 'a' :
      case 'A' : digit = 10; break;
      case 'b' :
      case 'B' : digit = 11; break;
      case 'c' :
      case 'C' : digit = 12; break;
      case 'd' :
      case 'D' : digit = 13; break;
      case 'e' :
      case 'E' : digit = 14; break;
      case 'f' :
      case 'F' : digit = 15; break;
      default  : exit(-3);
    }
    toReturn += digit * long_pow(base, strlen(input)-(power+1));
  }
  if(neg) toReturn *= -1;

  return toReturn;
}

//compare a known encrypted message with a potential encrypted message
//given a key and a unencrypted message
//NOTE: Possibly wrong
bool singleDESTest(char *_key, const char* in,
                   const char* outTest){

  int cryptStatus = 0;
  unsigned char* result = NULL;
  bool toReturn = false;
  DES_key_schedule schedule;
  DES_cblock key;
  u64 message, knownCipher;

  message = local_atoll(in, HEX);
  knownCipher = local_atoll(outTest, HEX);


  result = (unsigned char*) malloc(MESSAGE_SIZE);
  memcpy(key, _key, 8);

  DES_set_odd_parity((DES_cblock*)&key);
  DES_set_key_checked((DES_cblock*)&key, &schedule);

  DES_cfb64_encrypt( (unsigned char*)message, result, MESSAGE_SIZE,
      &schedule, (DES_cblock*)&key, &cryptStatus, DES_ENCRYPT);

  toReturn = !memcmp(result, outTest, 8);
  free(result);

  return toReturn;
}

/**
 * INPUT: [start hash] [end hash] [plain text] [cipher text]
 *
 * OUTPUT: ["Found one!" | NULL]
 *
 * NOTE: ALL io is done in hex, plaintext and ciphertext MUST be 16
 *       charcters long
 */
int main(int argc, char** argv){

  u64 testHash = local_atoll(argv[0], HEX);
  char testKey[8];

  while(testHash <= local_atoll(argv[1], HEX)){

    memcpy(&testKey, &testHash, 8);

    if(singleDESTest(testKey, argv[3], argv[4]))
      cout << "Found one!" << endl;
    testHash++;
  }

  return 0;
}