RSA verschlüsselung

[negaH]

Wenn du das geschafft hast kopierst du die Procedure RSA aus dem gleichen Thread und baust sie wie oben in das Test Projekt ein.

Delphi-Quellcode:

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 Erzeugung 
// 1. Primzahlen P,Q erzeugen, jeweils 512 Bit groß, N=P*Q erzeugen
  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; 
// 2. Exponenten E und D erzeugen
  NDec(P); 
  NDec(Q); 
  NLCM(U, P, Q);   // Phi   
  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); 
// 3. Hilfsvariablen des privaten Keys erzeugen um die Entschlüsselung 400% zu beschleunigen
  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); 
  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 
// Ausgabe

  WriteLn('Schlüssel');
  WriteLn('P  : ', NStr(P));
  WriteLn('Q  : ', NStr(Q));
  WriteLn('N  : ', NStr(N));
  WriteLn('E  : ', NStr(E));
  WriteLn('D  : ', NStr(D));
  WriteLn('U  : ', NStr(U));
  WriteLn('Dp : ', NStr(Dp));
  WriteLn('Dq : ', NStr(Dq));
  WriteLn(#13, 'Verschlüsselung');
  WriteLn('M  : ', NStr(M, 256));
  WriteLn('M  : ', NStr(M));
  WriteLn('C  : ', NStr(C));
  WriteLn(#13, 'Entschlüsselung');
  WriteLn('Y  : ', NStr(Y, 256));
  WriteLn('Y  : ', NStr(Y));
  WriteLn(#13'fertig'#13);
end;

Gruß Hagen