#include <stdio.h>
#include <openssl/des.h>
#include <string.h>

typedef unsigned char uchar;
typedef unsigned long long int ullong;

int NUM;

const int ENCRYPTION_OP_CODE = 1;
const int DECRYPTION_OP_CODE = 2;

const int BITS_COUNT = 7;
const uchar KEY_PART_RANGE_BORDER = 128;
const int KEY_SIZE = 8;

ullong convert_to_ullong(uchar *p) {
    int i;
    ullong res = 0;
    uchar* res_ptr = (uchar*)&res;

    for (i = 0; i < KEY_SIZE; i++)
        res_ptr[i] = p[KEY_SIZE - i - 1];

    return res;
}

void fill_encryption_table(uchar *msg, uchar *cmsg) {
    FILE *fencr, *fdecr;

    char fencr_name[8], fdecr_name[8];
    snprintf(fencr_name, 8, "%d.encr", NUM);
    snprintf(fdecr_name, 8, "%d.decr", NUM);

    fencr = fopen(fencr_name, "w");
    fdecr = fopen(fdecr_name, "w");

    uchar c0, c1, c2, c3;
    uchar key[KEY_SIZE];
    uchar encrypted_msg[KEY_SIZE];

    DES_key_schedule key_schedule;

    ullong key_as_num, encrypted_msg_as_num;

    for (c0 = (NUM-1)*4; c0 < NUM*4; c0++)
        for (c1 = 0; c1 < KEY_PART_RANGE_BORDER; c1++)
            for (c2 = 0; c2 < KEY_PART_RANGE_BORDER; c2++)
                for (c3 = 0; c3 < KEY_PART_RANGE_BORDER; c3++) {
                    /* form key */
                    key[0] = key[1] = key[2] = key[3] = 0x01;
                    key[4] = c0 << 1;
                    key[5] = c1 << 1;
                    key[6] = c2 << 1;
                    key[7] = c3 << 1;

                    /* set parity bits */
                    DES_set_odd_parity(&key);

                    /* expand key to schedule */
                    DES_set_key_checked(&key, &key_schedule);
                    DES_key_sched(&key, &key_schedule);

                    /* convert key to num for printing */
                    key_as_num = convert_to_ullong(key);

                    /* ============================== */
                    DES_ecb_encrypt((const_DES_cblock*)msg, (DES_cblock*)encrypted_msg, &key_schedule, DES_ENCRYPT);
                    encrypted_msg_as_num = convert_to_ullong(encrypted_msg);
                    fprintf(fencr, "%llu\t%016LX\t%d\n", encrypted_msg_as_num, key_as_num, ENCRYPTION_OP_CODE);

                    /* ============================== */
                    DES_ecb_encrypt((const_DES_cblock*)cmsg, (DES_cblock*)encrypted_msg, &key_schedule, DES_DECRYPT);
                    encrypted_msg_as_num = convert_to_ullong(encrypted_msg);
                    fprintf(fdecr, "%llu\t%016LX\t%d\n", encrypted_msg_as_num, key_as_num, DECRYPTION_OP_CODE);
                    /* ============================== */

                }

    fclose(fencr);
    fclose(fdecr);

}

int main(int argc, char *argv[]) {
    /* here is the number indicating which block of keys
     * we will inspect */
    sscanf(argv[1], "%d", &NUM);

    int i;

    // NOTE: padding with 0x01 (number of bytes to pad)
    ullong msg_as_num = 0x6665617475526500;
    uchar msg[8];

    /* reverse byte order */
    uchar *p1 = (uchar*)&msg_as_num;
    for (i = 0; i < KEY_SIZE; i++) {
        msg[i] = p1[KEY_SIZE - i - 1];
    }

    ullong cmsg_as_num = 0x77220D247542CA57;
    uchar cmsg[8];

    /* reverse byte order */
    uchar *p2 = (uchar*)&cmsg_as_num;
    for (i = 0; i < KEY_SIZE; i++) {
        cmsg[i] = p2[KEY_SIZE - i - 1];
    }

    /* build tables for attack */
    fill_encryption_table(msg, cmsg);

    return 0;
}