Brauche Hilfe dringend... Verschlüsselungsproggi mit RSA

[w-a-n-n-a-b-e]

Hallo Leute.. ich bastle schon die ganzen Tage an meinem Verschlüsselungsprogramm.
Also Mein Delphi Programm ist wie folgt aufgebaut:

Ein Bereich für die Berechnung des Schlüssels

Ein KlartextMemofeld
und ein Geheimtextmemofeld.


Um nun zu verschlüsseln muss man zunächst den Klartext in Zahlen umwandeln (ord).
Dann muss man nun diese große Zahl in Blöcke unterteilen.
Die Blocklänge(m)=Blocklänge(vom Schlüssel n)-1

Nun muss man jeweils mit den einzelnen Blöcken rechnen.(siehe Rechnung)
Es werden alle einzelnen Blöcke berechnet und als Geheimtext in Geheimtext Memo eingefügt

Bisher hat alles soweit auch gut geklappt.
Habe also als test: p und q genommen und die werte 7 und 5 übergeben
Bei [groß]A folgt das Ergebnis 610 was auch richtig ist..
Wenn ich dies nun dekodiere bekomme ich den Wert 65 (ASCII Wert für A).
Auch richtig also.. Nun muss im Klartextfeld wieder A stehen statt 65..
Aber die Umwandlung funktioniert irgendwie nicht..


Doch was mir später nochmal eingefallen ist, dass ich halt das Programm immer nur mit dem Buchstaben A ausprobiert habe und keinen Satz probiert habe.. wie zb. 'Hallo wie gehts?'

Ich hab nun solange an dem Programm rumgebastelt und wurde teilweise überfüllt von Fehlern (das ist auch warum die Unit so chaotisch ist :lol: ) ... und war so verzweifelt, dass ich irgendwann nur noch stumpf auf den Bildschirm geguckt hab :shock:

Nun ja irgendwann geht einem die Geduld aus und man kann nicht mehr.. naja würd mich freuen, wenn ihr mir helfen könntet... dies sollte eigentlich bis Montag fertig sein.. und als Anlage zu meiner Facharbeit dienen.. aber ich glaub alleine schaff ich das nicht mehr..

Ich danke allen im Voraus und würd mich wirklich dolle über eure Hilfe freuen :hi:

Delphi-Quellcode:

unit mRsa;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Menus, math;

type
  TForm1 = class(TForm)
    MemoKlartext: TMemo;
    MemoGeheimtext: TMemo;
    Edp: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    Edq: TEdit;
    Berechnenbutton: TButton;
    edn: TEdit;
    Label3: TLabel;
    ede: TEdit;
    edd: TEdit;
    Label4: TLabel;
    Label5: TLabel;
    Label6: TLabel;
    Label7: TLabel;
    MainMenu1: TMainMenu;
    Klartext1: TMenuItem;
    Geheimtext1: TMenuItem;
    Schlssel1: TMenuItem;
    Beenden1: TMenuItem;
    Kodierenbutton: TButton;
    Dekodierenbutton: TButton;
    Beenden2: TMenuItem;
    Erzeugen1: TMenuItem;
    Lschen1: TMenuItem;
    Lschen2: TMenuItem;
    Kodieren1: TMenuItem;
    Kodieren2: TMenuItem;
    Hilfe1: TMenuItem;
    Anleitung1: TMenuItem;
    procedure Beenden2Click(Sender: TObject);
    procedure BerechnenbuttonClick(Sender: TObject);
    function ggt(a,b:integer):integer;
    procedure Erzeugen1Click(Sender: TObject);
    procedure KodierenbuttonClick(Sender: TObject);
    procedure Lschen1Click(Sender: TObject);
    procedure DekodierenbuttonClick(Sender: TObject);
    procedure Lschen2Click(Sender: TObject);
    procedure Kodieren1Click(Sender: TObject);
    procedure Kodieren2Click(Sender: TObject);
    procedure Anleitung1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  p,q,n,e,d,blocklaenge: integer;
  zeile,cstring:string;
implementation

{$R *.dfm}

procedure TForm1.Beenden2Click(Sender: TObject);
begin
close;
end;

procedure TForm1.BerechnenbuttonClick(Sender: TObject);
var teilerfremd,i:integer;
begin
   if TryStrToInt(edp.text, i) then
   if TryStrToInt(edq.text, i) then
   begin


p:=strtoint(edp.Text);
q:=strtoint(edq.Text);
n:=p*q;
edn.Text:=inttostr(n);
teilerfremd:=0;
e:=2;
while teilerfremd<>1
do begin
e:=e+1;
teilerfremd:=ggt(e,((p-1)*(q-1)));
if teilerfremd=1
then ede.Text:=inttostr(e);
end;
d:=e mod((p-1)*(q-1));
edd.Text:=inttostr(d);
end else begin
  showMessage('Bitte Primzahlen in die Felder p und q eingeben!');
end;
end;


function tform1.ggt(a,b:integer):integer;
var r:integer;
begin
while b > 0 do
  begin
    r := a mod b;
    a := b;
    b := r;
    result:=a;
  end;
end;


procedure TForm1.Erzeugen1Click(Sender: TObject);
begin
self.BerechnenbuttonClick(sender);
end;

procedure TForm1.KodierenbuttonClick(Sender: TObject);
var i,j,f,g,code:integer;m,c:string;
begin
delete(zeile,1,length(zeile));
memogeheimtext.Lines.clear ;
for i:=0 to memoklartext.lines.count do                 //Umwandlung in ASCII-CODE
  for j:=1 to length(memoklartext.lines[i]) do
  begin
    zeile := zeile + inttostr(ord(memoklartext.lines[i][j]));
  end;

   blocklaenge:=length(edn.Text)-1;                    //Kodierung
      repeat
     begin
  m:= Copy(zeile, 1, blocklaenge);        
  Delete(zeile, 1, blocklaenge);
  f:=strtoint(m);
  g:=strtoint(m);
  for i:=2 to strtoint(ede.Text) do              //Rechnung
  begin
  g:=g*f;
  end;
  code:=g mod strtoint(edn.Text);
  c:=concat(c,inttostr(code),' ');
     end;
   until ( zeile = '' );
   c:=concat(c,'.');
   memogeheimtext.Lines.Clear;
   memogeheimtext.Lines.add(c);

end;


procedure TForm1.Lschen1Click(Sender: TObject);
begin
memogeheimtext.Lines.Clear;
end;

procedure TForm1.DekodierenbuttonClick(Sender: TObject);
var i,j,f,g,m:integer;code,Msg:string;
begin

delete(msg,1,length(zeile));                               //Dekodierung
memoklartext.Lines.clear ;
cstring:=memogeheimtext.Lines.Text;

while not (cstring='') or not (cstring='.') or not (cstring=' ') do
  begin

    code:=copy(cstring,1,pos(' ',cstring)-1);
    delete(cstring,1,length(code)+1);
    if not (code='') then begin
    f:=strtoint(code);
    g:=strtoint(code);
    for i:=2 to strtoint(edd.Text) do
      begin
        g:=g*f;
      end;
    m:=g mod strtoint(edn.Text);
    Msg:=concat(msg,inttostr(m));
    end
    else  begin memoklartext.Lines.add(msg);exit;



             //Durch ASCII CODE in Buchstaben
delete(msg,1,length(msg));
for i:=0 to memoklartext.lines.count do
  for j:=1 to length(memoklartext.lines[i]) do
  begin
    msg := msg + char(memoklartext.lines[i][j]);
  end;

  end;
  end;


  memoklartext.Lines.Clear;
  memoklartext.Lines.add(msg)
end;



procedure TForm1.Lschen2Click(Sender: TObject);
begin
memoklartext.Lines.Clear;
end;

procedure TForm1.Kodieren1Click(Sender: TObject);
begin
self.KodierenbuttonClick(sender);
end;

procedure TForm1.Kodieren2Click(Sender: TObject);
begin
self.DekodierenbuttonClick(sender);
end;

procedure TForm1.Anleitung1Click(Sender: TObject);
begin
showmessage('Als erstes setzt man die Primzahlen p und q ein');
showmessage('Dann erzeugt man den Schlüssel mit dem Button "Schlüssel erzeugen"');
showmessage('Um nun eine Nachricht zu verschlüsseln fügt man je nach dem den Text in das Klartextfeld bzw. in das Geheimtextfeld und wählt je nach Wunsch Kodieren oder Dekodieren');
end;

end.

[Ferber]

Das glaub ich Dir gerne, dass Du dich da nicht mehr herausgesehen hast. :mrgreen:

Du solltest die Kodier- und Dekodierfunktion vom Programm trennen, am besten in eine eigene Unit.

Delphi-Quellcode:

function EnCode(aText, aKey:String): String;
function DeCode(aText, aKey:String): String;

Das implementieren, gut testen, anschliessend die Oberfläche dazu basteln.
Dann wird's gelingen :wink:

[w-a-n-n-a-b-e]

nun ja das hab ich mir später auch gedacht..

aber dachte das kostet zu viel zeit..

muss ja noch für montag mathe lk lernen :D

also ich lern ersma mathe und dann versuch das weiter zu machen ..


aber habe mir halt erhofft dass manche mein denken übernehmen

mein denken von 4h ^= vll nur 20 min von euch ^^

ich schau mal später nochma rein wenn ich bei mathe fitter bin..trotzdem danke für den tipp

freu mich über jeden vorschlag ;D

[w-a-n-n-a-b-e]

*bump* bitteeeee :pale:

[negaH]

Deine RSA Schlüssel sind ja nun ziemlich kurz.

Normalerweise wird mit RSA garnicht die Nachricht verschlüsselt, das ist quasi unsicher da es spezielle Angriffe ermöglicht.

Man erzeugt einen Zufallsschlüssel der maximal exakt Ln2(P*Q)-1 Bits lang sein darf. Mit echtem RSA der ab 1024 Bit N anfängt ist es also kein Problem einen 128-256 Bit großen Zufallschlüssel zu erzeugen. Dieser Sessionkey wird benutzt um mit einem symmetrischen Verfahren wie DES, AES, Blowfish etc.pp. die Nachricht zu verschlüsseln. Mit RSA wird nun nur dieser 128-256 Bit große Zufallskey verschlüsselt. Da der aus Zufall besteht kann man auch die oben angesprochenen Angriffe auf RSA nicht mehr durchführen.

Leider ist das bei deinem Mini-RSA nicht durchführbar, da die effektive Sicherheit nur Ln2(5*7) = 4 also 4 Bit groß ist. Dein symmetrischer Zufallsschlüssel darf also nur 4 Bit groß sein.

Gruß Hagen

[-lx-]

Ich hab dazu eine Frage.

Wie kommst du auf die Blocklänge?

also warum gilt: Die Blocklänge(m)=Blocklänge(vom Schlüssel n)-1


?? :gruebel:

Ich sitz da auch shcon mehrere Nächte dran und hab mehrer Varianten verworfen da sie immer am scheinbaren Ende Mängel aufgewiesen haben. Nun mache ich das wie folgt.

Buchstabe für Buchstabe in ASCII Zeichen umwandeln und auf mit Hilfe von Nullen jeweils in 3er Packete packen.

also :

A= 65 = 065
z= 122 = 122

usw...

soo... nun habe ich halt das Problem wenn ich die Packete mit RSA verschlüssele... Verschlüsseln an sich ist nicht das Problem, aber am Ende das dann wieder zu entschlüsseln. ich muss doch wissen wo ein Packet anfängt und auch wieder endet. Erst habe ich das mit Hilfe von Nullen gekennzeichnet aber dies hat sich dann für ungeeignet entpupt - natürlich erst dann, als man dachte fertig zu sein :wall: ...
Nunja nun will ich es so machen dass die verschlüsselten Packete wiederum in Packete verschnürrt werden und gegebenfals mit Nullen aufgefüllt werden, damit sie alle die Gleiche Länge haben und ich sie schlussendlich wieder entschlüsseln kann.


Oder geht es noch anders? Ich bin mit meien Ideen am Ende. Irgendwo scheitern die immer wieder :(




Mit freundlichen Grüßen und schönen Oster Montag

-lx-

[negaH]

Du verchlüsselst "packete" mit RSA, das ist grundsätzlich falsch.

Mit RSA sollte man niemals eine Nachricht verschlüsseln, sondern nur ein Zufallsschlüssel. Dieser Schlüssel ist wie gesagt zufälig, ca. 128 Bit groß und dient als Schlüssel einer asymmetrischen Verschlüsselung der Nachricht.

Dies nennt sich Hybride, denn man benutzt aus beiden Welten -> symmetrische und asymmetrische Verschlüsselungen eine Kombiation aus beiden.

Das hat gleich mehrere Vorteile und erhöht auch noch die Sicherheit:

1.) asymmetrisches RSA ermöglicht es einen sicheren Schlüsselaustausch durchzuführen
2.) es wird ein zufälliger und großer Sessionkey intern benutzt -> ca. 128 Bit groß und zufällig. Das
ist besser als die meisten menschlichen Passwörter.
3.) zur Verschlüsselung der Nachricht wird nun ein sym. Verfahren wie AES Rijndael/Blowfish etc.pp. benutzt. Diese sind sicherer als asym. Verfahren im Besonderen bei speziellen Angriffen.
4.) RSA ist sehr empfindlich gegen Angriffe die auf bekannten Nachrichten-inhalten beruhen. Wenn du also mit RSA eine Nachricht verschlüsselt die entweder einen festen, immer wiederkehrenden Header enthält oder mit dem gleichen RSA verschiedene bekannte Nachtichten oder ein und die selbe Nachricht mit verschiedenen RSA Schlüsseln verschlüsselst, so sind in all diesen Fällen spezielle Angriffe möglich die zum Teil sogar den privaten Schlüssel restaurieren oder zumindestens simulieren können.

Man sollte mit RSA selber nur Zufallsdaten verschlüsseln.

Du benutzt die Primzahlen 5*7 um das public Modul N = 5*7 = 35 zu erzeugen. 35 ist ca. 2^5 ~32. Das bedeutet 5 Bits groß ist 35. Wenn du eine Nachticht damit direkt verschlüsseln möchtest so musst du sie also in Blöcke zerlegen die jeweils 5 Bit groß sind. Nur dann geht das auch wieder zu entschlüsseln. Aber wie ich oben schon andeutete solltest du einen zufälligen Sessionley benutzten. Der kann und darf dann natürlich nicht, bei 128 Bit Größe, ind 5 Bit Blöcke zerlegt werden und mit 5*7 RSA verschlüsselt werden. Das macht nämlich keinen sinn da die effektive Sicherheit maximal nur 5 Bit ist (was eher sehr optimistisch ist).

Nein. Damit RSA sicher ist musst du mit Primzahlen arbeiten die ca. 512 Bit große Zahlen darstellen, dh. die primzahlen sollten im Bereich > 2^512 liegen. Das ergäbe dann ein public Modul N mit 1024 Bit Größe, also ein Zahl um ca. 2^1024. Mit so einem RSA kann man auch mit nur einer einzigsten RSA Operation bis zu 1024 Bit an Daten verschlüsseln.


Gruß Hagen