dechash.pas

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

    procedure DoPull;
    procedure DoTransform(Buffer: PLongArray); override;
  public
    class function DigestSize: Integer; override;
    class function BlockSize: Integer; override; // 32
    function Digest: PByteArray; override;
  end;

  THashBaseWhirlpool = class(TDECHash)
  private
    FDigest: array[0..15] of LongWord;
    FTableC: Pointer;
    FTableR: Pointer;
  protected
    procedure DoTransform(Buffer: PLongArray); override;
    procedure DoDone; override;
  public
    class function DigestSize: Integer; override;
    class function BlockSize: Integer; override;
    function Digest: PByteArray; override;
  end;

  THash_Whirlpool = class(THashBaseWhirlpool)
  protected
    procedure DoInit; override;
  end;

  THash_Whirlpool1 = class(THashBaseWhirlpool)
  protected
    procedure DoInit; override;
  end;

  THash_Square = class(TDECHash)
  private
    FDigest: array[0..3] of LongWord;
  protected
    procedure DoInit; override;
    procedure DoDone; override;
    procedure DoTransform(Buffer: PLongArray); override;
  public
    class function DigestSize: Integer; override;
    class function BlockSize: Integer; override; 
    function Digest: PByteArray; override;
  end;

  THashBaseSnefru = class(TDECHash)  {"derived from the Xerox Secure Hash Function"}
  private
    FDigest: array[0..23] of LongWord;
    FSecurity_Level: Integer;
    procedure SetSecurity_Level(Value: Integer);
  protected
    procedure DoInit; override;
    procedure DoDone; override;
  public
    function Digest: PByteArray; override;
  published
    property Security_Level: Integer read FSecurity_Level write SetSecurity_Level; // can set from 2 to 8, default is 8
  end;

  THash_Snefru128 = class(THashBaseSnefru)
  protected
    procedure DoTransform(Buffer: PLongArray); override;
  public
    class function DigestSize: Integer; override;
    class function BlockSize: Integer; override; // 48
  end;

  THash_Snefru256 = class(THashBaseSnefru)
  protected
    procedure DoTransform(Buffer: PLongArray); override;
  public
    class function DigestSize: Integer; override;
    class function BlockSize: Integer; override;  // 32
  end;

  THash_Sapphire = class(TDECHash)
  private
    FCards: array[0..255] of LongWord;
    FDigest: array[0..15] of LongWord;
    FRotor: LongWord;                 // don't change order
    FRatchet: LongWord;
    FAvalanche: LongWord;
    FPlain: LongWord;
    FCipher: LongWord;
    FDigestSize: Integer;
  protected
    procedure DoInit; override;
    procedure DoDone; override;
  public
    class function BlockSize: Integer; override;
    class function DigestSize: Integer; override;
    function Digest: PByteArray; override;
    function DigestStr(Format: TDECFormatClass = nil): Binary; override;
    procedure Calc(const Data; DataSize: Integer); override;
  published
    property RequestedDigestSize: Integer read FDigestSize write FDigestSize;
  end;

function  ValidHash(HashClass: TDECHashClass = nil): TDECHashClass;
function  HashByName(const Name: String): TDECHashClass;
function  HashByIdentity(Identity: LongWord): TDECHashClass;
procedure SetDefaultHashClass(HashClass: TDECHashClass);

var
  StreamBufferSize: Integer = 8192;

implementation

uses DECData;

{$I *.inc}

{                                        assembler                             pascal
THash_SHA512        :       85.1 cycles/byte      17.62 Mb/sec      220.9 cycles/byte       6.79 Mb/sec  159%
THash_SHA384        :       85.2 cycles/byte      17.61 Mb/sec      220.0 cycles/byte       6.82 Mb/sec  158%
THash_Tiger         :       24.6 cycles/byte      60.98 Mb/sec       60.7 cycles/byte      24.69 Mb/sec  147%
THash_Haval128      :       13.3 cycles/byte     112.55 Mb/sec       26.0 cycles/byte      57.77 Mb/sec   95%
THash_SHA1          :       20.1 cycles/byte      74.80 Mb/sec       36.1 cycles/byte      41.51 Mb/sec   80%
THash_SHA           :       20.0 cycles/byte      75.03 Mb/sec       35.5 cycles/byte      42.21 Mb/sec   78%
THash_Haval160      :       13.2 cycles/byte     113.30 Mb/sec       22.7 cycles/byte      66.12 Mb/sec   71%
THash_Haval256      :       25.9 cycles/byte      57.84 Mb/sec       40.5 cycles/byte      37.07 Mb/sec   56%
THash_Snefru128     :      159.7 cycles/byte       9.39 Mb/sec      248.2 cycles/byte       6.04 Mb/sec   55%
THash_Snefru256     :      239.3 cycles/byte       6.27 Mb/sec      367.9 cycles/byte       4.08 Mb/sec   54%
THash_RipeMD256     :       14.5 cycles/byte     103.16 Mb/sec       21.4 cycles/byte      70.08 Mb/sec   47%
THash_MD4           :        5.8 cycles/byte     256.73 Mb/sec        8.5 cycles/byte     176.92 Mb/sec   45%

THash_MD2           :      251.6 cycles/byte       5.96 Mb/sec      366.1 cycles/byte       4.10 Mb/sec   45%
THash_RipeMD128     :       15.2 cycles/byte      98.89 Mb/sec       21.2 cycles/byte      70.61 Mb/sec   40%
THash_RipeMD320     :       25.5 cycles/byte      58.73 Mb/sec       35.8 cycles/byte      41.87 Mb/sec   40%
THash_MD5           :        8.9 cycles/byte     169.43 Mb/sec       11.4 cycles/byte     131.01 Mb/sec   29%
THash_RipeMD160     :       26.5 cycles/byte      56.66 Mb/sec       31.4 cycles/byte      47.79 Mb/sec   19%
THash_Square        :       44.7 cycles/byte      33.58 Mb/sec       53.1 cycles/byte      28.23 Mb/sec   19%
THash_Haval192      :       32.5 cycles/byte      46.17 Mb/sec       37.6 cycles/byte      39.87 Mb/sec   18%
THash_Whirlpool1    :      104.9 cycles/byte      14.30 Mb/sec      122.8 cycles/byte      12.22 Mb/sec   17%
THash_Whirlpool     :      104.7 cycles/byte      14.33 Mb/sec      119.9 cycles/byte      12.51 Mb/sec   15%
THash_Sapphire      :       52.9 cycles/byte      28.35 Mb/sec       53.8 cycles/byte      27.86 Mb/sec    2%
THash_Haval224      :       32.0 cycles/byte      46.82 Mb/sec       32.3 cycles/byte      46.46 Mb/sec    1%
THash_SHA256        :       47.8 cycles/byte      31.35 Mb/sec       47.8 cycles/byte      31.39 Mb/sec    0%
THash_Panama        :        8.9 cycles/byte     169.01 Mb/sec        7.3 cycles/byte     206.55 Mb/sec  -18%
}

resourcestring
  sHashingOverflowError = 'Hash function have to many bits processed';
  sHashNotInitialized   = 'Hash must be initialized';
  sHashNoDefault        = 'No default hash are registered';

var
  FDefaultHashClass: TDECHashClass = nil;


function ValidHash(HashClass: TDECHashClass): TDECHashClass;
begin
  if HashClass <> nil then Result := HashClass
    else Result := FDefaultHashClass;
  if Result = nil then raise EDECException.Create(sHashNoDefault);
end;

function HashByName(const Name: String): TDECHashClass;
begin
  Result := TDECHashClass(DECClassByName(Name, TDECHash));
end;

function HashByIdentity(Identity: LongWord): TDECHashClass;
begin
  Result := TDECHashClass(DECClassByIdentity(Identity, TDECHash));
end;

procedure SetDefaultHashClass(HashClass: TDECHashClass);
begin
  if HashClass <> nil then HashClass.Register;
  FDefaultHashClass := HashClass;
end;

// .TDECHash
destructor TDECHash.Destroy;
begin
  ProtectBuffer(Digest^, DigestSize);
  ProtectBuffer(FBuffer^, FBufferSize);
  ReallocMem(FBuffer, 0);
  inherited Destroy;
end;

procedure TDECHash.Init;
begin
  FBufferIndex := 0;
  FBufferSize := BlockSize;
  ReallocMem(FBuffer, FBufferSize);
  FillChar(FBuffer^, FBufferSize, 0);
  FillChar(FCount, SizeOf(FCount), 0);
  DoInit;
end;

procedure TDECHash.Done;
begin
  DoDone;
  ProtectBuffer(FBuffer^, FBufferSize);
  FBufferSize := 0;
  ReallocMem(FBuffer, 0);
end;

procedure HashingOverflowError;
begin
  raise EDECException.Create(sHashingOverflowError);
end;

procedure HashNotInitialized;
begin
  raise EDECException.Create(sHashNotInitialized);
end;

procedure Increment8(var Value; Add: LongWord);
// Value := Value + 8 * Add
// Value: array[0..7] of LongWord
asm
    MOV  ECX,EDX
    LEA  EDX,[EDX * 8]
    SHR  ECX,25
    ADD  [EAX].DWord[ 0],EDX
    ADC  [EAX].DWord[ 4],ECX
    ADC  [EAX].DWord[ 8],0
    ADC  [EAX].DWord[12],0
    ADC  [EAX].DWord[16],0
    ADC  [EAX].DWord[20],0
    ADC  [EAX].DWord[24],0
    ADC  [EAX].DWord[28],0
    JC   HashingOverflowError
end;

procedure TDECHash.Calc(const Data; DataSize: Integer);
var
  Remain: Integer;
  Source: PByte;
begin
  if DataSize <= 0 then Exit;
  if FBuffer = nil then HashNotInitialized;
  Increment8(FCount, DataSize);
  Source := @TByteArray(Data)[0];
  if FBufferIndex > 0 then
  begin
    Remain := FBufferSize - FBufferIndex;
    if DataSize < Remain then
    begin
      Move(Source^, FBuffer[FBufferIndex], DataSize);
      Inc(FBufferIndex, DataSize);
      Exit;
    end;
    Move(Source^, FBuffer[FBufferIndex], Remain);
    DoTransform(Pointer(FBuffer));
    Dec(DataSize, Remain);
    Inc(Source, Remain);
  end;
  while DataSize >= FBufferSize do
  begin
    DoTransform(Pointer(Source));
    Inc(Source, FBufferSize);
    Dec(DataSize, FBufferSize);
  end;
  Move(Source^, FBuffer^, DataSize);
  FBufferIndex := DataSize;
end;

function TDECHash.DigestStr(Format: TDECFormatClass): Binary;
begin
  Result := ValidFormat(Format).Encode(Digest[0], DigestSize);
end;