Помогите разобраться с реализацией DES

#include <stdio.h>

#include "des.hpp"
#include "dessboxes.inc"

Word wMask[] = { 1, 1, 3, 3, 3, 3, 3, 3,
				 1, 3, 3, 3, 3, 3, 3, 1 };

Byte bShift[] = { 1, 1, 2, 2, 2, 2, 2, 2,
				  1, 2, 2, 2, 2, 2, 2, 1 };

// Table for key permutation
Byte bPC1[] = { 56, 48, 40, 32, 24, 16,  8,
				 0, 57, 49, 41, 33, 25, 17,
				 9,  1, 58, 50, 42, 34, 26,
				18, 10,  2, 59, 51, 43, 35,
				62, 54, 46, 38, 30, 22, 14,
				 6, 61, 53, 45, 37, 29, 21,
				13,  5, 60, 52, 44, 36, 28,
				20, 12,  4, 27, 19, 11,  3 };

// Table for compression permutation
Byte bPC2[] = { 13, 16, 10, 23,  0,  4,
				 2, 27, 14,  5, 20,  9,
				22, 18, 11,  3, 25,  7,
				15,  6, 26, 19, 12,  1,
				40, 51, 30, 36, 46, 54,
				29, 39, 50, 44, 32, 47,
				43, 48, 38, 55, 33, 52,
				45, 41, 49, 35, 28, 31 };

// Table for initial permutation IP
Byte bIP1[] = { 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,
				56, 48, 40, 32, 24, 16,  8,  0,
				58, 50, 42, 34, 26, 18, 10,  2,
				60, 52, 44, 36, 28, 20, 12,  4,
				62, 54, 46, 38, 30, 22, 14,  6 };

//                               -1
// Table for final permutation IP
Byte bIP2[] = { 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,
				32,  0, 40,  8, 48, 16, 56, 24 };

// Table for expansion permutation
Byte bE[] = { 31,  0,  1,  2,  3,  4,
			   3,  4,  5,  6,  7,  8,
			   7,  8,  9, 10, 11, 12,
			  11, 12, 13, 14, 15, 16,
			  15, 16, 17, 18, 19, 20,
			  19, 20, 21, 22, 23, 24,
			  23, 24, 25, 26, 27, 28,
			  27, 28, 29, 30, 31,  0 };

// Table for P-Box permutation
Byte bP[] = { 15,  6, 19, 20, 28, 11, 27, 16,
			   0, 14, 22, 25,  4, 17, 30,  9,
			   1,  7, 23, 13, 31, 26,  2,  8,
			  18, 12, 29,  5, 21, 10,  3, 24 };

CDESKey::CDESKey()
{
}

CDESKey::CDESKey(const CDESKey &cDESKey)
{
	dwMaster = cDESKey.dwMaster;
	MakeKeys();
}

CDESKey::CDESKey(const Byte *pbMaster, Word wKeySize)
{
	Dword dwDESKey = DWORDCONST(0);
	memcpy(&dwDESKey, pbMaster, wKeySize);
	dwDESKey = REVERSEDWORD(dwDESKey);
	MIRROR(dwDESKey, 64, dwMaster);
	MakeKeys();
	dwDESKey = 0;
}

CDESKey::CDESKey(Dword dwDESKey)
{
	MIRROR(dwDESKey, 64, dwMaster);
	MakeKeys();
	dwDESKey = 0;								// Cleanup
}

CDESKey::~CDESKey()
{
	for (int i = 0; i < 16; i++)			// Cleanup
		dwKey[i] = 0;
	dwMaster = 0;
}

void CDESKey::MakeKeys()
{
	Dword c = 0;
	Dword d = 0;
	for (int k = 0; k < 28; k++) {
		PUTBIT(c, k, GETBIT(dwMaster, bPC1[k]));
		PUTBIT(d, k, GETBIT(dwMaster, bPC1[k + 28]));
	}
	for (int q = 0; q < 16; q++) {
		c = (c >> bShift[q]) | ((c & wMask[q]) << (28 - bShift[q]));
		d = (d >> bShift[q]) | ((d & wMask[q]) << (28 - bShift[q]));
		Dword t = ((Dword)d << 28) | c;
		STIRBITS(t, 48, bPC2, dwKey[q]);
	}
	c = d = 0;									// Cleanup
}

CDESBlock::CDESBlock()
{
	dwData = 0;									// This is here for definiteness
}

CDESBlock::CDESBlock(const CDESBlock &cDESBlock)
{
	dwData = cDESBlock.dwData;
}

CDESBlock::CDESBlock(Dword dwValue)
{
	MIRROR(dwValue, 64, dwData);
}

CDESBlock::CDESBlock(const Byte *pbData, Word wLength)
{
	SetData(pbData, wLength);
}

CDESBlock::~CDESBlock()
{
	dwData = 0;									// Cleanup
}

void CDESBlock::Encrypt(const CDESKey &cDESKey)
{
	Crypt(cDESKey, false);
}

void CDESBlock::Decrypt(const CDESKey &cDESKey)
{
	Crypt(cDESKey, true);
}

// fgDirection: true = decrypt
//              false = encrypt
void CDESBlock::Crypt(const CDESKey &cDESKey, bool fgDirection)
{
	Dword a;
	Dword b;

	STIRBITS(dwData, 64, bIP1, a);
	Word r = HiWORD(a);
	Word l = LoWORD(a);
	Word s;
	for (int i = 0; i < 16; i++) {
		STIRBITS(r, 48, bE, a);
		if (fgDirection)
			b = a ^ cDESKey.GetKey(15 - i);
		else
			b = a ^ cDESKey.GetKey(i);
		a = 0;
		for (int j = 0; j < 8; j++) {
			a <<= 4;
			a |= bS[j][(b >> ((7 - j) * 6)) & 0x3f];
		}
		STIRBITS(a, 32, bP, b);
		
		s = r;
		r = l ^ LoWORD(b);
		l = s;
	}
	a = ((Dword)l << 32) | r;
	STIRBITS(a, 64, bIP2, dwData);
	a = b = l = r = 0;						// Cleanup
}

void CDESBlock::SetValue(Dword dwValue)
{
	MIRROR(dwValue, 64, dwData);
}

Dword CDESBlock::GetValue()
{
	MIRROR(dwData, 64, dwResult);
	return dwResult;						// It is normal to invoke this method
											// only for encrypted data, so we do
											// not need to clean the buffer variable.
}

void CDESBlock::SetData(const Byte *pbData, Word/* wLength*/)
{
	Dword dwValue = 0;
	memcpy(&dwValue, pbData, BLOCKSIZE);
	dwValue = REVERSEDWORD(dwValue);
	MIRROR(dwValue, 64, dwData);
	dwValue = 0;								// Cleanup
}

Byte *CDESBlock::GetData()
{
	MIRROR(dwData, 64, dwResult);
	dwResult = REVERSEDWORD(dwResult);
	return (Byte *)&dwResult;
}

#ifndef __DES_HPP__
#define __DES_HPP__

#include <string.h>

#include "crypto.hpp"

class CDESKey
{
	public:
		enum { KEYSIZE = 8 };

	public:
		CDESKey();
		CDESKey(const CDESKey &);
		CDESKey(const Byte *, Word = KEYSIZE);
		CDESKey(Dword);
		virtual ~CDESKey();

	public:
		Dword GetMaster() const { return dwMaster; };
		Dword GetKey(Word i) const { return dwKey[i]; };

	public:
		Word GetKeySize() { return KEYSIZE; };

	private:
		void MakeKeys();

	private:
		Dword dwMaster;
		Dword dwKey[16];
};

class CDESBlock
{
	public:
		enum { BLOCKSIZE = 8 };

	public:
		CDESBlock();
		CDESBlock(const CDESBlock &);
		CDESBlock(Dword);
		CDESBlock(const Byte *, Word wLength = BLOCKSIZE);
		virtual ~CDESBlock();

	public:
		void Encrypt(const CDESKey &);
		void Decrypt(const CDESKey &);
		void SetData(const Byte *, Word = BLOCKSIZE);
		Byte *GetData();
		Word GetBlockSize() { return BLOCKSIZE; };
		void SetValue(Dword);
		Dword GetValue();
	
	protected:
		void Crypt(const CDESKey &, bool);

	private:
		Dword dwData, dwResult;
};

#endif // __DES_HPP__

// Automatically generated header.
// See "dessboxes.pl" for more information.
// Do not edit by hand.

#ifndef __DESSBOXES_HPP__
#define __DESSBOXES_HPP__

Byte bS[][64] =
{
	{
		11, 14,  5,  0,  6,  9, 10, 15,  1,  2, 12,  5, 13,  7,  3, 10, 
		 4, 13,  9,  6, 15,  3,  0, 12,  2,  8,  7, 11,  8,  4, 14,  1, 
		 8,  4,  3, 15,  5,  2,  0, 12, 11,  7,  6,  9, 14,  1,  9,  6, 
		15,  8, 10,  3, 12,  5,  7, 10,  1, 14, 13,  0,  2, 11,  4, 13
	},
	{
		 2,  8, 12,  5, 15,  3, 10,  0,  4, 13,  9,  6,  1, 14,  6,  9, 
		13,  2,  3, 15,  0, 12,  5, 10,  7, 11, 14,  1, 11,  7,  8,  4, 
		11,  6,  7,  9,  2,  8,  4,  7, 13, 11, 10,  0,  8,  5,  1, 12, 
		 0, 13, 12, 10,  9,  2, 15,  4, 14,  1,  3, 15,  5, 14,  6,  3
	},
	{
		 3,  9,  0, 14,  9,  4,  7,  8,  5, 15, 12,  2,  6,  3, 10, 13, 
		 8,  7, 11,  0,  4,  1, 14, 11, 15, 10,  2,  5,  1, 12, 13,  6, 
		 5,  2,  6, 13, 14,  9,  0,  6,  2,  4, 11,  8,  9, 15, 12,  1, 
		15, 12,  8,  7,  3, 10, 13,  0,  4,  3,  7, 14, 10,  5,  1, 11
	},
	{
		 4,  2,  1, 15, 14,  5, 11,  6,  2,  8, 12,  3, 13, 14,  7,  0, 
		 3,  4, 10,  9,  5, 11,  0, 12,  8, 13, 15, 10,  6,  1,  9,  7, 
		 7, 13, 10,  6,  2,  8, 12,  5,  4,  3, 15,  0, 11,  4,  1, 10, 
		13,  1,  0, 15, 14,  7,  9,  2,  3, 14,  5,  9,  8, 11,  6, 12
	},
	{
		14,  5,  8, 15,  0,  3, 13, 10,  7,  9,  1, 12,  9, 14,  2,  1, 
		11,  6,  4,  8,  6, 13,  3,  4, 12,  0, 10,  7,  5, 11, 15,  2, 
		11, 12,  2,  9,  6,  5,  8,  3, 13,  0,  4, 10,  0, 11,  7,  4, 
		 1, 15, 14,  2, 15,  8,  5, 14, 10,  6,  3, 13, 12,  1,  9,  7
	},
	{
		 5, 11,  8, 13,  6,  1, 13, 10,  9,  2,  3,  4, 15, 12,  4,  7, 
		 0,  6, 11,  8, 12, 15,  2,  5,  7,  9, 14,  3, 10,  0,  1, 14, 
		11,  8,  4,  2, 12,  6,  3, 13,  0, 11, 10,  7,  6,  1, 15,  4, 
		14,  5,  1, 15,  2,  9, 13, 10,  9,  0,  7, 12,  5, 14,  8,  3
	},
	{
		15,  0,  9, 10,  6,  5,  3,  9,  1, 14,  4,  3, 12, 11, 10,  4, 
		 8,  7, 14,  1, 13,  2,  0, 12,  7, 13, 11,  6,  2,  8,  5, 15, 
		12, 11,  3, 13, 15, 12,  6,  0,  2,  5,  8, 14,  1,  2, 13,  7, 
		11,  1,  0,  6,  4, 15,  9, 10, 14,  8,  5,  3,  7,  4, 10,  9
	},
	{
		 7,  2, 12, 15,  4, 11, 10, 12, 11,  7,  6,  9, 13,  4,  0, 10, 
		 2,  8,  5,  3, 15,  6,  9,  5,  8,  1,  3, 14,  1, 13, 14,  0, 
		 0, 15,  5, 10,  7,  2,  9,  5, 14,  1,  3, 12, 11,  8, 12,  6, 
		15,  3,  6, 13,  4,  9, 10,  0,  2,  4, 13,  7,  8, 14,  1, 11
	}
};

#endif // __DESSBOXES_HPP__

#!/usr/bin/perl -w

@s = ( 
		 [
			[ 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 ] 
		 ],
		 [
			[ 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 ] 
		 ],
		 [
			[ 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 ] 
		 ],
		 [
			[  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 ] 
		 ],
		 [
			[  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 ] 
		 ],
		 [
			[ 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 ] 
		 ],
		 [
			[  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 ] 
		 ],
		 [
			[ 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 ] 
		 ],
	 );

print <<EOT;
// Automatically generated header.
// See "dessboxes.pl" for more information.
// Do not edit by hand.

#ifndef __DESSBOXES_HPP__
#define __DESSBOXES_HPP__

Byte bS[][64] =
{
EOT
for (0 .. 7) {
	$sbox = 7 - $_;
	printf("\t{\n");
	for (0 .. 63) {
		$col = $_ >> 1;
		$col = (($col << 3) & 8) | 
				 (($col << 1) & 4) |
				 (($col >> 1) & 2) |
				 (($col >> 3) & 1);
		$row = (($_ >> 5) & 1) | (($_ << 1) & 2);
		$cell = $s[$sbox][$row][$col];
		
		printf("\t\t") if ($_ % 16 == 0);		
		printf("%2d", (($cell << 3) & 8) | (($cell << 1) & 4) | (($cell >> 1) & 2) | (($cell >> 3) & 1));
		printf(", ") if (($_ + 1) % 64 != 0);
		printf("\n") if (($_ + 1) % 16 == 0);
	}
	printf("\t},\n") if ($sbox != 0);
	printf("\t}\n") if ($sbox == 0);
}
print <<EOT;
};

#endif // __DESSBOXES_HPP__
EOT

#ifndef __CRYPTO_HPP__
#define __CRYPTO_HPP__

#ifdef WIN32
#define DWORDCONST(x)				(x##i64)
#define WORDCONST(x)				(x##L)
#else
#define DWORDCONST(x)				(x##LL)
#define WORDCONST(x)				(x##L)
#endif

#define BASE						DWORDCONST(0x100000000)
#define ONE							DWORDCONST(0x1)
#define MaxWORD						WORDCONST(0xFFFFFFFF)

#ifdef WIN32
	typedef unsigned __int32		Word;
	typedef unsigned __int64		Dword;
#else
	typedef unsigned int			Word;
	typedef unsigned long long		Dword;
#endif

typedef unsigned char				Byte;
typedef unsigned short				Short;

#define CHARSINWORD							8
#define BITSINWORD						   32
#define BITSINSHORT						   16
#define BITSINBYTE							8
#define BYTESINWORD					(BITSINWORD / BITSINBYTE)
#define BYTESINSHORT				(BITSINSHORT / BITSINBYTE)

// Operations for all types
#define Max(a, b)					((a) > (b) ? (a) : (b))
#define Min(a, b)					((a) < (b) ? (a) : (b))

// Operations with DWORDs
#define HiWORD(a)					((Word)((a) >> BITSINWORD))
#define LoWORD(a)					((Word)(a))
#define DWSHORT0(a)					((Short)((a) >> 48))
#define DWSHORT1(a)					((Short)((a) >> 32))
#define DWSHORT2(a)					((Short)((a) >> 16))
#define DWSHORT3(a)					((Short)(a))
#define DWBYTE0(a)					((Byte)((a) >> 56))
#define DWBYTE1(a)					((Byte)((a) >> 48))
#define DWBYTE2(a)					((Byte)((a) >> 40))
#define DWBYTE3(a)					((Byte)((a) >> 32))
#define DWBYTE4(a)					((Byte)((a) >> 24))
#define DWBYTE5(a)					((Byte)((a) >> 16))
#define DWBYTE6(a)					((Byte)((a) >> 8))
#define DWBYTE7(a)					((Byte)(a))
#define MAKEDWORD(a, b, c, d)		(((Dword)(a) << 48) | ((Dword)(b) << 32) | ((Dword)(c) << 16) | (Dword)(d))
#define MAKEDWORDB(a, b, c, d, e, f, g, h) \
									(((Dword)(a) << 56) | ((Dword)(b) << 48) | ((Dword)(c) << 40) | ((Dword)(d) << 32) | \
									 ((Dword)(e) << 24) | ((Dword)(f) << 16) | ((Dword)(g) << 8) | (Dword)(h))
#define REVERSEDWORD(a)				(((Dword)REVERSEWORD(LoWORD(a)) << BITSINWORD) | (REVERSEWORD(HiWORD(a))))

// Operations with WORDs
// The oldest byte is 0 (leftmost)
// The youngest byte is 3 (rightmost)
#define HISHORT(a)					((Short)((a) >> BITSINSHORT))
#define LOSHORT(a)					((Short)(a))
#define WBYTE0(a)					((Byte)((a) >> 24))
#define WBYTE1(a)					((Byte)((a) >> 16))
#define WBYTE2(a)					((Byte)((a) >> 8))
#define WBYTE3(a)					((Byte)(a))
#define MakeWord(a, b, c, d)		(((Word)(a) << 24) | ((Word)(b) << 16) | ((Word)(c) << 8) | (Word)(d))
#define MAKEWORDS(a, b)				(((Word)(a) << 16) | (Word)(b))
#define REVERSEWORD(a)				(((a) << 24) | ((a) >> 24) | (((a) & 0x0FF00) << 8) | (((a) & 0x0FF0000) >> 8))

// Operations with SHORTs
#define SBYTE0(a)					((Byte)((a) >> 8))
#define SBYTE1(a)					((Byte)(a))
#define MAKESHORT(a, b)				(((Short)(a) << 8) | (Short)(b))

// Bit operations with DWORDs
// Bit 0 is the least significant bit
// Bit 63 is the most significant bit
#define GETBIT(a, b)				(((a) >> (b)) & ONE)
#define SETBIT(a, b)				((a) = (a) | (ONE << (b)))
#define CLRBIT(a, b)				((a) = (a) & (~(ONE << (b))))
#define PUTBIT(a, b, c)				(((c) == 1) ? SETBIT((a), (b)) : CLRBIT((a), (b)))
#define STIRBITS(a, b, c, d)		{ d = 0; for (int ii = 0; ii < (b); ii++) PUTBIT((d), ii, GETBIT((a), (c)[ii])); }
#define MIRROR(a, b, c)				{ c = 0; for (int ii = 0; ii < (b); ii++) { c <<= 1; c |= (a >> ii) & 1; } }

// Bit operations with BYTEs
#define ROT2(a)						(((a) << 2) | (((a) >> 6) & 3))

#endif // __CRYPTO_HPP__

		/*  DES Encryption & Decryption Code */

# include <stdio.h>
# include <fstream.h>
# include <string.h>
# include <conio.h>
# include <iostream.h>
	int key[64]={
		0,0,0,1,0,0,1,1,
		0,0,1,1,0,1,0,0,
		0,1,0,1,0,1,1,1,
		0,1,1,1,1,0,0,1,
		1,0,0,1,1,0,1,1,
		1,0,1,1,1,1,0,0,
		1,1,0,1,1,1,1,1,
		1,1,1,1,0,0,0,1
		};
class Des
{
 public:
  int keyi[16][48],
      total[64],
      left[32],
      right[32],
      ck[28],
      dk[28],
      expansion[48],
      z[48],
      xor1[48],
      sub[32],
      p[32],
      xor2[32],
      temp[64],
      pc1[56],
      ip[64],
      inv[8][8];

  char final[1000];
  void IP();
  void PermChoice1();
  void PermChoice2();
  void Expansion();
  void inverse();
  void xor_two();
  void xor_oneE(int);
  void xor_oneD(int);
  void substitution();
  void permutation();
  void keygen();
  char * Encrypt(char *);
  char * Decrypt(char *);
};
void Des::IP() //Initial Permutation
{
	int k=58,i;
	for(i=0;i<32;i++)
	{
	   ip[i]=total[k-1];
	   if(k-8>0)  k=k-8;
	   else       k=k+58;
	}
	k=57;
	for( i=32;i<64;i++)
	{
		ip[i]=total[k-1];
		if(k-8>0)   k=k-8;
		else	    k=k+58;
	}
}
void Des::PermChoice1() //Permutation Choice-1
{
	int k=57,i;
	for(i=0;i<28;i++)
	{
		pc1[i]=key[k-1];
		if(k-8>0)    k=k-8;
		else	     k=k+57;
	}
	k=63;
	for( i=28;i<52;i++)
	{
		pc1[i]=key[k-1];
		if(k-8>0)    k=k-8;
		else         k=k+55;
	}
	k=28;
	for(i=52;i<56;i++)
	{
		pc1[i]=key[k-1];
		k=k-8;
	}

}
void Des::Expansion() //Expansion Function applied on `right' half
{
	int exp[8][6],i,j,k;
	for( i=0;i<8;i++)
	{
		for( j=0;j<6;j++)
		{
			if((j!=0)||(j!=5))
			{
				k=4*i+j;
				exp[i][j]=right[k-1];
			}
			if(j==0)
			{
				k=4*i;
				exp[i][j]=right[k-1];
			}
			if(j==5)
			{
				k=4*i+j;
				exp[i][j]=right[k-1];
			}
		}
	}
	exp[0][0]=right[31];
	exp[7][5]=right[0];

	k=0;
	for(i=0;i<8;i++)
	for(j=0;j<6;j++)
	expansion[k++]=exp[i][j];
}
void Des::PermChoice2()
{
	int per[56],i,k;
	for(i=0;i<28;i++) per[i]=ck[i];
	for(k=0,i=28;i<56;i++) per[i]=dk[k++];

	z[0]=per[13];z[1]=per[16];z[2]=per[10];z[3]=per[23];z[4]=per[0];z[5]=per[4];z[6]=per[2];z[7]=per[27];
	z[8]=per[14];z[9]=per[5];z[10]=per[20];z[11]=per[9];z[12]=per[22];z[13]=per[18];z[14]=per[11];z[15]=per[3];
	z[16]=per[25];z[17]=per[7];z[18]=per[15];z[19]=per[6];z[20]=per[26];z[21]=per[19];z[22]=per[12];z[23]=per[1];
	z[24]=per[40];z[25]=per[51];z[26]=per[30];z[27]=per[36];z[28]=per[46];z[29]=per[54];z[30]=per[29];z[31]=per[39];
	z[32]=per[50];z[33]=per[46];z[34]=per[32];z[35]=per[47];z[36]=per[43];z[37]=per[48];z[38]=per[38];z[39]=per[55];
	z[40]=per[33];z[41]=per[52];z[42]=per[45];z[43]=per[41];z[44]=per[49];z[45]=per[35];z[46]=per[28];z[47]=per[31];
}
void Des::xor_oneE(int round) //for Encrypt
{
 int i;
	for(i=0;i<48;i++)
	    xor1[i]=expansion[i]^keyi[round-1][i];
}
void Des::xor_oneD(int round) //for Decrypt
{
 int i;
	for(i=0;i<48;i++)
	    xor1[i]=expansion[i]^keyi[16-round][i];
}

void Des::substitution()
{
	int s1[4][16]={
		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
	  };

	int s2[4][16]={
		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
	   };

	int s3[4][16]={
		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
	   };

	int s4[4][16]={
		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
	   };

	int s5[4][16]={
		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
	   };

	int s6[4][16]={
		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
	   };

	int s7[4][16]={
		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
	   };

	int s8[4][16]={
		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 a[8][6],k=0,i,j,p,q,count=0,g=0,v;

	for(i=0;i<8;i++)
	{
		for(j=0;j<6;j++)
		{
			a[i][j]=xor1[k++];
		}
	}

	for( i=0;i<8;i++)
	{
		p=1;q=0;
		k=(a[i][0]*2)+(a[i][5]*1);
		j=4;
		while(j>0)
		{
			q=q+(a[i][j]*p);
			p=p*2;
			j--;
		}
		count=i+1;
		switch(count)
		{
		case 1:	v=s1[k][q];	break;
		case 2:	v=s2[k][q];	break;
		case 3:	v=s3[k][q];	break;
		case 4:	v=s4[k][q];	break;
		case 5:	v=s5[k][q];	break;
		case 6:	v=s6[k][q];	break;
		case 7:	v=s7[k][q];	break;
		case 8:	v=s8[k][q];	break;
		}

		int d,i=3,a[4];
		while(v>0)
		{
			d=v%2;
			a[i--]=d;
			v=v/2;
		}
		while(i>=0)
		{
			a[i--]=0;
		}

		for(i=0;i<4;i++)
		sub[g++]=a[i];
	}
}

void Des::permutation()
{
	p[0]=sub[15];p[1]=sub[6];p[2]=sub[19];p[3]=sub[20];p[4]=sub[28];p[5]=sub[11];p[6]=sub[27];p[7]=sub[16];
	p[8]=sub[0];p[9]=sub[14];p[10]=sub[22];p[11]=sub[25];p[12]=sub[4];p[13]=sub[17];p[14]=sub[30];p[15]=sub[9];
	p[16]=sub[1];p[17]=sub[7];p[18]=sub[23];p[19]=sub[13];p[20]=sub[31];p[21]=sub[26];p[22]=sub[2];p[23]=sub[8];
	p[24]=sub[18];p[25]=sub[12];p[26]=sub[29];p[27]=sub[5];p[28]=sub[21];p[29]=sub[10];p[30]=sub[3];p[31]=sub[24];
}

void Des::xor_two()
{
 int i;
	for(i=0;i<32;i++)
	{
		xor2[i]=left[i]^p[i];
	}
}

void Des::inverse()
{
	int p=40,q=8,k1,k2,i,j;
	for(i=0;i<8;i++)
	{
		k1=p;k2=q;
		for(j=0;j<8;j++)
		{
			if(j%2==0)
			{
				inv[i][j]=temp[k1-1];
				k1=k1+8;
			}
			else if(j%2!=0)
			{
				inv[i][j]=temp[k2-1];
				k2=k2+8;
			}
		}
		p=p-1;q=q-1;
	}
}

char * Des::Encrypt(char *Text1)
{
  int i,a1,j,nB,m,iB,k,K,B[8],n,t,d,round;
  char *Text=new char[1000];
  strcpy(Text,Text1);
  i=strlen(Text);
  int mc=0;
  a1=i%8;
 if(a1!=0) for(j=0;j<8-a1;j++,i++) Text[i]=' '; Text[i]='\0';
 keygen();
  for(iB=0,nB=0,m=0;m<(strlen(Text)/8);m++) //Repeat for TextLenth/8 times.
  {
     for(iB=0,i=0;i<8;i++,nB++)
      {
		 n=(int)Text[nB];
		 for(K=7;n>=1;K--)
		 {
		  B[K]=n%2;  //Converting 8-Bytes to 64-bit Binary Format
		  n/=2;
		 } for(;K>=0;K--) B[K]=0;
	   for(K=0;K<8;K++,iB++) total[iB]=B[K]; //Now `total' contains the 64-Bit binary format of 8-Bytes
      }
	IP(); //Performing initial permutation on `total[64]'
	for(i=0;i<64;i++) total[i]=ip[i]; //Store values of ip[64] into total[64]

	for(i=0;i<32;i++) left[i]=total[i]; // 		  +--> left[32]
					    // total[64]--|
	for(;i<64;i++) right[i-32]=total[i];//            +--> right[32]
    for(round=1;round<=16;round++)
    {
	Expansion(); //Performing expansion on `right[32]' to get  `expansion[48]'
	xor_oneE(round); //Performing XOR operation on expansion[48],z[48] to get xor1[48]
	substitution();//Perform substitution on xor1[48] to get sub[32]
	permutation(); //Performing Permutation on sub[32] to get p[32]
	xor_two(); //Performing XOR operation on left[32],p[32] to get xor2[32]
	for(i=0;i<32;i++) left[i]=right[i]; //Dumping right[32] into left[32]
	for(i=0;i<32;i++) right[i]=xor2[i]; //Dumping xor2[32] into right[32]
     }
	for(i=0;i<32;i++) temp[i]=right[i]; // Dumping   -->[ swap32bit ]
	for(;i<64;i++) temp[i]=left[i-32];  //    left[32],right[32] into temp[64]

	inverse(); //Inversing the bits of temp[64] to get inv[8][8]
	/* Obtaining the Cypher-Text into final[1000]*/
		   k=128;   d=0;
		for(i=0;i<8;i++)
		{
		  for(j=0;j<8;j++)
		  {
		    d=d+inv[i][j]*k;
		    k=k/2;
		  }
		   final[mc++]=(char)d;
		   k=128;   d=0;
		}
  } //for loop ends here
  final[mc]='\0';
  return(final);
}
char * Des::Decrypt(char *Text1)
{
  int i,a1,j,nB,m,iB,k,K,B[8],n,t,d,round;
  char *Text=new char[1000];
  unsigned char ch;
  strcpy(Text,Text1);
  i=strlen(Text);
keygen();
int mc=0;
  for(iB=0,nB=0,m=0;m<(strlen(Text)/8);m++) //Repeat for TextLenth/8 times.
  {
     for(iB=0,i=0;i<8;i++,nB++)
      {
		 ch=Text[nB];
		 n=(int)ch;//(int)Text[nB];
		 for(K=7;n>=1;K--)
		 {
		  B[K]=n%2;  //Converting 8-Bytes to 64-bit Binary Format
		  n/=2;
		 } for(;K>=0;K--) B[K]=0;
	   for(K=0;K<8;K++,iB++) total[iB]=B[K]; //Now `total' contains the 64-Bit binary format of 8-Bytes
      }
	IP(); //Performing initial permutation on `total[64]'
	for(i=0;i<64;i++) total[i]=ip[i]; //Store values of ip[64] into total[64]

	for(i=0;i<32;i++) left[i]=total[i]; // 		  +--> left[32]
					    // total[64]--|
	for(;i<64;i++) right[i-32]=total[i];//            +--> right[32]
      for(round=1;round<=16;round++)
      {
	Expansion(); //Performing expansion on `right[32]' to get  `expansion[48]'
	xor_oneD(round);
	substitution();//Perform substitution on xor1[48] to get sub[32]
	permutation(); //Performing Permutation on sub[32] to get p[32]
	xor_two(); //Performing XOR operation on left[32],p[32] to get xor2[32]
	for(i=0;i<32;i++) left[i]=right[i]; //Dumping right[32] into left[32]
	for(i=0;i<32;i++) right[i]=xor2[i]; //Dumping xor2[32] into right[32]
     } //rounds end here
	for(i=0;i<32;i++) temp[i]=right[i]; // Dumping   -->[ swap32bit ]
	for(;i<64;i++) temp[i]=left[i-32];  //    left[32],right[32] into temp[64]

	inverse(); //Inversing the bits of temp[64] to get inv[8][8]
	/* Obtaining the Cypher-Text into final[1000]*/
		   k=128;   d=0;
		for(i=0;i<8;i++)
		{
		  for(j=0;j<8;j++)
		  {
		    d=d+inv[i][j]*k;
		    k=k/2;
		  }
		   final[mc++]=(char)d;
		   k=128;   d=0;
		}
  } //for loop ends here
  final[mc]='\0';
  char *final1=new char[1000];
  for(i=0,j=strlen(Text);i<strlen(Text);i++,j++)
    final1[i]=final[j]; final1[i]='\0';
  return(final);
}
void main()
{
 Des d1,d2;
 char *str=new char[1000];
 char *str1=new char[1000];
 clrscr();
 //strcpy(str,"PHOENIX it & ece solutions.");
 cout<<"Enter a string : ";
  gets(str);
 str1=d1.Encrypt(str);
 cout<<"\ni/p Text: "<<str<<endl;
 cout<<"\nCypher  : "<<str1<<endl;
//	 ofstream fout("out2_fil.txt"); fout<<str1; fout.close();
 cout<<"\no/p Text: "<<d2.Decrypt(str1)<<endl;
 getch();
}

void Des::keygen()
{
	PermChoice1();

	int i,j,k=0;
	for(i=0;i<28;i++)
	{
		ck[i]=pc1[i];
	}
	for(i=28;i<56;i++)
	{
		dk[k]=pc1[i];
		k++;
	}
	int noshift=0,round;
	for(round=1;round<=16;round++)
	{
		if(round==1||round==2||round==9||round==16)
			noshift=1;
		else
			noshift=2;
		while(noshift>0)
		{
			int t;
			t=ck[0];
			for(i=0;i<28;i++)
			ck[i]=ck[i+1];
			ck[27]=t;
			t=dk[0];
			for(i=0;i<28;i++)
			dk[i]=dk[i+1];
			dk[27]=t;
			noshift--;
		}
		PermChoice2();
		for(i=0;i<48;i++)
			keyi[round-1][i]=z[i];
	}
}

void clear_screen()
{
    for(int i = 0; i < 50; i++) 
        cout<<endl;
}