/*
 * DES file encryption tool
 *
 * A simple file encryption tool using the DES algorithm.
 * This code is for educational purposes only, I do not
 * reccomend using this for the secure storage of data.
 * This is NOT meant as a secure means for encrypting files
 * for various reasons.
 *
 * Compiling: g++ descrypt.cpp -o descrypt
 *
 * Encryption: ./descrypt -e secret.txt secret.crypt
 * Decryption: ./descrypt -d secret.crypt secret.txt
 *
 * Author: Jonathan So 2003 - [ jonny [ @ ] nop-art.net ]
 */

#include <iostream>
#include <fstream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define int64 long long unsigned int

using namespace std;

int pc1[56] = {
	57,	49,	41,	33,	25,	17,	9,
	1,	58,	50,	42,	34,	26,	18,
	10,	2,	59,	51,	43,	35,	27,
	9,	11,	3,	60,	52,	44,	36,
	63,	55,	47,	39,	31,	23,	15,
	7,	62,	54,	46,	38,	30,	22,
	14,	6,	61,	53,	45,	37,	29,
	21,	13,	5,	28,	20,	12,	4
};

int pc2[48] = {
	14,	17,	11,	24,	1,	5,
	3,	28,	15,	6,	21,	10,
	23,	19,	12,	4,	26,	8,
	16,	7,	27,	20,	13,	2,
	41,	52,	31,	37,	47,	55,
	30,	40,	51,	45,	33,	48,
	44,	49,	39,	56,	34,	53,
	46,	42,	50,	36,	29,	32
};

int ip[64] = {
	58,	50,	42,	34,	26,	18,	10,	2,
	60,	52,	44,	36,	28,	20,	12,	4,
	62,	54,	46,	38,	30,	22,	14,	6,
	64,	56,	48,	40,	32,	24,	16,	8,
	57,	49,	41,	33,	25,	17,	9,	1,
	59,	51,	43,	35,	27,	19,	11,	3,
	61,	53,	45,	37,	29,	21,	13,	5,
	63,	55,	47,	39,	31,	23,	15,	7
};

int e[48] = {
	32,	1,	2,	3,	4,	5,
	4,	5,	6,	7,	8,	9,
	8,	9,	10,	11,	12,	13,
	12,	13,	14,	15,	16,	17,
	16,	17,	18,	19,	20,	21,
	20,	21,	22,	23,	24,	25,
	24,	25,	26,	27,	28,	29,
	28,	29,	30,	31,	32,	1
};

int shifts[16] = {
	1,	1,	2,	2,	2,	2,	2,
	2,	1,	2,	2,	2,	2,	2,
	2,	1
};

int s_box[8][4][16] = {

	/* sbox 1 */
	{
		{ 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
		{ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
		{ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
		{ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 }
	},
	/* sbox 2 */
	{
		{ 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
		{ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
		{ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
		{ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 }
	},
	/* sbox 3 */
	{
		{ 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
		{ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
		{ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
		{ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 }
	},
	/* sbox 4 */
	{
		{ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
		{ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },
		{ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
		{ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 }
	},
	/* sbox 5 */
	{
		{ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
		{ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
		{ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
		{ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 }
	},
	/* sbox 6 */
	{
		{ 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
		{ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
		{ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
		{ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 }
	},
	/* sbox 7 */
	{
		{ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
		{ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
		{ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
		{ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 }
	},
	/* sbox 8 */
	{
		{ 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
		{ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
		{ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
		{ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 }
	}
};	

int p[32] = {
	16,	7,	20,	21,
	29,	12,	28,	17,
	1,	15,	23,	26,
	5,	18,	31,	10,
	2,	8,	24,	14,
	32,	27,	3,	9,
	19,	13,	30,	6,
	22,	11,	4,	25
};

int fp[64] = {
	40,	8,	48,	16,	56,	24,	64,	32,
	39,	7,	47,	15,	55,	23,	63,	31,
	38,	6,	46,	14,	54,	22,	62,	30,
	37,	5,	45,	13,	53,	21,	61,	29,
	36,	4,	44,	12,	52,	20,	60,	28,
	35,	3,	43,	11,	51,	19,	59,	27,
	34,	2,	42,	10,	50,	18,	58,	26,
	33,	1,	41,	9,	49,	17,	57,	25
};

/* Function prototypes */
void generate_subkeys(int64);
void encrypt_message(int64, int);
unsigned int f(unsigned int, int64);

/* Global variables */
int64 subkey[16];
int64 cipher;

int main(int argc, char **argv)
{
    int64 message;
    int64 key;
    ifstream input;
    ofstream output;
	unsigned int i;

    if (argc<4) {
       cout << "Usage: " << argv[0] << " -[e|d] inputfile outputfile" << endl;
       exit(1);
    }

    memset((void *) &key, 0x00, sizeof(key));
    cout << "Key [8 bytes]: " << endl;
    cin.read((char *) &key, 8);

    input.open(argv[2], ios::in | ios::binary);
    output.open(argv[3], ios::out | ios::binary);
    if(!input) cout << "error opening input file" << endl;

    while (!input.eof()) {
       memset((void *) &message, 0x00, sizeof(message));
       input.read((char *) &message, 8);
       if (!input.gcount()) break;

       if(!memcmp(argv[1], "-e", 2)) {
              generate_subkeys(key);
              encrypt_message(message, 0);
              output.write((char *) &cipher, 8);
       }
       else if(!memcmp(argv[1], "-d", 2)) {
              generate_subkeys(key);
              encrypt_message(message, 1);
              output.write((char *) &cipher, 8);
      }
    }
    input.close();
    output.close();

}


void generate_subkeys(int64 key)
{
	int64 permutation[64];
	unsigned int c[16];
	unsigned int d[16];
	unsigned int i;
	unsigned int n;

	/* Clear our variables */
	memset((void *) &permutation, 0x00, sizeof(permutation));

	/* Cycle through the PC1 table, store each bit in an */
	/* array element, then add the elements together     */
	for ( i=0 ; i<56 ; i++ ) permutation[i] = key << (pc1[i]-1) >> 63 << (55-i);
	memset((void *) &key, 0x00, sizeof(key));
	for ( i=0 ; i<56 ; i++ ) key += permutation[i];

	/* Split the key into 2 halves */
	c[0] = key >> (28);
	d[0] = key << (8+28) >> (8+28);

	/* Create 16 blocks of C and D, each formed from the last using */
	/* either 1 or 2 left shifts as defined in shifts[] */
	for (i=0;i<16;i++) {
		if(!i) {
			c[i] = ((c[i] << 1) & 0x0FFFFFFF) + (c[i] >> 27);
			d[i] = ((d[i] << 1) & 0x0FFFFFFF) + (d[i] >> 27);
		}
		else {
			c[i] = ((c[i-1] << shifts[i]) & 0x0FFFFFFF) + (c[i-1] >> (28-shifts[i]));
			d[i] = ((d[i-1] << shifts[i]) & 0x0FFFFFFF) + (d[i-1] >> (28-shifts[i]));
		}
	}

	for (n=0;n<16;n++) {
		/* Concatenate c[n] and d[n] into subkey[n] for 0<=n<=15 */
		subkey[n] = c[n];
		subkey[n] = subkey[n] << 28;
		subkey[n] = subkey[n] + d[n];

		/* Cycle through the PC2 table, store each bit in an */
		/* array element, then add the elements together     */
		memset((void *) &permutation, 0x00, sizeof(permutation));
		for ( i=0 ; i<48 ; i++ ) permutation[i] = subkey[n] << ((pc2[i]-1)+8) >> 63 << (47-i);
		memset((void *) &subkey[n], 0x00, sizeof(subkey[n]));
		for ( i=0 ; i<48 ; i++ ) subkey[n] += permutation[i];
		
	}

}

void encrypt_message(int64 message, int inverse)
{
	int64 permutation[64];
	unsigned int l[16], r[16];
	unsigned int i;
	unsigned int n;
    unsigned int m;

	/* Cycle through the IP table, store each bit in an */
	/* array element, then add the elements together    */
	for ( i=0 ; i<64 ; i++ ) permutation[i] = message << (ip[i]-1) >> 63 << (63-i);
	memset((void *) &message, 0x00, sizeof(message));
	for ( i=0 ; i<64 ; i++ ) message += permutation[i];

	l[0] = message >> 32;
	r[0] = message & 0x00000000FFFFFFFF;

	if (!inverse) {
       /* Iterate through 16 feistel rounds */
	   for (n=0;n<16;n++) {
		   if(n==0) {
               i = l[n];
               l[n] = r[n];
               r[n] = i ^ f(l[n], subkey[n]);
           }
   		   else {
               l[n] = r[n-1];
               r[n] = l[n-1] ^ f(l[n], subkey[n]);
           }
	   }
    }
    else {
       /* Iterate through 16 feistel rounds, reverse the subkey order */
	   for (n=0, m=15;n<16 && m>=0;n++,m--) {
		   if(n==0) {
               i = l[n];
               l[n] = r[n];
               r[n] = i ^ f(l[n], subkey[m]);
           }
   		   else {
               l[n] = r[n-1];
               r[n] = l[n-1] ^ f(l[n], subkey[m]);
           }
	   }
    }
	/* Reverse the order of the two 32 bit halves */
	cipher = r[15];
	cipher = (cipher << 32) + l[15];

	/* Perform final permutation */
    for ( i=0 ; i<64 ; i++ ) permutation[i] = ((cipher << (fp[i]-1)) & 0x8000000000000000LL) >> i;
	memset((void *) &cipher, 0x00, sizeof(cipher));
	for ( i=0 ; i<64 ; i++ ) cipher += permutation[i];
	
}

unsigned int f(unsigned int small, int64 key)
{
	int64 message;
	int64 permutation[64];
	unsigned int table;
	unsigned int record;
	unsigned int final;
	unsigned int i;

	/* Cycle through the E table, store each bit in an */
	/* array element, then add the elements together     */
	memset((void *) &permutation, 0x00, sizeof(permutation));
	message = small;
	for ( i=0 ; i<48 ; i++ ) permutation[i] = ((message << ((e[i]-1)+32)) & 0x8000000000000000LL) >> i+16;
	memset((void *) &message, 0x00, sizeof(message));
	for ( i=0 ; i<48 ; i++ ) message += permutation[i];


	message = message ^ key;

	/* Perform the sbox substitutions */
	memset((void *) &final, 0x00, sizeof(final));
	for (i=0;i<8;i++) {
		table = (message << (16+(i*6)) >> 63 << 1) + (message << ((5+16)+(i*6)) >> 63);
		record = (message << ((1+16)+(i*6)) >> 60);
		final = (final << 4) + s_box[i][table][record];

	}


	/* Cycle through the P table, store each bit in an */
	/* array element, then add the elements together   */
	memset((void *) &permutation, 0x00, sizeof(permutation));
	for ( i=0 ; i<32 ; i++ ) permutation[i] = ((final << (p[i]-1)) & 0x80000000) >> i;
	memset((void *) &final, 0x00, sizeof(final));
	for ( i=0 ; i<32 ; i++ ) final += permutation[i];	

	return final;
}