Binärdatei verschlüsseln und ausgeben

m0m0

also ich hab jetzt mal überall wo "unsigned char" gestanden is "wchar_t" hingeschrieben, das is doch ein unicode-datentyp, oder?

in der zweiten datei, in der ich den verschlüsselten und wieder entschlüsselten text ausgebe, stehen nun tatsächlich wieder binärzeichen, nur leider einige zuviel. es wird also der originaltext hingeschrieben, und hinten noch einige andere zeichen drangehängt.

Bei

fwrite(decrypted, sizeof(wchar_t), size, pFile1);

steht in size zwar der selbe Wert drin, wie am Angang, es werden aber weit mehr Zeichen ausgegeben. Hat jemand eine Ahnung warum?

Badestrand

Da du die Dateien binär behandeltst, spielt UnicodeANSI keine Rolle

Und dass fwrite(decrypted, sizeof(wchar_t), size, pFile1); doppelt soviel schreibt, ist kein Wunder Schließlich werden size*sizeof(wchar_t) Bytes geschrieben statt size*sizeof(char) Bytes.

Und was du noch tun könntest: Wenn du mit dem Visual Studio arbeitest, kannst du die Anfangs- und ver-ent-schlüsselte Datei mit der Dateiendung ".bin" versehen und mit dem VS öffnen - hier kannst du dann bequem vergleichen, inwiefern die Dateien unterschiedlich sind

Lies doch nur mal die Datei ein und speicher sie wieder. ohne verlschüsseln

m0m0

einlesen und ohne verschlüsseln gleich wieder rausschreiben hat vorher schon funktioniert, bevor ich das mit dem wchar_t geändert hab.
doppelt soviel gibt er jetzt auch nicht mehr aus .. allerdings scheint das ganze nur bei kleinen dateien zu funktionieren. keine ahnung warum. wenn ich ne 5 kb datei nehme, funktionierts ohne probleme. bei einer 90 kb datei steht in der ausgabedatei ein paar tausend mal das selbe zeichen (sieht wie ein komisches i aus).
und wie ichs mit einer datei mit einer größe von ca. 30 kbs probiert hab, hats beim ausführen einen fehler gegeben in der zeile
if (s[t]==ByteInput[tmp])

t war bei ca. 80 und tmp bei ein paar tausend, aber noch lange nicht bei size, also irgendwo mitten drinnen. warum hier ein fehler geworfen wurde versteh ich aber nicht. selbst wenn ByteInput[20000] oder was das war NULL gewesen wäre, müsste doch der vergleich ob s[t] gleich null ist funktionieren und keinen fehler erzeugen, der das programm abbricht. wie gesagt, ich verstehs grad nicht.

Badestrand

m0m0 schrieb:

selbst wenn ByteInput[20000] oder was das war NULL gewesen wäre, müsste doch der vergleich ob s[t] gleich null ist funktionieren und keinen fehler erzeugen, der das programm abbricht.

Naja, ByteInput[xx] kann nicht NULL zurückgeben. Zeig doch mal deine ReadFile ( "u1.swf", &Buffer, &size) -Methode.

m0m0

void ReadFile ( char *Filename, wchar_t **Buffer , int *size)
{
	FILE *pFile = fopen ( Filename, "rb" );

	if( pFile != NULL )
	{
		fseek ( pFile, 0, SEEK_END );
		*size = ftell ( pFile );
		*Buffer    = (wchar_t *) malloc ( *size );
		fseek ( pFile, 0, SEEK_SET );
		fread ( *Buffer, sizeof(wchar_t), *size,  pFile );
	}
	fclose ( pFile ); 
}

wchar_t sind doch immer 2 Bytes. Ich glaub da gibts Probleme, wenn die Dateigröße nicht durch 2 Teilbar ist.

camper

C&P-Programmierung ... und so furchtbar viel (=alles) C drin...

fread ( *Buffer, sizeof(wchar_t), *size,  pFile );

das ist jedenfalls unsinn (es sei denn, es ist gerade mal sizeof(wchar_t)==1).

*D*Evil

Davon mal abgesehen das wir hier im C++-Teil sind ... guck dir nochmal den RC4A-Algo an ... http://de.wikipedia.org/wiki/RC4 hast nen Fehler drin ...

Badestrand

Interessante Sache, dieser RC4! Wikipedia nennt ihn ja sogar "sicher"

Naja, jedenfalls hab ich ihn einfach mal programmiert, ist ja zum Glück recht simpel:

void Rc4( const char* input, char* output, unsigned int size, const char* key )
{
    unsigned int keylen = strlen(key);

    unsigned char s[256];
    for ( int i=0; i<256; i++ )
        s[i] = i;

    for ( int i=0, j=0; i<256; i++ )
    {
        j = (j + s[i] + key[i%keylen]) % 256;
        unsigned char c = s[i];
        s[i] = s[j];
        s[j] = c;
    }

    for ( int i=0, j=0, k=0; k<size; k++ )
    {
        i = (i+1) % 256;
        j = (j+s[i]) % 256;
        unsigned char zufall = s[ (s[i]+s[j])%256 ];
        output[k] = zufall ^ input[k];
        unsigned char c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

und etwas gekürzt, muss nicht unbedingt stimmen, sollte aber (:D):

void Rc4( const char* input, char* output, unsigned int size, const char* key )
{
    uint keylen = strlen(key);

    unsigned char s[256];
    for ( int z=0; z<256; ++z )
        s[z] = z;

    unsigned char j = 0;
    for ( int z=0; z<256; ++z )
    {
        j += s[z] + key[z%keylen];
            swap( s[z], s[j] );
    }

    j = 0;
    unsigned char i = 0;
    for ( unsigned int k=0; k<size; ++k )
    {
        j += s[++i];
        unsigned char idx = s[i] + s[j];
        output[k] = s[idx] ^ input[k];
        swap( s[i], s[j] );
    }
}