RSA - Problem bei der verschlüsselung/entschlüsselung

[schweindi]

Hallo alle,
ich werkle jetzt schon länger an einigen Programmen für die Schule und brauche jetzt für das letzte noch RSA.

Ich habe eig alles schon fertig geschrieben, leider funzt da irgendetwas nicht ganz perfekt und ich bin mir ziemlich sicher, dass es mit hohen Potenzen und anschließenden modulo Rechnungen zusammenhängt.

So jetzt mal was ich bisher gemacht habe:

Delphi-Quellcode:

p:=p1;
q:=q1;
N:=p*q;
phiN:=(p-1)*(q-1);
repeat
e:=Random(1024);
until ((e mod  phiN)<>0)and(e<2048);
d:=mod_inv(phiN,e);

da sind einmal p, q, N, und phi(N) sowie e und dann das multipl. Inverse von phi(N) und e.
p1 & q1 sind integer generiert aus Random(2048)...

mod_inv(phiN,e) befindet sich in einer dll, die ich für alle Programme verwende:

Delphi-Quellcode:

function mod_inv(A,B:Integer):Integer;export;
var n1,n2,b1,b2,q,r,t:Integer;
Fertig:Boolean;
begin
if a < 1 then
  begin
  Result:=a;
  end else
  begin
  Fertig:=False;
  n1:=A;
  n2:=B;
  b1:=0;
  b2:=1;
  repeat
   r:=n1 mod n2;
   q:=n1 div n2;
   if r=0 then
   begin
    if b2 < 0 then
    b2:=b2+65537;
    Result:=b2;
    Fertig:=True;
   end else
    begin
    n1:=n2;
    n2:=r;
    t:=b2;
    b2:=b1-q*b2;
    b1:=t;
    end;
  until Fertig;
  end;
end;

so und hier noch der letzte teil:
Input = ein Text von Edit1.Text
symbcode(Input) = eine funktion, die jeden Buchstaben in die entsprechende Zahl umwandelt (A:1,B:2,C:3...)
ich habe iwo gelesen, man könnte es auch direkt mit den ASCII codes machen und dann glaub ich char() aber ich wollte es mal so probieren.
Die function hab ich schon getestet und sie gibt die richtigen Werte aus.

Delphi-Quellcode:

for i:=1 to length(Input) do
begin
debug:=StrToInt(symbcode(Input)[i]);
Memo1.Lines.Add('Eingabe: '+IntToStr(debug)+' d: '+Inttostr(d));
y:=expmod(debug,e,N);
Memo1.Lines.Add('Code: '+IntToStr(y));
Memo1.Lines.Add('Klartext: '+IntToStr(expmod(y,d,N)));
end;

so und jetzt noch die function expmod(a,b,c)... ich hatte leider keine Ahnung wie ich von den "riesen Zahlen" mod rechen soll, wenn sie hunderte stellen haben, deshalb hab ich diese function verwendet, ka wo ich sie gefunden hab.
(unverändert)

Delphi-Quellcode:

function expmod(b,x,m :integer):extended;export;
  var
    quad,halb,erg:Integer;
   {
    Berechnet die diskrete Exponentialfunktion b hoch x modulo m
    unter ausschließlicher Verwendung der Operationen Quadrieren
    und Multiplizieren. Der Rest wird nach jeder Operation bestimmt,
    um große Zwischenergebnisse zu vermeiden
    mod bezeichnet die Modulo-Operation
    div bezeichnet die ganzzahlige Division
   }
begin
  Quad := b; //basis
  Halb := x; //hochzahl
  Erg := 1;  //Ergebnis
  while Halb > 0 do
    begin
      if Halb mod 2 > 0 then
         Erg := (Erg * Quad) mod m;
       Quad := (Quad * Quad) mod m;
       Halb := Halb div 2;
    end;
  result := Erg;
end;

bei kleinen werten:
e,d=3
p,q < 100 funktioniert es bei A=01 aber sobald e,d,p,q größer werden oder B=02 eingegeben wird kommt es zu Fehler, so dass der "codierte"Buchstabe plötzlich den Wert 0 bekommt...

sieht jemand schon einen Fehler?

lg
Schweindi

[gammatester]

RSA setzt voraus, daß p und q Primzahlen sind!

[schweindi]

ahaaa... naja daran hab ich eig nicht gedacht ;)

ja ich änder das mal schnell und mal sehen...
danke!

[schweindi]

also, es werden jetzt immer schöne primzahlen verwendet..
2 mögliche Fehler:
1) die verschlüsselung / entschlüsselung ergibt immer noch 0
2) der "Code" "Klartext" ist bei G(7) gerade 75 gewesen... da kann also auch iwas nicht stimmen, aber danke für den primzahlen Hinweis!

[himitsu]

Über RSA findet man Einiges, aber auch nicht zuviel ... schau dir doch einfach mal einige dieser Threads an.

[gammatester]

Das Ergebnis von expmod ist extended, also kann eigentlich

Delphi-Quellcode:

y:=expmod(debug,e,N);
Memo1.Lines.Add('Code: '+IntToStr(y));

nicht übersetzt werden. Wenn y integer ist, geht die erste Zeile nicht, sonst die zweite. Hast Du eventuell expmod in Deinem Code als integer deklariert und die DLL liefert extended? Warum ist überhaupt das Ergebnis von expmod extended, da Du doch alles integer rechnest?

[schweindi]

so ich habe jetzt mal das ergebnis von expmod zu integer gemacht und hab eben auch bemerkt:

Bei RSA muss ja N > text zum verschlüsseln -> ich versuch mal p&q ordentlich groß zu machen und e ein bisschen einzuschränken, damit das auch mal stimmt.

Kann ich da, damit es größer wird, integer ersetzen? Ich weiß, dass extended der größte Typ ist, aber da gibt es doch probleme mim Darstellen bzw bei mir ging aus trunc(extendend) oft ein Floating Point error hervor?

[gammatester]

Die Größe von e ist das kleinste Problem. Wenn Du statt integer überall den größeren Typ int64 nimmst, kannst Du für p,q bis zu ca 55000 gehen.

[schweindi]

ahso... naja ich dachte nur weil der klartext ^e genommen wird, aber ich sehe ja bei expmod ist die hochzahl ja umgangen...

Und noch eine frage, ist es notwendig 2-3 zeichen zusammenzufassen oder kann man, so wie ich jeden buchstaben einzeln verschlüsseln?

was für zahlen kann ich mir da erwarten bei e:=1024, p,q ca. 25000-30000 und die zu verschlüsselnde Zahl 1-41?

EDIT:
Ich habe jetzt mal alle "großen Zahlen" zu Int64 gemacht und es läuft jetzt mal sehr schön, aber nur wenn ich A(01) eingebe...

Dann berechnet er schön:
input = 1
Code = 1 also A

Wenn ich aber zb B(02) eingebe bzw Z(26) dann sieht das so aus:
[B(02)]:
input = 2
d = -20138308
Code = 1 (sollte 2 sein!)
Klartext = 2145688 (entschlüsselt, sollte auch 2 sein)

[Z(26)]:
input = 26
d = 41659327
Code = 1 (sollte 26 sein!)
Klartext = 3188353 (entschlüsselt, sollte auch 26 sein)

also schließe ich richtig, dass "d", also das multiplikative inverse falsch berechnet wird?

[himitsu]

Schalte mal die Überlaufprüfung ein.
siehe Projektoptionen

[gammatester]

Was ist eigentlich Dein 'd'? Normalerweise ist es der geheime Entschlüssellungsexponent und der ändert sich natürlich nicht.

[gammatester]

Dein mod_inv hat einen Bug (außerdem hat es eine ungewöhnliche Parameterreihenfolge: inv_mod(a,b) berechnet nicht 1/a mod b sondern 1/b mod a, solltest du vielleicht mal ändern, zumindest aber hinschreiben). Ich zeige mal die korrigierte Version und ein simples Testproramm mit kleinen Werten:

Delphi-Quellcode:

program t_mrsa2;

{$ifdef WIN32}
{$apptype console}
{$endif}

function mod_inv(A,B:longint):longint;
  {-liefert 1/B mod A}
var
  n1,n2,b1,b2,q,r,t:longint;
  Fertig:Boolean;
begin
  if a < 1 then begin
    mod_inv:=a;
  end
  else begin
    Fertig:=False;
    n1:=A;
    n2:=B;
    b1:=0;
    b2:=1;
    repeat
       r:=n1 mod n2;
       q:=n1 div n2;
       if r=0 then begin
         if b2 < 0 then b2:=b2+A; {Fehler!! statt 65537 muss hier A stehen}
         mod_inv:=b2;
         Fertig:=True;
       end
       else begin
         n1:=n2;
         n2:=r;
         t :=b2;
         b2:=b1-q*b2;
         b1:=t;
       end;
    until Fertig;
  end;
end;

function expmod(b,x,m: longint): longint;
  var
    quad,halb,erg:longint;
   {
    Berechnet die diskrete Exponentialfunktion b hoch x modulo m
    unter ausschließlicher Verwendung der Operationen Quadrieren
    und Multiplizieren. Der Rest wird nach jeder Operation bestimmt,
    um große Zwischenergebnisse zu vermeiden
    mod bezeichnet die Modulo-Operation
    div bezeichnet die ganzzahlige Division
   }
begin
  Quad := b; {basis}
  Halb := x; {hochzahl}
  Erg := 1;  {Ergebnis}
  while Halb > 0 do
    begin
      if Halb mod 2 > 0 then
         Erg := (Erg * Quad) mod m;
       Quad := (Quad * Quad) mod m;
       Halb := Halb div 2;
    end;
  expmod := Erg;
end;

var
  p,q,n,e,d,phi,i,x,y: longint;
begin
  p := 17;
  q := 19;
  n := p*q;
  phi := (p-1)*(q-1);
  e := 5;
  d := mod_inv(phi,e);
  writeln('d=',d);
  for i:=0 to 255 do begin
    x := expmod(i,e,n);
    y := expmod(x,d,n);
    if y<>i then writeln('Fehler: y<>i für i=',i);
    if (i<11) or (i>240) then writeln(i:5, x:5, y:5);
  end;
end.

Und hier die Ausgabe, die zeigt, daß alle Zeichen von 0..255 richtig ver/entschlüsselt werden. Setz mal die Werte p=17, q=19, e=5 in Dein Programm ein und vergleiche, ob die Ergebniss dann übereinstimmen.

Wenn alles OK, must Du Dir klar sein, daß RSA in dieser Größenordnung nur für Lernzwecke genutzt werden sollte, keinesfalls für wirkliche Anwendungen.

Code:

>DCC32 -b t_mrsa2.pas
Borland Delphi for Win32 compiler version 18.0
Copyright (c) 1983,2005 Borland Software Corporation
t_mrsa2.pas(39) Warning:
t_mrsa2.pas(85)
86 lines, 0.66 seconds, 12508 bytes code, 12176 bytes data.

>T_MRSA2.EXE
d=173
    0    0    0
    1    1    1
    2   32    2
    3  243    3
    4   55    4
    5  218    5
    6   24    6
    7   11    7
    8  145    8
    9  263    9
   10  193   10
  241   90  241
  242  276  242
  243  116  243
  244  194  244
  245  215  245
  246   94  246
  247   76  247
  248  210  248
  249  146  249
  250  224  250
  251  302  251
  252  199  252
  253  138  253
  254  220  254
  255  221  255

[himitsu]

Zitat:

Zitat von gammatester

außerdem hat es eine ungewöhnliche Parameterreihenfolge

och, sowas läßt sich ja leicht beheben

- die beiden Parameter umgedreht
- Das Funktionsergebnis über Result, statt Funktionsnamen
* (leichter zu erkennen, ob Funktionsaufruf oder Ergebniszuweisung)
- die Fertig-Variable abgeschaft

Delphi-Quellcode:

program t_mrsa2;

{$ifdef WIN32}
  {$apptype console}
{$endif}

function mod_inv(A, B: LongInt): LongInt;
  {liefert 1 / A mod B}
var
  n1, n2, b1, b2, q, r, t: LongInt;
begin
  if B >= 1 then begin
    n1 := B;
    n2 := A;
    b1 := 0;
    b2 := 1;
    while true do begin
       r := n1 mod n2;
       q := n1 div n2;
       if r = 0 then begin
         if b2 < 0 then b2 := b2 + B;
         Result := b2;
         Break;  // oder gleich Exit;
       end;
       n1 := n2;
       n2 := r;
       t  := b2;
       b2 := b1 - q * b2;
       b1 := t;
    end;
  end else
    Result := B;
end;

function expmod(b, x, m: LongInt): LongInt;
  var
    quad, halb, erg: LongInt;
   {
    Berechnet die diskrete Exponentialfunktion b hoch x modulo m
    unter ausschließlicher Verwendung der Operationen Quadrieren
    und Multiplizieren. Der Rest wird nach jeder Operation bestimmt,
    um große Zwischenergebnisse zu vermeiden.
    - mod bezeichnet die Modulo-Operation
    - div bezeichnet die ganzzahlige Division
   }
begin
  Quad := b; {Basis}
  Halb := x; {Exponent}
  Erg  := 1; {Ergebnis}
  while Halb > 0 do
    begin
      if Halb mod 2 > 0 then
         Erg := (Erg * Quad) mod m;
       Quad := (Quad * Quad) mod m;
       Halb := Halb div 2;
    end;
  Result := Erg;
end;

var
  p, q, n, e, d, phi, i, x, y: LongInt;
begin
  p   := 17;
  q   := 19;
  n   := p * q;
  phi := (p - 1) * (q - 1);
  e   := 5;
  d   := mod_inv(e, phi);
  WriteLn('d=', d);
  for i := 0 to 255 do begin
    x := expmod(i, e, n);
    y := expmod(x, d, n);
    if y <> i then WriteLn('Fehler: y<>i für i=', i);
    if (i < 11) or (i > 240) then WriteLn(i:5, x:5, y:5);
  end;
end.

Für größere berechnugsräume gibt es Int64.
Extended kann zwar theoretisch größere Werte enthalten, aber es gibt nur 19-20 signifikante Dezimalstellen ... alles andere wird Aufgrund des internen Formates quasi weggerundet.
Int64 hat genausoviele Stellen, aber keine Rundungsfehler.

Für mehr mußt du dann auf andere Mittel ausweichen: BigNumber, BigInt oder Dergleichen
TBigInt

[gammatester]

Zitat:

Zitat von himitsu

- Das Funktionsergebnis über Result, statt Funktionsnamen
(leichter zu erkennen, ob Funktionsaufruf oder Ergebniszuweisung)

Ist aber nicht portabel! :!: Außerdem könnte man es dann doch gleich durchsichtiger machen (hab's anders genannt, damit keine Verwirrung entsteht):

Delphi-Quellcode:

function mod_inv1(A,B:longint):longint;
  {-liefert 1/A mod B, 0 wenn nicht invertierbar d.h. ggt(A,B) <> 1}
var
  n1,n2,b1,b2,q,t:longint;
begin
  n1 := B;
  n2 := A;
  b1 := 0;
  b2 := 1;
  while n2<>0 do begin
    q  := n1 div n2;
    t  := n2;
    n2 := n1 - q*n2;
    n1 := t;
    t  := b2;
    b2 := b1 - q*b2;
    b1 := t;
  end;
  if n1<>1 then mod_inv1 := 0
  else if b1<0 then mod_inv1 := b1+B
  else mod_inv1 := b1;
end;

[himitsu]

Wieso eigentlich nicht portabel?
Selbst FPC/Lazarus sollte doch wohl Result kennen, denn dieses stammt ja noch aus den Pascal-Anfangszeiten und gehört praktisch zur grundlegenden Syntax.

[edit]
OK, die Anfangszeiten sind für mmich jetzt einfach mal solange ich mich zurückerinnern kann.

[gammatester]

Zitat:

Zitat von himitsu

Wieso eigentlich nicht portabel?
Selbst FPC/Lazarus sollte doch wohl Result kennen, denn dieses stammt ja noch aus den Pascal-Anfangszeiten und gehört praktisch zur grundlegenden Syntax.

Ich weiß zwar nicht, was Du unter Pascal-Anfangszeiten verstehst, aber zB alle Borland/Turbo-Pascalversionen und alle Free-Pascal in nativen Modi kennen es nicht (FPC muss erst in den Delphi-Kompatibilitäts-Modus schalten).

Vielleicht sollten wir diesen Tread aber nicht so 'zumüllen' und erst mal Schweindis Antwort(en) abwarten.

[schweindi]

also d ist eben das multipl. Inverse von e... und es kommt immer ein anderer Wert raus, weil ich es in die loop reingeschrieben hab -> fehler

ja, die absolute Zahl ist natürlich auch dumm :) danke für die Korrektur!

Ich werde, wenn mal die Verschlüsselung richtig geht, auf BigInt etc umsteigen und für den Anfang reicht es fürs Lernen aus.

Das mit portable verstehe ich nicht ganz- worum gehts da genau?? (ist es wichtig, wenn ich das Programm nur so verwenden will, also compiled ohne Schnittstelle zu anderen?

Ich melde mich wenn ich alles verändert habe.
lg

[Aphton]

Wie es aussieht, hast du dich nicht ausreichend genug mit der Materie beschäftigt.
Ich habe vor einiger Zeit mal ein Referat über RSA gehalten. Ich lade mal die PP Präsentation hoch, evt. hilft es dir.

Btw. Du wirst noch einem ganz anderen Problem begegenen:
Das Ergebnis von X mod Y liegt im Wertebereich von {0..Y-1}.

Was heißt das?
Beim RSA-Algorithmus verschlüsselt man, indem man das zu Verschlüsselnde (X) hernimmt, es mit der Encryption-Potenz (E) potenziert und modulo RSA-Modul (N) rechnet.
Sieht dann so aus --> Y = X^E mod N.

Hierbei musst du beachten, dass foglende Bedingung erfüllt ist:
X < N

Falls nicht, kann X nicht mehr zurückberechnet werden - siehe dazu Entschlüsselung und den Fett gedruckten Teil dieser Nachricht:
X = Y^D mod N.

MfG

[ele]

Ich verstehe ja das das ein Schulprojekt ist, aber RSA mit Int64??

Ein Int64 ist lächerlich schnell faktorisiert und bietet daher Null Sicherheit. Ein RSA-Schlüssel sollte in der Praxis mindestens 1024 Bits lang sein. Besser 2048, da man annimt, dass man in wenigen Jahren in der Lage sein wird 1024-Bit Schlüssel innerhalb einer vernünftigen Zeit zu knacken.

Als Lernprojekt ist das OK, aber es soll ja nicht jemand auf die Idee kommen, sowas in einem echten Produkt zu machen.

Ausserdem: Das verschlüsseln mit RSA ist relativ zeitaufwändig (zumindest wenn man mit genügend grossen Zahlen arbeitet). Deshalb wir in der Praxis meist ein symmetrisches Verschlüsselungsverfahren gewählt. Dieser Schlüssel kann dann mit RSA verschlüsselt und sicher übertragen werden.

Nur so zur Info, da ich das jetzt nirgendwo gelesen habe...

[schweindi]

jaja, klar aber wie schon einige geschrieben haben ist das jetzt nur zu Testzwecken, wenn ich da schon solche Denkfehler drinnen habe, wie soll ich dann etwas mit "großen" Zahlen verstehen, die ich mir garnicht vorstellen kann.

Also ich habe die functions wie folgt geändert:

Delphi-Quellcode:

function expmod(b, x, m: LongInt): LongInt; 
  var 
    quad, halb, erg: LongInt; 
   { 
    Berechnet die diskrete Exponentialfunktion b hoch x modulo m 
    unter ausschließlicher Verwendung der Operationen Quadrieren 
    und Multiplizieren. Der Rest wird nach jeder Operation bestimmt, 
    um große Zwischenergebnisse zu vermeiden. 
    - mod bezeichnet die Modulo-Operation 
    - div bezeichnet die ganzzahlige Division 
   } 
begin 
  Quad := b; {Basis} 
  Halb := x; {Exponent} 
  Erg  := 1; {Ergebnis} 
  while Halb > 0 do 
    begin 
      if Halb mod 2 > 0 then 
         Erg := (Erg * Quad) mod m; 
       Quad := (Quad * Quad) mod m; 
       Halb := Halb div 2; 
    end; 
  Result := Erg; 
end;

function mod_inv(A,B:Int64):Int64;export;
  {liefert 1 / A mod B} 
var n1,n2,b1,b2,q,r,t:Int64;
begin 
  if B >= 1 then begin 
    n1 := B; 
    n2 := A; 
    b1 := 0; 
    b2 := 1; 
    while true do begin 
       r := n1 mod n2; 
       q := n1 div n2; 
       if r = 0 then begin 
         if b2 < 0 then b2 := b2 + B; 
         Result := b2;
         Break;  // oder gleich Exit;
       end; 
       n1 := n2; 
       n2 := r; 
       t  := b2; 
       b2 := b1 - q * b2; 
       b1 := t; 
    end; 
  end else 
    Result := B; 
end;

und wenn ich jetzt, wie du es geschrieben hast, die Schleife von 0-255 durchlaufen lasse steht folgendes da:

Fehler: y<>i für i=0
x:5 y:5 z:5
x:5 y:5 z:5
Fehler: y<>i für i=2
x:5 y:5 z:5
Fehler: y<>i für i=3
x:5 y:5 z:5
Fehler: y<>i für i=4
x:5 y:5 z:5
Fehler: y<>i für i=5
x:5 y:5 z:5
Fehler: y<>i für i=6
x:5 y:5 z:5
Fehler: y<>i für i=7
x:5 y:5 z:5
Fehler: y<>i für i=8
x:5 y:5 z:5
Fehler: y<>i für i=9
x:5 y:5 z:5
Fehler: y<>i für i=10
x:5 y:5 z:5
Fehler: y<>i für i=11
Fehler: y<>i für i=12
Fehler: y<>i für i=13
Fehler: y<>i für i=14
Fehler: y<>i für i=15

usw.............. hmmm sollte glaub ich nicht so sein :(

[gammatester]

Leider hast Du himitsus mod_inv eingebaut (ich hatte ja schon befürchtet, daß er damit nur Verwirrung stiftet!), ohne zu beachten, daß er die Parameterreihefolge umgedreht hat. Damit mußt Du natürlich auch schreiben:

Delphi-Quellcode:

  e := 5;
  d := mod_inv(e,phi);
  writeln('d=',d);

[schweindi]

okay... hab jetzt doch deine functions reinkopiert und alles compiled kommt immer: 'x:5 y:5 z:5'

folglich ist i<11 & i>240 - was genau bedeutet das nun?
da der 'Fehler' nicht kommt, heißt es doch, dass i=y (Gut!)
worum gehts dann genau im x,y,z:5 ?

[himitsu]

Du kannst das

Delphi-Quellcode:

if (i < 11) or (i > 240) then

auch weglassen ... dieses ist praktisch nur da, damit die Anzeige nicht zu lang wird.

i = Eingabewert
x = verschlüsselter Wert
y = entschlüsselter Wert (dieser sollte ja i entsprechen)

[schweindi]

ahso.. naja okay, ich war mir nicht sicher, da ich bisher nur delphi 2007 verwendet hab und nicht sicher war, ob writeln das selbe ist wie bei mir :S

okay damit funktioniert das ganze mal, das ist sehr schön, danke euch Beiden.

Jetzt würde ich doch noch gerne wissen, wie ich das mit größeren Zahlen machen kann, ich denke zb (Testzweck!) an e=1024...?
Geht das nur mit BigInt?

[gammatester]

Zitat:

Zitat von schweindi

okay... hab jetzt doch deine functions reinkopiert und alles compiled kommt immer: 'x:5 y:5 z:5'

folglich ist i<11 & i>240 - was genau bedeutet das nun?
da der 'Fehler' nicht kommt, heißt es doch, dass i=y (Gut!)
worum gehts dann genau im x,y,z:5 ?

Hast Du in Deinem Code

Delphi-Quellcode:

writeln(i:5, x:5, y:5);

stehen oder nicht? Ich denke nicht, sondern etwas wie

Delphi-Quellcode:

writeln('i:5, x:5, y:5');
//oder noch schlimmer
ShowMessage('i:5, x:5, y:5');

Das writeln(i:5, x:5, y:5); gibt in der Schleife i,x und y jeweils 5-stellig aus. Aber wenn Du keine Fehler 'Fehler: y<>i für i=5' mehr bekommst, hast Du jetzt eine Basis, auf der Du Deine Ideen weiter entwickeln kannst.

Gruß Gammatester

[schweindi]

ja, wie gesagt, ich programmiere in Delphi 2007 und da kann ich nicht writeln() aufrufen, wenn ich es nicht in eine Datei schreiben will.

und x:5 / z:5 / y:5 kenn ich garnicht.

habs jetzt so probiert:

Delphi-Quellcode:

AssignFile(F, 'z.txt');
Rewrite(F);
writeln(x:5,y:5,z:5);
CloseFile(F);

da kommt I/O Error 105 raus... ist aber nicht so wichtig, danke für die Erklärungen, ich mach mal weiter mit dem, was ich vor hatte!

[gammatester]

Wie schon gesagt, e ist überhaupt keine Problem. In der Praxis werden Werte wie e=3, e=17=2^4+1 oder e=65537=2^16+1 benutzt. Mit Deinen int64 könntest Du Werte nehmen, die unsinnig groß sind und normalerweise nicht verwendet werden. Du scheinst zu vergessen, daß e öffentlich ist, also nix geheimes, schwer knackbares etc. Das Problem ist (wie ele schon geschrieben hat) die Größe von N. Mit den 63 Bit bist Du um den Faktor ca 20 [editiert] zu klein.

Wenn Du wirklich (hoffentlich nachdem Du die Grundlagen sauber mit longint oder int64 implementiert hast) an große Zahlen rangehen willst, kannst Du zB die RSA-Funktionen aus meiner Opensource Bigint-Bibliothek MPArith benutzen.

PS: IO Error 105: Du hast {$apptype console] nicht mit eingegeben.

[schweindi]

okay danke sehr :)

ja ich spiel mich jetzt mal mit den kleinen zahlen herum, bis ich es wirklich verstanden hab, das könnte noch bisschen dauern und dann wag ich mich erst weiter... vllt liest man sich ja.

lg
Schweindi

PS: Danke, jetzt gehts!

[himitsu]

Delphi-Quellcode:

AssignFile(F, 'z.txt');
Rewrite(F);
WriteLn(F, x:5, y:5, z:5);  // die Datei nicht vergessen
CloseFile(F);

Delphi-Quellcode:

Jetzt würde ich doch noch gerne wissen, wie ich das mit größeren Zahlen machen kann, ich denke zb (Testzweck!) an e=1024...?
Geht das nur mit BigInt?

Ja, also nun hast du die Qual der der Wahl.

Es gibt tausende Big-Math-Libs
und welche du jetzt nimmst, das ist dir überlassen.

negaH's DECMath ist superschnell und leistungsstark, da es speziell für Verschlüsselungen entwickelt wurde.
Ansonsten gibt es alleine in der DP mehrere Libs.
Schau einfach mal nach BigMath BigInt TBigInt, da sollten sich einige Threads finden lassen.

Meine StringMatheLib wurde speziell auf Einfachheit hin entwickelt, aber sie ist auch relativ langsam.
(absichtlich nicht zu sehr optimiert .. halt einfacher Code)

Aber für "kleine" Verschlüsselungen scheint sie nutzbar zu sein ... es gibt hier schon einige Threads, wo jemand damit versuchte eine RSA zu erstellen.

[gammatester]

Zitat:

Zitat von schweindi

ich denke zb (Testzweck!) an e=1024...? Geht das nur mit BigInt?

Versuch als kleine Übung mal herauszufinden, warum RSA mit e=1024 nicht funktionieren kann! (Weder mit int64 noch mit BigInt).

Gammatester