Unbegrenzt viele Nachkommastellen

[negaH]

Ja das geht:

Delphi-Quellcode:

uses NInts, NMath;

interface

implementation

procedure RSA;
// RSA 1024 Bit verschlüsselung
var
  P,Q: IInteger; 
  N: IInteger;   
  E,D: IInteger;  
  U,Dp,Dq: IInteger;
  M,C: IInteger;    
  X,Y: IInteger;    
begin
// Schüssel Erzegung
  repeat
    NRnd(P, 512);
    NBit(P, 512 -2, True);
    NMakePrime(P, [1, 2]);
    repeat
      NRnd(Q, 512);
      NBit(Q, 512 -2, True);
      NMakePrime(Q, [1, 2]);
    until NCmp(P, Q) <> 0; 
    if NCmp(P, Q) < 0 then NSwp(P, Q);   
    NMul(N, P, Q);
  until NSize(N) = 1024;

  NDec(P);
  NDec(Q);
  NLCM(U, P, Q);      
  repeat
    repeat
      NRnd(E, NLog2(NSize(N)) * 4);   
      NOdd(E, True);
    until NGCD1(E, P) and NGCD1(E, Q);
  until NInvMod(D, E, U) and (NSize(D) >= NSize(E)) and NGCD1(D, N);

  NMod(Dp, D, P);    
  NMod(Dq, D, Q);    
  NInc(P);
  NInc(Q);
  NInvMod(U, P, Q);  

// privater und öffentlicher RSA Schlüssel sind nun fertig
// N,E ist der öffentliche Schlüssel
// N,D der private Schlüssel, wobei
// U,Dp,Dq,P,Q dazu gehören damit wir die Entschlüsselung um Faktor 4 beschleunigen können


// verschlüssele M den PlainText zu CipherText C = M^E mod N
  NSet(M, 'Unser Geheimnis', 256);
  NMod(M, N);          
  NPowMod(C, M, E, N);          

// entschlüssele C per Chinese Remainder Theorem ca. 4 mal schneller als normale Variante
  NPowMod(X, C, Dp, P);
  NPowMod(Y, C, Dq, Q);
  NCRT(Y, NInt([X, Y]), NInt([Dp, Dq]), NInt([U]));

// Y = M entschlüsselt
end.

Wie du siehst einfach per Uses einbinden und schwups ist RSA fertig.

gruß Hagen