ROUTINE DE CRYPTAGE BASIQUE

#include <stdio.h>
#include <string.h>
#include <io.h>
#include <fstream.h>
#include <FCNTL.H>

#define HEADER 4

bool CopyMatrix(unsigned __int8* matdst, unsigned __int8* matsrc, unsigned int  startdst, unsigned int startsrc, unsigned int lenght);

inline int im(int i, int j, int max) { return i*max + j; }

/////////////////////////////////////////////////////////////////////////////////////////
// CRYPTAGE:
/////////////////////////////////////////////////////////////////////////////////////////
bool CopyMatrix(unsigned __int8* matdst, unsigned __int8* matsrc, unsigned int  startdst, unsigned int startsrc, unsigned int lenght) // Copie deux matrices de __in8!
{
	if (matdst == NULL || matdst == NULL)
		return false;

	for (unsigned int i=0;i<lenght;i++)
	{
		matdst[startdst+i] = matsrc[startsrc+i];
	}

	return true;
}

unsigned __int8* Crypt(unsigned __int8* File, char* Key, unsigned long* sizefile, int* Progr)
{
	// Variables:

	// boucles:
	unsigned int i, j, k;

	// Tailles des matrices :
	unsigned long filesize  = *sizefile; //_filelength (fileno);
	*sizefile = filesize+HEADER;
	unsigned long keysize   = strlen(Key);
	unsigned long keytsize  = keysize*keysize;
	unsigned long nbpacks   = 0;
	unsigned long rest      = 0;
	unsigned long keytest   = 0;

	// Matrices:
	unsigned __int8* data	 = new unsigned __int8[filesize+HEADER];
	unsigned __int8* keyt	 = new unsigned __int8[keytsize];
	unsigned __int8* keytemp = new unsigned __int8[keysize];
	unsigned int* indexpacks = NULL;

	// Met le fichier en mémoire
	for(i=0;i<filesize;i++)
		data[i] = File[i];

	delete[] File;
	// Bon, maintenant on passe aux choses sérieuses!

	// Init de la table de crypt:
	for(i=0;i<keysize;i++)
		keytemp[i] = __int8(Key[i]);

	for(i=0;i<keysize;i++)
		for(j=0;j<keysize;j++)
			keyt[im(i,j,keysize)] = keytemp[i] + keytemp[j];

	// Clé de test:
	for(i=0;i<keysize;i++)
		keytest += keytemp[i] * keytemp[keysize-i-1];

	delete [] keytemp; // Bye!

	nbpacks = int((filesize)/keytsize);		// Nb de pack de n octets
	rest = filesize - keytsize*nbpacks;		// Nb d'octets restants

	i=0;j=0;
	for(;i<nbpacks;i++)
		for (j=0;j<keytsize;j++)
		{
			data[im(i,j,keytsize)] = data[im(i,j,keytsize)] ^ keyt[j];		// Cryptage XOR

			*Progr = im(i,j,keytsize);							// Progression
		}

	i--;
	for(k=im(i,j,keytsize);k<filesize;k++)
	{
		data[k] = data[k] ^ keyt[k - im(i,j,keytsize)];
		*Progr = k;											// Progression
	}

	// Inscription de la clé de test:
	data[k] = unsigned __int8((keytest) & 0xFF);
	data[k+1] = unsigned __int8((keytest >> 8) & 0xFF);
	data[k+2] = unsigned __int8((keytest >> 16) & 0xFF);
	data[k+3] = unsigned __int8((keytest >> 24) & 0xFF);
	
	delete [] keyt;

	return data;
}



/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
// DECRYPTAGE:
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

unsigned __int8* Decrypt(unsigned __int8* File, char* Key, unsigned long* sizefile, int* Progr)
{
	// Variables:

	// boucles:
	unsigned int i, j, k;

	// Tailles des matrices :
	unsigned long filesize  = *sizefile;
	*sizefile = filesize-HEADER;
	unsigned long keysize   = strlen(Key);
	unsigned long keytsize  = keysize*keysize;
	unsigned long nbpacks   = 0;
	unsigned long rest      = 0;
	unsigned long keytest   = 0;

	// Matrices:
	unsigned __int8* data	 = new unsigned __int8[filesize];
	unsigned __int8* keyt	 = new unsigned __int8[keytsize];
	unsigned __int8* keytemp = new unsigned __int8[keysize];
	unsigned int* indexpacks = NULL;

	// Met le fichier en mémoire 

	for(i=0;i<filesize;i++)
		data[i] = File[i];

	delete[] File;

	// Bon, maintenant on passe aux choses sérieuses!

	// Init de la table de crypt:
	for(i=0;i<keysize;i++)
		keytemp[i] = __int8(Key[i]);

	for(i=0;i<keysize;i++)
		for(j=0;j<keysize;j++)
			keyt[im(i,j,keysize)] = keytemp[i] + keytemp[j];

	// Clé de test:
	for(i=0;i<keysize;i++)
		keytest += keytemp[i] * keytemp[keysize-i-1];

	delete [] keytemp; // Bye!

	// Comparaison des 2 clés de test:
	if ((data[filesize-HEADER]   != ((keytest)       & 0xFF)) ||
		(data[filesize-HEADER+1] != ((keytest >> 8)  & 0xFF)) ||
		(data[filesize-HEADER+2] != ((keytest >> 16) & 0xFF)) ||
		(data[filesize-HEADER+3] != ((keytest >> 24) & 0xFF)))
		return NULL;

	nbpacks = int((filesize-HEADER)/keytsize);		// Nb de pack de n octets
	rest = filesize - HEADER - keytsize*nbpacks;		// Nb d'octets restants

	i=0;j=0;
	for(;i<nbpacks;i++)
		for (j=0;j<keytsize;j++)
		{
			data[im(i,j,keytsize)] = data[im(i,j,keytsize)] ^ keyt[j];		// Cryptage XOR
			*Progr = im(i,j,keytsize);							// Progression
		}

	i--;
	for(k=im(i,j,keytsize);k<filesize-HEADER;k++)
	{
		data[k] = data[k] ^ keyt[k - im(i,j,keytsize)];
		*Progr = k;											// Progression
	}


	delete [] keyt;

	return data;

}