Keskustelu: Ohjelmointikysymykset: C++: kryptaukseni ei liene toimivansa

/*
jos tuntuu siltä, niin kertokaa onko vika algoritmissa vai
itse koodissa, kun ei kryptaa oikein tota tekstiä
kertokaa samalla onko okei laittaa putkaan omia koodeja
korjattaviksi
*/

#include <iostream>
#include <string>
#include <fstream>
#include <time.h>

using namespace std;

char* resize(char* data, int oldsize, int newsize, char filler='\n');
char* EC(char* data, int ndata, const char* key, int nkey, bool deletedata=false, int ikey=0);
char* DC(char* data, int ndata, const char* key, int nkey, bool deletedata=false, int ikey=-2);

int main()
{
	/*char* avain=new char[16];
	avain[0]=67;
	avain[1]=175;
	avain[2]=250;
	avain[3]=91;
	avain[4]=78;
	avain[5]=6;
	avain[6]=203;
	avain[7]=198;
	avain[8]=109;
	avain[9]=47;
	avain[10]=155;
	avain[11]=83;
	avain[12]=98;
	avain[13]=42;
	avain[14]=83;
	avain[15]=19;
	char* c="jukopliutamasokistit";
	char* ccrypted=EC(c,21,avain,16);
	char* cdecrypted=DC(ccrypted,21,avain,16);
	ccrypted=resize(ccrypted,21,22,'\0');
	avain=resize(avain,16,17,'\0');
	/*
	kerrotaan käyttäjälle mitä ohjelma on saanut aikaan
	*/
	/*cout << c << " kryptattuna avaimella " << avain << " on\n"
		<< ccrypted << " ja dekryptauksen tulos on " << cdecrypted <<"\n";
	delete [] ccrypted;
	delete [] cdecrypted;*/
	for (int i=0;i<10;i++)			// vertaillaan EC:n tuloksia eri avaimella ja
	{								// samalla kryptattavalla tekstillä
		char* avain=new char[5];	// tehdään avain
		avain[0]=i*25;				// asetetaan arvot
		avain[1]=50;
		avain[2]=100;
		avain[3]=150;
		avain[4]=200;
		char* c="cryptattava";
		cout << c << "->" << EC(c,11,avain,5) << "\n";
		//cout << c << "->" << DC(EC(c,12,avain,5),12,avain,6) << "\n";
	}
	return 0;
}

/* (resize)
turha selittää kun ei ole käytössä
deletoi data:n ja palauttaa taulukon, jolla on sama sisältö kuin data:lla,
mutta eri kokoisena ja siten, että ylimääräisiin alkioihin on pistetty
filler:in sisältö
*/
char* resize(char* data, int oldsize, int newsize, char filler)
{
	char * vali=new char[newsize];
	for (int i=0;i<oldsize&&i<newsize;i++)
	{
		vali[i]=data[i];
	}
	if (newsize>oldsize)
		for (int i=oldsize;i<newsize;i++)
			vali[i]=filler;
	delete [] data;
	return vali;
}

char* EC(char* data, int ndata, const char* key, int nkey, bool deletedata, int ikey)
{
	if (ikey>=nkey) return data;		// palautetaan data käsittelemättömänä kun rekursio päättyy
	char* encrypted=new char[ndata];	// luodaan ndata:n kokoinen taulukko, johon data kryptataan
	encrypted[0]=data[0]^key[ikey];		// xorrataan datan eka alkio key[ikey]:llä
										// ikey on se key:n alkio, jolla tällä kertaa xorrataan data
										// ikey:n arvoina käydään läpi rekursiossa kaikki key:n alkiot
	for (int i=1;i<ndata;i++)			// xorrataan loput alkiot ekan alkion perusteella
	{
		encrypted[i]=data[i-1]^data[i];
	}
	if (deletedata) delete [] data;		// data deletoidaan, jos funktiota on kutsuttu EC:n sisältä
										// muuttujaa tarvitaan, sillä kun käyttäjä kutsuu funktiota,
										// se ei saa tuhota data:a, mutta kun se kutsuu itseään
										// täytyy data tuhota, jottei ilmaan jäisi varattua taulukkoa
										// jokaista kutsuttua funktiota kohti
	return EC(encrypted,ndata,key,nkey,true,ikey+1);	// rekursio-plop
}

char* DC(char* data, int ndata, const char* key, int nkey, bool deletedata, int ikey)
{
	if (ikey==-2) ikey=nkey-1; // DC on EC:n palautus, joten sitä lie turha sen tarkemmin kommentoida
	if (ikey==-1) return data;
	char* decrypted=new char[ndata];
	decrypted[0]=data[0]^key[ikey];
	for (int i=1;i<ndata;i++)
	{
		decrypted[i]=decrypted[i-1]^data[i];
	}
	if (deletedata) delete [] data;
	return DC(decrypted,ndata,key,nkey,true,ikey-1);
}

/*char* EC(const char* data, int ndata, const char* key, int nkey)
{
	char* encrypted=new char[ndata];
	for (int ik=0;ik<nkey;ik++)
	{
		encrypted[0]=data[0]^key[ik];
		for (int i=1;i<ndata;i++)
		{
			encrypted[i]=data[i-1]^data[i];
		}
	}
	return encrypted;
}

char* DC(const char* data, int ndata, const char* key, int nkey)
{
	char* decrypted=new char[ndata];
	for (int ik=0;ik<nkey;ik++)
	{
		decrypted[0]=data[0]^key[ik];
		for (int i=1;i<ndata;i++)
		{
			decrypted[i]=decrypted[i-1]^data[i];
		}
	}
	return decrypted;
}*/