eine Variable bei jedem Durchlauf ändern, aber immer anders?

[malo]

Und zwar will ich in meinem Verschlüsselungsprogramm die ASCII-Codes verändern und anzeigen (das ist dann meine "Verschlüsselung"). Nun will ich aber keine regelmäßige Veränderung des ASCII-Codes haben, sondern immer eine neue Veränderung.

Und zwar benutze ich für die Verschlüsselung eine For-Schleife, mit der ich jedes Zeichen durchgehe, den ASCII-Code herausfinde und diesen ändere. Das klappt auch wunderbar. Aber, da ich ja eine "unregelmäßige" Veränderung haben will, dacht ich mir, dass ich innerhalb dieser Schleife die Variable, die meinen ASCII-Code ändert, ändere.

Da hatte ich auch ein paar Ideen, zu denen alle Probleme auftraten.

:arrow: die Durchlaufvariable der For-Schleife abfragen und per Case-Anweisung die Änderungsvariable ändern --> Problem: ich kann ja keine "unendlichen"-Caseanweisungen schreiben, sondern muss irgendwo eine Art Limit haben. Und da ich ja nicht weiß, wie lang die Strings werden, die verschlüsselt werden sollen, kann ich ja nicht ewig weitermachen, case-Abfragen zu schreiben ;)


:arrow: Innerhalb der For-Schleife eine andere Variable hochzählen und abfragen, irgendwann dann die Variable zurücksetzen und weiter machen --> Problem: Entweder bekomme ich einen ASCII-Code raus, der bis ins 6-Stellige hereingeht, oder die Änderungsvariable wird gar nicht zum ASCII-Code dazuaddiert.



Naja, das sind die einzigen zwei Möglichkeiten, die halbwegs in Frage kämen, aber es funktionieren halt beide nicht richtig. Hat jemand eine Ahnung, wie ich die Probleme löse, bzw. hat jemand eine andere Idee, wie ich die Variable regelmäßig ändern kann?


Danke schonmal!

[Binärbaum]

Man könnte es so probieren:

Delphi-Quellcode:

var
 mein_text: string;//Original
 neuer_Text: string;//Verschlüsselt

...

neuer_text:=mein_Text; //Verschlüsselter Text initialisieren
for i:= 1 to Length(mein_Text) do begin
 neuer_Text[i]:= Chr(Ord(mei_text[i])+ (i mod 25));
end;

Damit würde die "Änderung" sich nur alle 25 Zeichen wiederholen.

MfG
Binärbaum
//Edit: Quelltext korrigiert

[Niels]

Zitat:

Zitat von malo

:arrow: die Durchlaufvariable der For-Schleife abfragen und per Case-Anweisung die Änderungsvariable ändern --> Problem: ich kann ja keine "unendlichen"-Caseanweisungen schreiben, sondern muss irgendwo eine Art Limit haben. Und da ich ja nicht weiß, wie lang die Strings werden, die verschlüsselt werden sollen, kann ich ja nicht ewig weitermachen, case-Abfragen zu schreiben ;)

Die Case-Anweisung würde ich so ungefähr gestalten:

Delphi-Quellcode:

case (variable mod 7) of
0: machwas;
1: machwas;
...
6: machwas;
end;

Anstatt der 7 nimmst du halt die Anzahl der Variationen, die du willst. Ich find die Variante der Verschlüsselung aber viel zu einfach zu knacken. Beschäftige dich mal mit Matritzen-Verschlüsselung, da braucht man schon sehr lange Texte um Regelmäßigkeiten zu erkennen.

Zitat:

Zitat von malo

:arrow: Innerhalb der For-Schleife eine andere Variable hochzählen und abfragen, irgendwann dann die Variable zurücksetzen und weiter machen --> Problem: Entweder bekomme ich einen ASCII-Code raus, der bis ins 6-Stellige hereingeht, oder die Änderungsvariable wird gar nicht zum ASCII-Code dazuaddiert.

Sollte eigentlich funktionieren, hast sicher nen Fehler im Code, musste mal nen Ausschnitt posten

MfG Niels

[edit]Fehler im Quote-Tag[/edit]

[malo]

@Binärbaum: Aber da wär mir die Änderung wieder etwas zu regelmäßig. Ich will jedes Mal eine komplett neue Änderung haben. Also z.B. beim ersten mal +5, beim 2. mal +77, beim 3. Mal +88, beim 4. mal +2, beim 5. mal -20 oder sowas... nur halt bei jedem Zeichen!

@Niels:

Meine Case-Anweisung sieht so aus:

Delphi-Quellcode:

      case AenderungsZaehler of
        1: Aenderung := Aenderung + 7;
        2: Aenderung := Aenderung + 4;
        3: Aenderung := Aenderung + 9;
        4: Aenderung := Aenderung + 61;
        5: Aenderung := Aenderung - 70;
        6: Aenderung := Aenderung + 21;
        7: Aenderung := Aenderung + 1;
        8: Aenderung := Aenderung + 11;
        9: Aenderung := Aenderung - 20;
        10: Aenderung := Aenderung + 71;
        11: Aenderung := Aenderung + 22;
        12: Aenderung := Aenderung - 61;
        13: Aenderung := Aenderung - 51;
      end;
      inc(AenderungsZaehler);

Der Code ist innerhalb meiner Verschlüsselungsschleife ;)

Wenn ich da jetzt "a" (ohne "...") verschlüsseln will, kommt das hier raus:

Code:

1243145

//edit: wegen "leicht zu knacken": Ich versuch ja erstmal etwas einfaches zu machen, zum lernen. Das soll jetzt keine perfekte unknackbare verschlüsselung werden, das kann ich eh nicht :stupid:

[Binärbaum]

Dann könnte man es mit Zufallszahlen probieren:

Delphi-Quellcode:

var
 mein_text: string;//Original
 neuer_Text: string;//Verschlüsselt
 keycode: array[0..24] of Byte;//Schlüsselwerte

...

//Zufallszahlen erzeugen
Randomize;
for i:= 0 to 24 do
 keycode[i]:= random(256);

neuer_text:=mein_Text; //Verschlüsselter Text initialisieren
for i:= 1 to Length(mein_Text) do begin
 neuer_Text[i]:= Chr(Ord(mei_text[i])+ keycode[i mod 25]);
end;

Damit würde die "Änderung" sich zwar auch alle 25 Zeichen wiederholen, aber wäre nicht so regelmäßig.
Allerdings müsste man hier die Schlüsselwerte in keycode irgendwo abspeichern, um den Text wieder entschlüsseln zu können.

MfG
Binärbaum

[malo]

Zufallszahlen sind nicht gut, ich will ja später einen beliebigen verschlüsselten Text auch wieder entschlüsseln können ;)

[Niels]

Zitat:

Zitat von malo

Meine Case-Anweisung sieht so aus:

Delphi-Quellcode:

      case AenderungsZaehler of
        1: Aenderung := Aenderung + 7;
        2: Aenderung := Aenderung + 4;
        3: Aenderung := Aenderung + 9;
        4: Aenderung := Aenderung + 61;
        5: Aenderung := Aenderung - 70;
        6: Aenderung := Aenderung + 21;
        7: Aenderung := Aenderung + 1;
        8: Aenderung := Aenderung + 11;
        9: Aenderung := Aenderung - 20;
        10: Aenderung := Aenderung + 71;
        11: Aenderung := Aenderung + 22;
        12: Aenderung := Aenderung - 61;
        13: Aenderung := Aenderung - 51;
      end;
      inc(AenderungsZaehler);

Der Code ist innerhalb meiner Verschlüsselungsschleife ;)

Wenn ich da jetzt "a" (ohne "...") verschlüsseln will, kommt das hier raus:

Code:

1243145

Damit kann ich leider nicht viel anfangen, da ich ja nicht weiß, wie sich die Variable Änderung auf die Veränderung des ASCII-Symbols auswirkt. Aber die Summer der Veränderungen der Variable Aenderung (komischer Satz) sollte 0 und nicht 5 sein, sonst wird Aenderung langsam aber sicher größer, und erreicht bei längeren Texten dann eben auch den 6-stelligen Bereich.

MfG Niels

[malo]

Ich zähle die Variable "Aenderung" einfach nur zu dem ASCII-Code dazu. Also nix groß mit Rechnerei.

Und dein komischer Satz ist echt komisch, den kapier ich nämlich nicht :gruebel:

[Binärbaum]

Dann musst du die Zufallszahlen halt seperat speichern und beim Entschlüsseln wieder einlesen. Da das allerdings ein Sicherheitsrisiko darstellt, könnte man auch eine kleine Änderung vornehmen:
Im obigen Quelltext müsste man Randomize durch RandomSeed (oder so ähnlich heißt es) ersetzen und dann immer den selben Wert zuweisen. Damit bräuchte man die Zahlen nicht speichern, weil der Zufallsgenerator somit stets die gleichen Zufallszahlen erzeugt. Natürlich muss man dann den Startwert von RandomSeed geheimhalten.

MfG
Binärbaum

[Niels]

Zitat:

Zitat von malo

Und dein komischer Satz ist echt komisch, den kapier ich nämlich nicht :gruebel:

Ok, da is auch n Rechtschreibfehler drin gewesen :)

Ich hab nur gemeint, dass deine Variable Aenderung immer größer wird. Du addierst zwar dazu und ziehst auch wieder ab, aber was du abziehst ist weniger, als das was du dazu addierst.

MfG Niels

[malo]

Zitat:

Zitat von Niels

Zitat:

Zitat von malo

Und dein komischer Satz ist echt komisch, den kapier ich nämlich nicht :gruebel:

Ok, da is auch n Rechtschreibfehler drin gewesen :)

Ich hab nur gemeint, dass deine Variable Aenderung immer größer wird. Du addierst zwar dazu und ziehst auch wieder ab, aber was du abziehst ist weniger, als das was du dazu addierst.

MfG Niels

Achso. Ja, das war eigentlich auch beabsichtigt, weil ich ja hinterher auch mal die ganzen Case-Anweisungen wiederholen wollte und keine Regelmäßigkeiten wollte. Wenn nun zuerst bei 0 gestartet wird und später bei 5 ist es schwieriger, den Code "von Hand" zu entschlüsseln, weil halt keine Regelmäßigkeiten auftreten :)

//edit: aber ich hab ja nur ein "a" entschlüsseln wollen, und da kommt direkt ein 7-Stelliger Code :wall:

[Niels]

Naja du sagtest, dass es kein unknackbares Verfahren werden soll, andererseits willst du es doch möglichst sicher.
Sobald jemand weiß, wie dein Verfahren funktioniert und das sollte ja jeder, der es benutzt, ist diese Verschiebung sowieso kein Hindernis mehr beim knacken. und diese Verschiebung um 5 ist ja auch wieder eine Regelmäßigkeit, weil es ja immer 5 mehr werden :).

Zu deinem a:
setzt du am Anfang Aenderungszaehler und Aenderung auf 0? Sonst haben die zufällige Werte (naja nicht ganz zufällig, aber halt das was an der Adresse, wo sie hinzeigen grad im RAM steht)!

MfG Niels

[malo]

Zitat:

Zitat von Niels

Zu deinem a:
setzt du am Anfang Aenderungszaehler und Aenderung auf 0? Sonst haben die zufällige Werte (naja nicht ganz zufällig, aber halt das was an der Adresse, wo sie hinzeigen grad im RAM steht)!

AenderungsZahler hab ich auf 0 gesetzt, Aenderung nicht, weil es ja eine lokale Variable ist. Und ich dachte halt, integer-Variablen ohne Wert sind immer 0 :wall:


Aber funktioniert das sogar, danke! :mrgreen:

//edit: Wegen Sicherheit: Ja, ich versuche halt das System, was ich mir "ausgetüftelt" habe, möglichst sicher zu machen. Ich werde aber (jedenfalls in absehbarer Zeit) kein neues System programmieren, auch wenn das sicherer ist ;)

[SirThornberry]

Zitat:

Zitat von Binärbaum

Man könnte es so probieren:

Delphi-Quellcode:

var
 mein_text: string;//Original
 neuer_Text: string;//Verschlüsselt

...

neuer_text:=mein_Text; //Verschlüsselter Text initialisieren
for i:= 1 to Length(mein_Text) do begin
 neuer_Text[i]:= Chr(Ord(mei_text[i])+ (i mod 25));
end;

Hallo??? :? So kannst du den verschlüsselten Text schon fast in den Müll werfen. :wink: angeommen mein Zeichen hat den Ascii-Wert 254 und i ist 3, dann würde bei würde bei der "254 + 3" gerechnet werden was "257" ergibt. Und wenn du das mit "chr" wieder zurück schreibst kommt was falches raus weil es kein ascii-wert "257" gibt. Auf grund eines Überlaufes würd vermutlich dann der Ascii-Wert "1" sein und nicht wie es laut berechnung sein müsste "257"

[Niels]

Zitat:

Zitat von SirThornberry

Zitat:

Zitat von Binärbaum

Man könnte es so probieren:

Delphi-Quellcode:

var
 mein_text: string;//Original
 neuer_Text: string;//Verschlüsselt

...

neuer_text:=mein_Text; //Verschlüsselter Text initialisieren
for i:= 1 to Length(mein_Text) do begin
 neuer_Text[i]:= Chr(Ord(mei_text[i])+ (i mod 25));
end;

Hallo??? :? So kannst du den verschlüsselten Text schon fast in den Müll werfen. :wink: angeommen mein Zeichen hat den Ascii-Wert 254 und i ist 3, dann würde bei würde bei der "254 + 3" gerechnet werden was "257" ergibt. Und wenn du das mit "chr" wieder zurück schreibst kommt was falches raus weil es kein ascii-wert "257" gibt. Auf grund eines Überlaufes würd vermutlich dann der Ascii-Wert "1" sein und nicht wie es laut berechnung sein müsste "257"

Da die ersten 32 ASCII-Zeichen Steuerzeichen sind, würde ich einfach '- (i mod 25)' anstatt '+ (i mod 25)' nehmen. Damit bekommst du keine Probleme. Wenn du natürlich mehr als i mod 32 hast, wird's dann problematisch, da müsste man dann was ändern.

[SirThornberry]

@niels: So würde es natürlich für einfache Texte funktionieren. Aber meist ist es so das der Programmierer, nach dem es mit einfachtem Text funktioniert, das ganze mit allen möglichen Datein versucht zum Beispiel mit bildern um diese zu verschlüsslen. Und spätestens das funktioniert das ganze dann irgendwann wieder nicht weil auch zeichen mit Ascii-Wert < 32 verwendet werden.

[Binärbaum]

@Niels, @Thornberry:
So kann man es natürlich auh machen. Ich bin allerdings davon ausgegangen, dass die Bereichsüberprüfung ausgeschaltet ist (per Compileroption bzw. Präprozessor). Dann würde man einfach wieder bei 0 anfangen, wenn man den zulässigen Bereich verlässt. Da ein Byte ja nur von 0-255 geht, würde ein Ordinalwert von 257 dann wieder als 2 interpretiert und man hätte keine Probleme (abgesehen davon, dass man dann in den Steuerzeichen ist).

MfG
Binärbaum

[SirThornberry]

257 als 2?
Ich hätte gedacht als 1 weil es ja bei 0 wieder los geht.
Also 255 + 1 = 256/0
und 256 + 1 = 257/1

[Binärbaum]

Ja klar, war mein Fehler. :wall:
Natürlich ist die 257 dann eine 1 und keine 2. Aber das spielt ja kaum eine Rolle, Hauptsache das Programm kommt damit zurecht. :wink: Selbst wenn es eine 2 wäre, würde es durchs Entschlüsseln wieder auf die richtige zahl und das richtige Zeichen kommen.

MfG
Binärbaum