Enkel kryptering

Jag behöver en kryptering för att kryptera stora mängder data snabbt. Det bör vara en algoritm som är enkel att implementera. Den behöver inte vara oknäckbar, den ska egentligen bara stoppa folk från att läsa eller ändra i filer. Jag testade först lite med en xor-kryptering men insåg ganska snabbt att det var ganska värdelöst eftersom krypteringsnyckeln skrevs ut när det fanns bytes med värdet 0 ;)

En enkel modell är att peta ihop en variant av ceasar som styrs av en nyckel.

Dvs:

nyckel: 
    KEY
text:
    abbas kaviartub
blir:
    (a+K)mod ö, (b+E)mod ö,  (b+Y)mod ö, (a+K)mod ö, ('  '+E)mod ö .. osv.

Inte oknäckbart, men texten blir ivf förvanskad.

Annars, om det är ett program som ska skriva och läsa till filerna är det bättre att använda binär data i filerna istället för text.

Du menar så här?

void ceasar(char *input, char *output, long lenght, char *key, bool reverse=false)
{

	int key_pos = 0;
	int key_len = strlen(key);

	for(long i=0;i<lenght;i++)
	{

		if(reverse==false)
			output[i] = input[i] + key[key_pos++] % 'ö';
		else
			output[i] = input[i] - key[key_pos++] % 'ö';

		if(key_pos>key_len)
			key_pos = 0;
	}

}

Ändrade lite... Kom inte på något sätt att dekryptera på det sättet du beskrev. Det blir lite omkastat men det är ganska lätt att lista ut en del av innehållet eftersom versaler oftast blir andra versaler och gemener oftast blir andra gemener. Men jag tror det fungerar ganska bra till ändamålet. :)

Jag menade ungefär så ja. Men du kanske bör se till att det blir ett intervall så att inte vissa tecken skrivs sönder (t.ex är ju 0 = terminering) och andra lustiga effekter. Det är ju inom det bestämda intervallet som modulo ska operera och 'ö' är bara den övre gränsen :)
Dekrypteringen har du ju redan i samma funktion, dvs lägg på åt ena hållet och dra bort åt andra.

Men är det inte aktuellt med binärdata istället?

Det är binär data...

Isf ska det räcka med att bara lägga på nyckeln på data vid krypteringen och omvänt vid dekrypteringen. Men du behöver ju inte loopa, utan datat genom en funktion, byte för byte och bara stega runt med nyckeln.

Hur menar du?

Jag testade förresten att kryptera en stor fil (132 MB). Men jag fick problem när jag skulle avkryptera den. Början av filen blev korrekt avkrypterad men resten blev bara skräp.

Jag menar att funktionen du nu tar en "sträng" av bytes och fyller resultatet i en annan "sträng". Det blir inneffektivt om du har stora filer och hur blir det med minnet? Så det kan vara bättre att ha en funktion som tar ett byte åt gången och returnerar ett bearbetat byte och att denna data som du hämtar / skriver till filen får passera funktionen, byte efter byte. Du läser/skriver ju ändå från/till filen byte för byte så det är väl lämpligt att implementera funktionen direkt i anslutning till det.

I senaste numret av DatorMagazinet (1 -2004) finns det en mycket bra artikel om komprimering. Om man sätter in en nyckel i dettta kör, har man samtidigt en bra kryptering.
Kan det vara ett läsvärt uppslag?

Man kan skapa en enkel kryptering utifrån rand-funktionen i C++:

//Otestad kod
void encrypt(vector<unsigned char>& data, unsigned key)
{
  using namespace std;

  //Initera slumptalsgeneratorn till kryperingsnyckeln
  srand( key );

  for (int p=0; p < data.length(); ++p)
    //Lägg till ett "slumpmässigt" tal till datan
    data[p] = (data[p] + rand()%256) % 256;
}

För att dekryptera initerar man med srand() till samma nyckel och subtraherar ett "slumpmässigt" tal (som ju då är samma som man tidigare lade till.

//Otestad kod

void encrypt(vector<unsigned char>& data, unsigned key)
{
  using namespace std;

  //Initera slumptalsgeneratorn till kryperingsnyckeln
  srand( key );

  for (int p=0; p < data.length(); ++p)
  {
    int byte = data[p];
    //Dra ifråntill ett "slumpmässigt" tal till datan
    byte -= rand()%256;
    if (byte < 0)
      byte = 256-byte;
    data[p] = static_cast<unsigned char>( byte );
  }
}

Om man vill ha en sträng som kryperingsnyckel kan man generera den med hjälp av en checksumma eller något.