» Steganographie zum Experimentieren mit der Verschlüsselung von Dateien

1. = Addition
2. = Subtraktion

/* 
Diese Funktion ist ein Beispiel wie so eine Dechiffrierung aussehen könnte.
Als erster Parameter fungiert der Textfundus,
zweiter Parameter ist die Buchstabennummer der dechiffrierten Nachricht,
dritter Parameter der Codeschlüssel.
*/ 

int Dekodieren(unsigned int Codeletter[], int Letternummer, int Schluessel[])
{
int Rechenart, Zusatzwert, Nachricht, Position;
/* 
Positionserrechnung der Rechenelemente(Codeletter, Rechenart, Zusatzwert) 
Byte: 0 1 2 3 4
 0 1 2 | 3 4 5 | 6 7 8 | 9 10 11 | 12 13 14
 1*3=3 2*3=6 3*3=9 4*3=12
 */
if (Letternummer > 0) 
Letternummer = Letternummer * 3;
 
Position = Schluessel[Letternummer];
Rechenart = Schluessel[Letternummer + 1];
Zusatzwert = Schluessel[Letternummer + 2];
if (Rechenart == 0) Nachricht = Codeletter[Position];
if (Rechenart == 1) Nachricht = Codeletter[Position] + Zusatzwert; 
if (Rechenart == 2) Nachricht = Codeletter[Position] - Zusatzwert;
return(Nachricht);
}
Reihenfolge zur Kodierung 
1. Quelle aussuchen: Bzw. eine CD, Texte Bücher Werbeprospekte, Sektoren von Disketten, WAV-Dateien usw...
2. Benötigte Quellpassagen einlesen und als Datei speichern.
3. Per Zufall Zeichenfolge festlegen, (Anzahl so hoch wie Dateilänge) 
4. einzelne Quellbytes mit Nachrichtenbytes vergleichen und Differenz errechnen
5. Aus Differenz Rechenart und Zusatzwert festlegen
6. Positionswert(Zufallszahl), Rechenart und Zusatzwert in Codeschlüssel abspeichern 
Beispielprogramm in C:
/*Reihenfolge zur Kodierung 
1. Quelle aussuchen
2. Quellpassagen einlesen
3. Per Zufall Zeichenfolge festlegen
4. mit Nachrichtenbyte vergleichen und Differenz errechnen
5. Rechenart und Zusatzwert festlegen
6. Positionswert, Rechenart und Zusatzwert in Codeschlüssel abspeichern 
*/




/* selbstgeschriebener Header random.h für die Funktion random und
* getrandom . Wenn RANDOMIZE verwendet wird, wird bei einer
* Schleifenanweisung zur Erzeugung von Zufallsdatenfeldern diese
* Anweisung nur einmal benötigt, sonst werden immer die gleichen Zahlen
* erzeugt
* Beispiel
* #include <kopf.h>
* #include <random.h>
* void setranval(int (*wert)[16])
* {
* int sleia, sleib;
* for (sleia = 0; sleia <= 15; sleia++)
*  {
*   numal: (*wert)[sleia] = getrandom( 0, 15 );
*         if (sleia > 0)
*          for (sleib = 0 ; sleib <= (sleia - 1); sleib++)
*         if ((*wert)[sleib] == (*wert)[sleia])
*          goto numal;
*  }
*
* }
*
* void main(void)
* {
* int sleia, sleib, zuzko[16], zko[16];
* RANDOMIZE();
* for (sleib = 0; sleib  <= 15; sleib++)
*  {
*  setranval(&zuzko);
*  printf("\n");
*   for (sleia = 0; sleia <= 15; sleia++)
*    printf("%d ", (zuzko)[sleia]);
*  }
* }
* ----------- Beispielende--------------------- */
#ifndef _INC_RANDOM
#define _INC_RANDOM 1


#include <stdlib.h>
#include <time.h>
#include <malloc.h>
 /* dient zur Überprüfung, ob RANDOMIZE mehr als einmal
  * bei Programmablauf aufgerufen wurde  */
int randinitcount = 0; 
                
/* #define RANDOMIZE() srand( (unsigned)time( NULL ) ) 
 * 
 * alte Aefinition der "Funktion" getrandom:
 *
 * #define getrandom( min, max)(( rand() % (int)(max - min + 1)) + (int)(min))
 * letzte Änderung am 17.10.2002 um 20.00 Uhr  */

int __cdecl getrandom( int min, int max)
{
int zuza, zuza2, zuza3, rewer;
zuza  = rand();
zuza2 = (max - min + 1);
zuza3 = zuza % zuza2;
rewer = zuza3 + min;
return rewer;
}

long getlongrand(long min, long max)
 {            
unsigned long rewer = 0, rest, minimum = 0, zuza;
unsigned int bereich, limit = 32767, maxbereichsfeld, minbereichsfeld;
  
 maxbereichsfeld = (unsigned int)(max / 32767);
 minbereichsfeld = (unsigned int)(min / 32767);
  
 bereich = getrandom(minbereichsfeld, maxbereichsfeld);
 
 minimum = min;
 if (bereich >= 1) minimum = (unsigned long)(32767 * bereich);
 rest = max - minimum;
 
 if (rest < 32767) limit = (unsigned int)rest;
 zuza = (unsigned long)getrandom(0, limit);
 
 rewer = minimum + zuza;
 
 return((long)rewer);
 }

#define random(max ) getrandom(0, max)

void RANDOMIZE(void)
{
long bwer;
srand( (unsigned)(time(&bwer) % 20));
if (randinitcount < 2)
 randinitcount++;
}

/* Rückgabewert ist der tatsächlich verwendete Wertebereich (Parameter 2)
 * Aufruf Parameter 1: &Arrayname  */

int setranval(unsigned int (*wert)[300], int wertebereich)
{
int maxi = 255;  /* Legt den Arbeitsbereich von 0 bis 255 fest */
int slei, a, sleia,  zuze, maxgre, szahl, zahl, fiwer[300], zuza[300];
if ((wertebereich <= 255) && (wertebereich >1))
 maxi = wertebereich;
zuze = 0;
maxgre = maxi;
/* Initialisieren des Arrays "fiwer" mit Werten von 0 bis 255 */
for (slei = 0; slei <= maxi; slei++)
 fiwer[slei] = slei;
/* Aufruf von RANDOMIZE nur einmal bei Programmablauf, sonst
 * kommen pro "Würfelrunde" immer nur die gleichen Zahlen  */
if (randinitcount == 0)
 {
 RANDOMIZE();
 randinitcount++;
 }
for (a = 0; a <= maxgre; a++)
{
  szahl =  getrandom( 0, maxi);   /* generiert Zufallszahl "szahl" von 0 bis maxi  */ 
  zahl = fiwer[szahl];

   for (sleia = 0; sleia <= maxi; sleia++)
	if (fiwer[sleia] == zahl)
	{
	  --maxi;
	  for (slei = sleia; slei <= maxi; slei++)
	   fiwer[slei] = fiwer[slei + 1];
	   zuza[zuze] = zahl;
	  ++zuze;
	 }
}

/* Übertrag der Werte des lokalen Arrays zuza in das Array wert */
for (slei = 0; slei <= maxgre; slei++)
(*wert)[slei] = zuza[slei];

return(maxgre);
}

/* Ueberprueft ob die Permutationsreihe fehlerfrei ist.
 * Aufruf: Differenz_bei_Fehler =  TellyDec(long_huge_array, Arraygroesse, &Pruefsumme), &Istwert);
 *
 */
long TellyDec(long huge wert[], long grenze, long (*quersumme), long (*tstwrt) )
{
long slei, rewer = 0;
(*tstwrt) = (*quersumme) = 0;

for (slei = 0; slei < grenze; slei++)
 {
  (*quersumme) += slei;     /*printf("\nquersumme%ld tstwert[slei]%ld", quersumme, tstwrt);*/
  (*tstwrt)    += wert[slei];  /*printf("\ntstwrt%ld wert[slei]%ld", tstwrt, wert[slei]); */
 }

rewer = (*quersumme) - (*tstwrt);

return(rewer);         
}

/* Im Gegensatz zu WORD-Variante muss die DWORD-Variante mit nur 2 Arrays
 * auskommen. Diese muessen  von Aussen erst mit "halloc" Allokiert werden.
 * Parameter eins ist dabei das Array, indem das Ergebnis nach abarbeiten
 * der Funktion stehen soll. Parameter 2 ist dabei das Hilfsarray.
 * Die Groesse der Arrays muß explizit in Parameter 3 angeben werden 
 * Aufruf: Arraygroesse-1 =  SetRanValNoLimit(ErgebnisArray, Hilfsarray, Groesse_der_einzelnen_Arrays )
 */

long SetRanValNoLimit (long huge wert[], long huge zuza[], long arraygroesse)
{
long rewer = 0;
long maxi = arraygroesse - 1;  /* Legt den Arbeitsbereich von 0 bis 255 fest */
long keylength = arraygroesse;
long slei, a, sleia,  zuze, szahl, zahl; 

/* Initialisieren des Arrays "fiwer" mit Werten von 0 bis arraygroesse */
for (slei = 0; slei <= keylength; slei++) 
 {
  wert[slei] = slei;
  zuza[slei]  = 0;
 }
/*folgende printf-Anweisung wurde nur zu Testzwecken implementiert: 
  printf("initial erreicht");  
  dessen Entfernung nach dem Test wurde vergessen, so 
  das bem Linken der Windows-Applipikation der Laufzeitfehler
  L2029 (= unresolved external) hervorgerufen wurde ein vermeiden mit
  anderen Linkereinstellungen ist erfolglos, da dir printf-Anweisung nur 
  für MSDOS-Applipikationen verwendet werden darf, nicht für
  Windows-Programme.
 * 
 * Aufruf von RANDOMIZE nur einmal bei Programmablauf, sonst
 * kommen pro "Würfelrunde" immer nur die gleichen Zahlen  */

if (randinitcount == 0)
 {
 RANDOMIZE();
 randinitcount++;
 }

zuze = 0;

for (a = 0; a < keylength; a++)
{
  szahl = getlongrand(0, maxi);  /* generiert Zufallszahl "szahl" von 0 bis maxi  */ 
  zahl  = wert[szahl];           /* liest Wert von Variable wert[szahl] */

   for (sleia = 0; sleia <= maxi; sleia++)
	if (wert[sleia] == zahl)
	 { /* suche gefundenen Wert in Array wert[], wenn gefunden aus Liste streichen
	    * und in Array zuze uebertragen, dann Arraygroesse von Wert[] um eins kuerzen  */
	  for (slei = sleia; slei <= maxi; slei++)
	     wert[slei] = wert[slei + 1];
	  zuza[zuze] = zahl;
	  ++zuze;
	  if (maxi >= 0) --maxi; /* solange Arraygroesse von wert[]-Array > 0 dekrementieren */
	  if (maxi < 0) goto fertig;  /*wenn alle Werte uebertragen (erst bei maxi <0 der Fall) Ende */
	 
	 }
}

/* Übertrag der Werte des lokalen Arrays zuza in das Array wert */
fertig: for (slei = 0; slei < keylength; slei++)
        wert[slei] = zuza[slei];
        rewer = keylength - 1;
        if (rewer == 0) hfree(zuza);
         
return(rewer);
}

#endif
/* End of Header */










#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <random.h>


void main(void)
{
int slei, differenz, laenge, rechenart, schluesseloffset, reihenfolge[600];
char quelltext[200], nachrichtentext[200], schluessel[600];
/* einlesen der Quelltextpassagen (1 + 2)*/
printf("\nBitte Quelltext eingeben(bis 180 Zeichen): ");
scanf("%[^\n]", quelltext);
oldclpuf();
/* einlesen des zu codierenden Textes */
printf("\nBitte Nachrichtentext eingeben(bis 180 Zeichen): ");
scanf("%[^\n]", nachrichtentext);
/* Nachrichtenlaenge ermitteln */
laenge = strlen(nachrichtentext);
schluesseloffset = 0;
printf("\nNachrichtenlaenge: %d", laenge);
/* Zufallsreihenfolge von Integerzahlen generieren: (4)
 verwendung noch nicht im Beispiel Integriert*/
RANDOMIZE();
for (slei = 0; slei < laenge; slei++)
 reihenfolge[slei] = getrandom( 0, laenge);
for (slei = 0; slei < laenge; slei++)
 {
 /* Position 5*/
 differenz = nachrichtentext[slei] - quelltext[slei];
 if (differenz == 0) rechenart = 0;
 if (differenz > 0) rechenart = 1;
 if (differenz < 0) rechenart = 2;
 /* Position 6*/
 schluessel[schluesseloffset] = slei;
 schluessel[schluesseloffset + 1] = rechenart;
 schluessel[schluesseloffset + 2] = differenz;
 schluesseloffset += 3;
 }
printf("\nCode-Schluessel: ");
for (slei = 0; slei < (laenge * 3); slei += 3)
 printf("- %d, %d, %d -", schluessel[slei], schluessel[slei + 1], schluessel[slei + 2]); 
}

1. = Nachricht - Quelle = +Differenz; (Positive Rationale Zahl als Wert der Variable)
2. = Nachricht - Quelle = -Differenz; (negative Rationale Zahl als Wert der Variable)
   Positionserrechnung der Rechenelemente(Codeletter, Rechenart, Zusatzwert)
   Byte: 0 1 2 3 4
   0 1 2 | 3 4 5 | 6 7 8 | 9 10 11 | 12 13 14
   13=3 2*3=6 3*3=9 4*3=12
   Der eigentliche Schwachpunkt ist das Differenzbyte der Bytegruppen welche in Form von Ternen angewandt werden.
   Dies kann nur durch eine zusätzliche Einbringung eines Codewortes in die Verschlüsselung
   revidiert werden.
   Bytefolge des Codeworts: 012345

Mach mit!