testunit.pas

cipher 5.1。一个几乎包含了所有常见的加密算法的控件

unit TestUnit;

interface

uses Windows, SysUtils, Classes, ConsoleForm, DECUtil, DECHash, DECRandom,
     NMath, NInts, NInt_1, NCombi, NRats, Prime, IDPrimes, DECCipher, DECFmt,
     comctrls, Controls, SRP, NPolys, NGFPs, NGFPBld, NGFPTab, CRC, Math;

implementation

function _Str(const A: IInteger = nil; const Base: Integer = 10): Variant;
// f黵 Debugwatching
begin
  Result := NStr(A, Base);
end;


procedure Step1;
// basic usage of IInteger
var
  A,B,C: IInteger;
begin
// zuerst mal erzeugen wir zuf鋖lige werte f黵 A und B
  NRnd(A, 1024);  // A hat 1024 Bit gr鲞e
  NRnd(B, 128);   // B 128 Bit
// num mal alle wichtigen Operatoren
  NAdd(A, B);	  // A = A + B
  NSub(A, B);	  // A = A - B
  NAdd(C, A, B);  // C = A + B
  NSub(C, A, B);  // C = A - B
  NNeg(C);	  // C = -C
  NOdd(C, True);  // C = C or 1, nun ist C ungerade
  NMul(C, A, B);  // C = A * B

  WriteLn(#2'Dezimal:'#0#13, NStr(C, 10) ); // display C in dezimal
  WriteLn(#2'Bin鋜:'#0#13, NStr(B, 2)  ); // display B in binr鋜
  WriteLn(#2'Basis 7:'#0#13, NStr(B, 7)  ); // display B zur basis 7
  WriteLn(#2'HEX:'#0#13, NStr(B, 16) ); // nun HEX-decimal

  NSwp(B, piByte);
  WriteLn(#2'HEX geswappt:'#0#13, NStr(B, 16) );
end;


procedure Step2;
// NPi() selber ist die dritt schnellste Implementation zur Berechnung von Pi
// auf PC's in der Welt !
var
  Decimals: Integer;
  A: IInteger;
begin
  Write(#2'Anzahl Dezimalstellen von PI:'#0); Decimals := Trunc(ReadNumber); // auch 1e4 f黵 10000 m鰃lich als Eingabe
  Write(#30);  // aktiviere Timer, das erste WriteLn zeigt dann die Millisekunden an

  NPi(A, Decimals);

  WriteLn;     // hier Timer anzeigen

  Write(#21);  // Console 1 aktivieren
  WriteLn(NStr(A));
  Write(#20);  // Console 0 aktivieren

 // #21 = Opcode zum Wechseln in Console 1
 // #20 = Opcode zum Wechseln in Console 0

end;

procedure NRoot(var R: IInteger; const A: IInteger; Root,Digits: Integer; Base: TBase = 10); overload;
// R = A^(1/Root) * Base^Digits
resourcestring
  sNRoot1 = 'NRoot(), invalid paramater Root, must be >= 2';
  sNRoot2 = 'NRoot(), invalid paramater Digits, must be >= 0';
var
  T: IInteger;
begin
  if Root < 2 then NRaise(@sNRoot1);
  if Digits < 0 then NRaise(@sNRoot2);
  NPow(T, Base, Digits);
  NPow(T, Root);
  NMul(R, T, A);
  while not Odd(Root) do
  begin
    NSqrt(R);
    Root := Root shr 1;
  end;
  if Root > 1 then NRoot(R, Root);
end;

procedure Step3;
var
  Decimals: Integer;
  C: Char;
  A: IInteger;
begin
  Write(#2'Anzahl Dezimalstellen der Quadratwurzel:'#0); ReadLn(Decimals);
  Write(#30);  // aktiviere Timer

  NRoot(A, NTwo, 2, Decimals, 10);

  Write(#3'Resultat hat ', NDigitCount(A, 10), ' Dezimalstellen, anzeigen (J/N)'#0); ReadLn(C);
  if UpCase(C) = 'J' then
  begin
    Write(#21);
    WriteLn(NStr(A, 10));
    Write(#20);
  end;
end;

procedure Step4;
var
  N: Integer;
  A: IInteger;
begin
  Write(#5'Fakult鋞 von:'#0); ReadLn(N);
  Write(#30);

  NFactorial(A, N);

  WriteLn;
  Write(#21);
  WriteLn( NStr(A) );
  Write(#20);
end;

procedure Step5;
var
  R,S: IRational;
begin
  NSet(R, 1, 3);   // R = 1 / 3
  NSet(S, 4, 5);   // S = 4 / 5

  NMul(R, S);
  WriteLn(#4'1/3 * 4/5'#0#13, NStr(R) );

  NDiv(R, S);
  WriteLn(#5#14'1/3 * 4/5 / 4/5'#0#13, NStr(R) );
  WriteLn(#5#15'1/3 * 4/5 / 4/5'#0#13, NStr(R, 16, 32) );  // zur basis 16 und 32 signifikante Stellen

  NMul(R, 3);
  WriteLn(#6'1/3 * 3'#0#13, NStr(R) );

end;

procedure Step6;
var
  A,B,C: IPoly;
  M,X: IInteger;
begin
// erzeuge eine Primzahl
  NRnd(M, 256);
  NMakePrime(M, [1, 2]);
// erzeuge ein zuf鋖liges degree 8 polynom
  NRnd(A, 8, M, True);
// ausgabe
  WriteLn(#2'Degree 8 random Polynom'#0#13, NStr(A) );

// finde einen Degree 4 Faktor des Degree 8 Polynoms in A
  NFactor(B, A, 4, M);

  WriteLn(#2'1. Faktor'#0#13, NStr(B) );

// dividire C = A / B mod M
  NDiv(C, A, B, M);
  WriteLn(#2'2. Faktor'#0#13, NStr(C) );

  NMul(A, C, B);
  NMod(A, M);
  WriteLn(#2'Result'#0#13, NStr(A) );

// berechne das Polynom, d.h. wir rechnen Y = X^8 +- a * X^7 +- b * X^6 .... + k mod M
  NRnd(X, 1024);
  WriteLn(#2'X:'#0#13, NStr(NInt(A, X, M)));
end;

procedure Step7;
// RSA 1024 Bit verschl黶selung
var
  P,Q: IInteger;     // primzahlen
  N: IInteger;	     // modulus
  E,D: IInteger;     // public/private exponent
  U,Dp,Dq: IInteger; // private values to speedup decryption by factor 4
  M,C: IInteger;     // Plaintext/Ciphertext
  X,Y: IInteger;     // helper
begin
  Write(#8);	     // clear screen

  repeat
  // erzeuge 512 Bit Primzahl P
    NRnd(P, 512);
    NBit(P, 512 -2, True);
    NMakePrime(P, [1, 2]);
  // erzeuge 512 Bit Primzahl Q
    repeat
      NRnd(Q, 512);
      NBit(Q, 512 -2, True);
      NMakePrime(Q, [1, 2]);
    until NCmp(P, Q) <> 0; // verhindere unwahrscheinlichen Fall das P gleich Q ist
    if NCmp(P, Q) < 0 then NSwp(P, Q);	// make sure P > Q
  // erzeuge public Modul N = 1024 Bit,  N = P * Q
    NMul(N, P, Q);
  until NSize(N) = 1024;  // verhindere unwahrscheinlichen Fall das N nicht wie gew黱scht 1024 Bit gro