ganz einfache Verschlüsselung von einem Memo Text

[Penelopee]

Ich habe in einem Memo einen Text geladen und möchte wenn ich auf den Button verschlüssele klicke , dass sich alle Buchstaben um eine Stelle Verschieben , also Cäsar Verchlüsselung.Muss ich dazu alle Buchstaben speichern und dann einfach a:=b setzen oder wie mache ich das am besten???
Vielen Dank im Vorraus!

[PierreB]

Cäsar Verschlüsselung hatten wir schon ein paar Mal, einfach mal die Forensuche bemühen. ;)

[Penelopee]

ja ich habs gesehen.Aber da sind so lange quellcodes und das ist viel zum kompliziert.Ich möchte einen Text , der aus 2 Worten besteht:'Hallo du' , möchte ich verschlüsseln.

[DP-Maintenance]

Dieses Thema wurde von "Sharky" von "Multimedia" nach "Sonstige Fragen zu Delphi" verschoben.
Ist irgendwie keine Multimedia frage ;-)

[Maximus]

Es gibt viele verschiedene Wege so eine Verschlüsselung umzusetzen ...

Eine Möglichkeit ist z.b. dass du ein Schlüssel nimmst, den aktuellen Buchstaben suchst und dann durch den nächsten ersetzt

Delphi-Quellcode:

function Verschluessle(Text: String) : String;

const
 Key = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ';

{ ... }

function Verschluessle(Text: String) : String;
var i,j: Integer;
begin
 Result := ''; //Ergebniss zurücksetzen

 for i := 1 to length(Text) do //Jeden Buchstaben des Textes durchgehen
 begin
   for j := 1 to 27 do //Jeden Buchstaben des Schlüssels durchgehen
   begin
     if Text[i] = Key[j] then //Sobald der Buchststabe gefunden ist
      Result := Result + Key[j+1]; //Den nächsten Buchstaben des Schlüssels hinzufügen
   end;
 end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
 Memo1.Lines.Text := Verschluessle(Memo1.Lines.Text); //Möglicher ausruf der Funktion
end;

Natürlich funktioniert dies nur mit Großbuchstaben, aber ich denke du wirst hier auch ganz leicht Kleinbuchstaben implementieren können, und noch diverse Bugs behebn können. (Eigeninitiative)

MFG
Maximus

[Penelopee]

Hier ist nochmal mein Quelltext:

Delphi-Quellcode:

var
  Form1: TForm1;
  Text:string;

implementation

{$R *.dfm}

procedure TForm1.FormActivate(Sender: TObject);
begin
Text:='Wer diesen Text verschlüsseln kann ist gut';
Memo1.Lines.Text:=Text;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
Memo1.Clear;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin

end;

end.

Ich möchte jetzt diesen Text ganz einfach verschlüsseln.Brauche ich dafür eine Funktion oder geht das auch ohne??

[ichbins]

Probier mal das:

Delphi-Quellcode:

procedure encode(key:integer);
var
  i,j,k,pos:integer;
  s:string;
  done:tpoint;
const
  letters:string='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ßöäüÖÄÜ'; //diese Buchstabenliste kann beliebig erweitert werden.
begin
  for i:=0 to form1.memo1.lines.Count-1 do
    for j:=1 to length(form1.memo1.lines.Strings[i]) do
      for k:=1 to length(letters) do
        if byte(form1.memo1.lines.Strings[i][j])=byte(letters[k]) then
        begin
          if not ((done.x=i) and (done.y=j)) then
          begin
            pos:=k+key;
            while pos>length(letters) do
              pos:=pos-length(letters);
            while pos<1 do
              pos:=pos+length(letters);
            s:=form1.memo1.lines.strings[i];
            s[j]:=letters[pos];
            form1.memo1.lines.Strings[i]:=s;
            done.X:=i;
            done.Y:=j;
          end;
        end;
end;

[Penelopee]

das funktionirt irgendwie nicht , danke für die mühe!!!!

[3_of_8]

Mal ne ganz einfache Möglichkeit:

Verschlüsseln:

Delphi-Quellcode:

function encodestr(Str: String; Key: Byte): String;
var I: Cardinal;
begin
Result:=Str;
for I:=1 to length(Result) do
Result[I]:=Chr(Ord(Result[I]) xor Key);
end;

Zum Entschlüsseln eines Strings die Funktion encodestr einfach noch einmal anwenden, das ganze ist umkehrbar.

Die "Cäsarverschlüsselung" ist auch ganz einfach:

Delphi-Quellcode:

function encodestr(Str: String): String;
var I: Cardinal;
begin
Result:=Str;
for I:=1 to length(Result) do
Result[I]:=Chr(Ord(Result[I])+1);
end;


function decodestr(Str: String): String;
var I: Cardinal;
begin
Result:=Str;
for I:=1 to length(Result) do
Result[I]:=Chr(Ord(Result[I])-1);
end;

[Ultimator]

Delphi-Quellcode:

function encodestr(Str: String; Key: Byte): string; 
var I: Cardinal; 
begin 
  Result:=Str; 
  for I:=1 to length(Str) do 
   Result[I]:=Chr(Ord(Result[I] xor Key); 
end;

Du hast vergessen, den Typ des Result anzugeben ;)

[ichbins]

@3/8: das ist aber keine Cäsar-Verschlüsselung.

@penelopee: was funktioniert nicht? bei mir geht das Super... :gruebel:

[3_of_8]

@ichbins: Das zweite schon. Also aus 'abcde' wird 'bcdef'. Das ist doch eine Cäsar-Verschlüsselung, oder? (Mir persönlich wäre das etwas zu einfach zu knacken.)

[marabu]

Hallo Penelopee,

das mit der Caesar-Chiffre ist nicht so einfach. Das Original hatte ein Standardalphabet von nur 20 Buchstaben und keine Großschrift. Eigentlich reden wir von der einfachen monozyklischen Substitution, für die Caesars Chiffre lediglich ein früher historischer Beleg ist. Julius hat das auch nicht selbst erfunden, sondern bei Sueton geklaut, aber ist schon verjährt. Hier hast du ein bischen Code:

Delphi-Quellcode:

function Cypher(const s: string; power: integer): string;
var
  i: integer;
begin
  Result := s;
  if power < 0 then
    power := (power + 224 * Succ((power div -224))) mod 224;
  if power > 0 then
    for i := 1 to Length(s) do
      if s[i] > #31 then
        Result[i] := Chr((Ord(s[i]) - 32 + power) mod 224 + 32)
end;

Testen kannst du mit zwei Buttons und einem Memo:

Delphi-Quellcode:

const
  PowerOfCesar = 3;

procedure TDemoForm.btnEncodeClick(Sender: TObject);
begin
  Memo.Lines.Text := Cypher(Memo.Lines.Text, PowerOfCesar);
end;

procedure TDemoForm.btnDecodeClick(Sender: TObject);
begin
  Memo.Lines.Text := Cypher(Memo.Lines.Text, - PowerOfCesar);
end;

Grüße vom marabu

[Penelopee]

kann mir mal bitte einer diesen Quellcode erklären:

Delphi-Quellcode:

procedure encode(key:integer);
var
  i,j,k,pos:integer;
  s:string;
  done:tpoint;
const
letters:string='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ßöäüÖÄÜ,.;-_+*~#''?\=}][{&%$³²$§"°^<>|µ€@';
begin
for i:=0 to form1.memo1.lines.Count do
      for j:=1 to length(form1.memo1.lines.Strings[i]) do
      for k:=1 to length(letters) do
        if byte(form1.memo1.lines.Strings[i][j])=byte(letters[k]) then
        begin
          if not ((done.x=i) and (done.y=j)) then
          begin
            pos:=k+key;
            while pos>length(letters) do
              pos:=pos-length(letters);
            while pos<1 do
              pos:=pos+length(letters);
            s:=form1.memo1.lines.strings[i];
            s[j]:=letters[pos];
            form1.memo1.lines.Strings[i]:=s;
            done.X:=i;
            done.Y:=j;
          end;
        end;

Also meine fragen:bei Count werden die Buchstaben gezählt oder??Und was macht "length"??
Was macht der Befehl "done.X:=i;"???

Vielen Dank!!

[Penelopee]

Jetzt funktioniert es!!
Aber wie baue ich Leerzeichen ein???Wenn ich einen Text decode , soll zwischen den Worten Leerzeichen sein!!

Delphi-Quellcode:

const
Key = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ';


implementation
{$R *.dfm}

function Verschluessle(Text: String) : String;



begin

for i := 1 to length(Text) do begin

for j := 1 to 64 do begin

if Text[i] = Key[j] then

Result := Result+Key[j+x];

end;
end;
end;




function Entschluessle(Text: String) : String;

begin

for i := 1 to length(Text) do begin

for j := 1 to 64 do begin

if Text[i] = Key[j] then

Result := Result+Key[j-x];

end;
end;
end;




procedure TForm1.BverschluesselnClick(Sender: TObject);
begin
Memo1.Lines.Text := Verschluessle(Memo1.Lines.Text);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
x:=5;
end;

procedure TForm1.BentschluesselnClick(Sender: TObject);
begin
Memo1.Lines.Text := Entschluessle(Memo1.Lines.Text);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
Memo1.Lines.LoadFromFile('Text.txt');
end;

end.

[Sharky]

Zitat:

Zitat von Penelopee

Jet...soll zwischen den Worten Leerzeichen sein!! ...

Das ist keine gute Idee! Wenn ich weiss wo ein Wort anfängt und wieder aufhört hat man mit etwas glück deinen "Cäsar" schnell geknackt.

BTW: Du solltest deinen Sourcecode "besser" formatieren. So wie er ist, ist er recht schlecht zu lesen ;-)


EDIT

Und noch etwas.

Überlege mal was in dieser Zeile passiert

Delphi-Quellcode:

Result := Result+Key[j+x];

wenn: (j + x) > als Length(Key) ist.

[marabu]

Hi Sharky,

ob mit oder ohne white space - bei der monozyklischen Substitution wird die Hürde für eine erfolgreiche Dechiffrierung nicht wesentlich erhöht:

Delphi-Quellcode:

function Cypher(const s: string; power: integer): string;
var
  i: integer;
begin
  Result := s;
  if power < 0 then
    power := (power + 223 * Succ((power div -223))) mod 223;
  if power > 0 then
    for i := 1 to Length(s) do
      if s[i] > #32 then
        Result[i] := Chr((Ord(s[i]) - 33 + power) mod 223 + 33)
end;

Auch unter einfachsten Randbedingungen sollte man mindestens eine polyzyklische Variante verwenden und Korrekturmaßnahmen zur Verschleierung der Häufigkeitsverteilung ergreifen. Und bei der heutigen Rechenleistung reden wir dann immer noch über Kinderkram...

Grüße vom marabu

[St.Pauli]

Zitat:

Zitat von Sharky

Überlege mal was in dieser Zeile passiert

Delphi-Quellcode:

Result := Result+Key[j+x];

wenn: (j + x) > als Length(Key) ist.

Das ist das eine...

Delphi-Quellcode:

letters:string='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890ßöäüÖÄÜ'; 
//diese Buchstabenliste kann beliebig erweitert werden.

Das Problem ist, dass z mit A verschlüsselt wird, aber nach Caesar mit a ersetzt werden müsste. Z wird zu 1, sollte aber A werden und Ü wird, wie du gesagt hast, ja einen Fehler ergeben.

Zitat:

Zitat von marabu

Ich bin sicher, dass ein nicht-wissenschaftlicher Umgang mit diesem Thema hier angebracht ist, aber auch da liebe ich Genauigkeit. Die Substitution von z mit A hat nicht viel mit der Verschlüsselung nach Caesar gemein. Das damalige Standardalphabet umfasste 20 Lettern, Groß oder Kleinschrift und auch white space waren kein Thema und Ziffern waren im Zeichenvorrat bereits eingeschlossen. Jede moderne Adaption des historisch belegten Verfahrens verdient eigentlich den Namen nicht mehr. Die im Zitat geforderte Verschlüsselung ist trivial polyzyklisch (3 Ringe), arbeitet aber mit der Potenz 1, die von Augustus, dem Erben des Gaius Julius verwendet wurde. Prof. Bauer mutmaßte, dass jener nicht bis 3 zählen konnte - 3 war die von Gaius Julius bevorzugte Potenz.

Zitat:

Zitat von marabu

Auch unter einfachsten Randbedingungen sollte man mindestens eine polyzyklische Variante verwenden und Korrekturmaßnahmen zur Verschleierung der Häufigkeitsverteilung ergreifen. Und bei der heutigen Rechenleistung reden wir dann immer noch über Kinderkram.

Das stimmt, aber ich glaube nicht, dass jemand seine Bankdaten mit Caesar verschlüsseln will, sondern das solche Verschlüsselungen immer nur als kleine Spielereien genutzt werden.
Und zu den Korrekturmaßnamen würde ich mal homophone Substitution vorschlagen, was natürlich auch nicht zum Verschlüsseln von Bankdaten einlädt, aber im Gegensatz zu der Caesar-Chiffre doch dem Angreifer eine Hürden in den Weg legt.

[Maximus]

Hallo,

Da mich das jetzt doch brennend interessiert hat, hab ich jetzt meine Version nochmals überarbeitet und einige Kleingkeiten, die in diesem Thread angesprochen wurden beseitigt.

Delphi-Quellcode:

function Verschluessle(Text: String) : String;

var
 Key: array[1..3] of String = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz', '0123456789');

{ ... }

function Verschluessle(Text: String) : String;
var i, j, k: Integer;
begin
 Result := ''; //Ergebniss zurücksetzen

 for i := 1 to length(Text) do //Jeden Buchstaben des Textes durchgehen
 begin
   for j := 1 to 3 do //Jeden Schlüssel durchgehen
   begin
     for k := 1 to length(Key[j]) do
     begin
       if Text[i] = Key[j][k] then
       begin
         if not (k+1 > length(Key[j])) then //Überprüfen ob man schon ebim letzten Buchstaben ist
          Result := Result + Key[j][k+1]
         else
          Result := Result + Key[j][1];
       end;
     end;
   end;
   if Text[i] = ' ' then //If Bedingung weglassen wenn man keine Leerstellen will.
    Result := Result + ' ';
 end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
 Memo1.Lines.Text := Verschluessle(Memo1.Lines.Text); //Möglicher aufruf der Funktion
end;

Gelöst hab ich das mit dem z zu A, Z zu 1, das ich 3 unterschiedliche Schlüssel nehme, bzw. für jede Gruppe ein eigenen.
Und wenn man am Ende vom der "Schlüsselgruppe" ankommt wird man einfacher wieder nach vorne gesetzt. (Stichwort: If-Abfrage) :)

[Edit1] Hups kleiner Denkfehler drin. Das mit den Leerstellen muss ich doch jetzt nocheinmal testen ..
[Edit2] So nun bleiben die Leerstellen erhalten ;) ...

MFG
Maximus

[marabu]

Hallo St. Pauli,

Zitat:

Zitat von St.Pauli

Das Problem ist, dass z mit A verschlüsselt wird, aber nach Caesar mit a ersetzt werden müsste. Z wird zu 1, sollte aber A werden und Ü wird, wie du gesagt hast, ja einen Fehler ergeben.

das ist nicht nach Caesar. Ich bin sicher, dass ein nicht-wissenschaftlicher Umgang mit diesem Thema hier angebracht ist, aber auch da liebe ich Genauigkeit. Die Substitution von z mit A hat nicht viel mit der Verschlüsselung nach Caesar gemein. Das damalige Standardalphabet umfasste 20 Lettern, Groß oder Kleinschrift und auch white space waren kein Thema und Ziffern waren im Zeichenvorrat bereits eingeschlossen. Jede moderne Adaption des historisch belegten Verfahrens verdient eigentlich den Namen nicht mehr. Die im Zitat geforderte Verschlüsselung ist trivial polyzyklisch (3 Ringe), arbeitet aber mit der Potenz 1, die von Augustus, dem Erben des Gaius Julius verwendet wurde. Prof. Bauer mutmaßte, dass jener nicht bis 3 zählen konnte - 3 war die von Gaius Julius bevorzugte Potenz.

Zitat:

Zitat von St.Pauli

Und zu den Korrekturmaßnamen würde ich mal homophone Substitution vorschlagen

Nur Interesse halber - steht sowas bei Wikipedia oder hast du Kenntnisse in Linguistik und Kryptologie? Homophonie ist zwar ein anerkanntes Verfahren zur Behinderung der stochastischen Analyse, beisst sich aber regelmäßig mit der rein funktionalen und damit deterministischen Implementierung des Verfahrens.

Freundliche Grüße vom marabu

[St.Pauli]

Zitat:

Zitat von marabu

das ist nicht nach Caesar. Ich bin sicher, dass ein nicht-wissenschaftlicher Umgang mit diesem Thema hier angebracht ist, aber auch da liebe ich Genauigkeit. Die Substitution von z mit A hat nicht viel mit der Verschlüsselung nach Caesar gemein. Das damalige Standardalphabet umfasste 20 Lettern, Groß oder Kleinschrift und auch white space waren kein Thema und Ziffern waren im Zeichenvorrat bereits eingeschlossen. Jede moderne Adaption des historisch belegten Verfahrens verdient eigentlich den Namen nicht mehr. Die im Zitat geforderte Verschlüsselung ist trivial polyzyklisch (3 Ringe), arbeitet aber mit der Potenz 1, die von Augustus, dem Erben des Gaius Julius verwendet wurde. Prof. Bauer mutmaßte, dass jener nicht bis 3 zählen konnte - 3 war die von Gaius Julius bevorzugte Potenz

Ok, dass sehe ich nach dieser Erklärung ein!!! :mrgreen:

Zitat:

Zitat von marabu

Nur Interesse halber - steht sowas bei Wikipedia

:roll:

Zitat:

Zitat von marabu

Homophonie ist zwar ein anerkanntes Verfahren zur Behinderung der stochastischen Analyse, beisst sich aber regelmäßig mit der rein funktionalen und damit deterministischen Implementierung des Verfahrens.

Welche Probleme wären das - aus reinem Interesse^^

[marabu]

Hallo St.Pauli,

Zitat:

Zitat von St.Pauli

Welche Probleme wären das

ganz einfach: Sobald du Homophone einführst und diese dann auch gleich noch maskierst, brauchst du einen nondeterministischen Operator zur Auswahl deiner Homophone - und hast dadurch keine rein funktionale Abbildung mehr. Nehmen wir den Pseudozufall zu Hilfe, dann könnte das für englische Texte und ohne Maskierungszeichen so aussehen:

Delphi-Quellcode:

function Encode(s: string): string;
var
  i, index: integer;
begin
  Result := '';
  // Schreibweise wird normiert
  s := AnsiLowercase(s);
  Randomize();
  for i := 1 to Length(s) do
  begin
    index := Pos(s[i], 'etaonirsh');
    if index > 0 then
    begin
      Result := Result + Chr(Ord('0') + index) + Chr(Ord('0') + 4 + Random(6));
      Continue;
    end;
    index := Pos(s[i], 'bcdfgjklm');
    if index > 0 then
    begin
      Result := Result + Chr(Ord('0') + index) + Chr(Ord('0') + 2 + Random(2));
      Continue;
    end;
    index := Pos(s[i], 'pquvwxyz');
    if index > 0 then
    begin
      Result := Result + Chr(Ord('0') + index) + '1';
      Continue;
    end;
    // Alle anderen Zeichen werden unterdrückt
    // Zahlen müssen also durch Zahlwörter dargestellt werden
  end;
end;

Übrigens: Die von mir gezeigte Funktion zur einfachen Substitution ist streng genommen schon polyzyklisch, da ich die ASCII Steuerzeichen und das Leerzeichen vom Gesamtalphabet ausnehme und standardmäßig mit der Potenz 0 verschlüssele - also gar nicht (Identität). Nichtsdestotrotz ist es eine funktionale und deterministische Abbildung. Deterministisch, weil für jedes Klartextzeichen das Schlüsselzeichen vorhergesagt werden kann. Zufall spielt keine Rolle.

Zitat:

Zitat von St.Pauli

aus reinem Interesse^^

Die beiden Schlusszeichen - haben die eine bestimmte Bedeutung? Ich kenne mich da nicht so aus.

@Penelopee: Ich fürchte dein thread hat sich in eine für dich ungewollte Richtung entwickelt und ich bin mit Schuld daran - bitte entschuldige, ich höre jetzt auf. Vielleicht war ja auch für dich etwas dabei.

Grüße vom marabu

[3_of_8]

Ich glaube sowas wie :wink: oder auch :mrgreen: .

[Cicaro]

Also ersteinmal - weil es doch mit Leer- und Sonderzeichen gemacht werden soll - würde ich eine Extra-Funktion für die Caesar-Verschlüsselung definieren und mit einer case-Anweisung arbeiten.

Delphi-Quellcode:

function ZeichenCaesarVerschluesselt(Ch:Char):Char;
begin
  case Ch of
    'A'..'Z','a'..'z':; // hier die Verschlüsselung
    ' '{,andere Sonderzeichen}:; // hier die Ersetzung
  end;
end;