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

[himitsu]

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