messagedigests.pas

分析torrent的东西是拿别人的

end;

procedure TMD5.TransformBlocks(const Blocks; const BlockCount: Longint);
{
  Pre: Addr(Blocks) <> nil and Blocks is an exact integral number of blocks
       of size MD5BlockSize and BlockCount represents the number of blocks
       in Blocks.
  Post: Self will update its state to reflect the message digest after
        processing Blocks with the MD5 algorithm.
}
var
  I, J: Integer;
  T: TChainingVar;
  P: PMD5Block;
  A, B, C, D: TChainingVar;
begin
  P := Addr(Blocks);
  (*$IFNDEF PreDelphi3*)
    Assert(Assigned(P), 'TMD5.TransformBlocks: Addr(Blocks) = nil.');
    {
    Assert(BlockCount mod MD5BlockSize = 0,
           'TMD5.TransformBlocks: BlockCount mod MD5BlockSize <> 0.');
    }
  (*$ENDIF*)
  for I := 1 to BlockCount do begin
    { Initialize working variables. }
    A := PMD5ChainingVarArray(PChainingVars)^[mdA];
    B := PMD5ChainingVarArray(PChainingVars)^[mdB];
    C := PMD5ChainingVarArray(PChainingVars)^[mdC];
    D := PMD5ChainingVarArray(PChainingVars)^[mdD];
    { Round 1. }
    for J := 0 to 15 do begin
      T := A + ((B and C) or (not B and D)) + P^(.MD5Z[J].) + MD5Y[J];
      A := D;
      D := C;
      C := B;
      Inc(B, CircularSHL(T, MD5S[J]));
    end;
    { Round 2. }
    for J := 16 to 31 do begin
      T := A + ((B and D) or (C and not D)) + P^(.MD5Z[J].) + MD5Y[J];
      A := D;
      D := C;
      C := B;
      Inc(B, CircularSHL(T, MD5S[J]));
    end;
    { Round 3. }
    for J := 32 to 47 do begin
      T := A + (B xor C xor D) + P^(.MD5Z[J].) + MD5Y[J];
      A := D;
      D := C;
      C := B;
      Inc(B, CircularSHL(T, MD5S[J]));
    end;
    { Round 4. }
    for J := 48 to 63 do begin
      T := A + (C xor (B or not D)) + P^(.MD5Z[J].) + MD5Y[J];
      A := D;
      D := C;
      C := B;
      Inc(B, CircularSHL(T, MD5S[J]));
    end;
    Inc(P);
    { Update chaining values. }
    Inc(PMD5ChainingVarArray(PChainingVars)^[mdA], A);
    Inc(PMD5ChainingVarArray(PChainingVars)^[mdB], B);
    Inc(PMD5ChainingVarArray(PChainingVars)^[mdC], C);
    Inc(PMD5ChainingVarArray(PChainingVars)^[mdD], D);
  end;
  inherited;
end;

class function TMD5.AsString: string;
begin
  Result := 'MD5';
end;

{----------------------------------TSHA1---------------------------------------}


const
  SHAInitialChainingValues: TSHAChainingVarArray = (
   $67452301, $efcdab89, $98badcfe, $10325476, $c3d2e1f0
  );


constructor TSHA1.Create;
{
  Pre: None.
  Post: Returns an instance of class TSHA1, capable of computing message
        digests using the SHA-1 algorithm.
}
begin
  inherited CreateInternal(SHABlockSize, SHADigestSize,
                           SHAInitialChainingValues, True);
end;

destructor TSHA1.Destroy;
begin
  inherited;
end;

procedure TSHA1.TransformBlocks(const Blocks; const BlockCount: Longint);
{
  Pre: Addr(Blocks) <> nil and Blocks is an exact integral number of blocks
       of size SHABlockSize and BlockCount represents the number of blocks
       in Blocks and Blocks represents little-endian data. (This routine will
       swap bytes so that they are big-endian, in compliance with the SHA-1
       standard.) 
  Post: Self will update its state to reflect the message digest after
        processing Blocks with the SHA-1 algorithm.
}
type
  PSHAExpandedBlock = ^TSHABlock;
  TSHAExpandedBlock = array [0..79] of DWORD;
var
  I, J: Integer;
  T: TChainingVar;
  P: PSHABlock;
  A, B, C, D, E: TChainingVar;
  X: TSHAExpandedBlock;
begin
  P := Addr(Blocks);
  (*$IFNDEF PreDelphi3*)
    Assert(Assigned(P), 'TSHA1.TransformBlocks: Addr(Blocks) = nil.');
    {
    Assert(BlockCount mod SHABlockSize = 0,
           'TSHA1.TransformBlocks: BlockCount mod SHABlockSize <> 0.');
    }
  (*$ENDIF*)
  for I := 1 to BlockCount do begin
    Move(P^, X, SizeOf(P^));
    for J := Low(TSHABlock) to High(TSHABlock) do begin
      {
       The SHA-1 standard is big-endian. Intel machines are little-endian.
       We have to swap the bytes in the incoming stream, and swap them again
       when we output to the hash value.
      }
      with TFourByte(X[J]) do begin
        T := B1; B1 := B4; B4 := T;
        T := B2; B2 := B3; B3 := T;
      end;
    end;
    for J := 16 to 79 do begin
      X[J] := CircularSHL(X[J - 3] xor X[J - 8] xor X[J - 14] xor X[J - 16], 1);
    end;
    { Initialize working variables. }
    A := PSHAChainingVarArray(PChainingVars)^[shaA];
    B := PSHAChainingVarArray(PChainingVars)^[shaB];
    C := PSHAChainingVarArray(PChainingVars)^[shaC];
    D := PSHAChainingVarArray(PChainingVars)^[shaD];
    E := PSHAChainingVarArray(PChainingVars)^[shaE];
    { Round 1. }
    for J := 0 to 19 do begin
      T := CircularSHL(A, 5) + ((B and C) or (not B and D)) + E + X[J] + $5a827999;
      E := D;
      D := C;
      C := CircularSHL(B, 30);
      B := A;
      A := T;
    end;
    { Round 2. }
    for J := 20 to 39 do begin
      T := CircularSHL(A, 5) + (B xor C xor D) + E + X[J] + $6ed9eba1;
      E := D;
      D := C;
      C := CircularSHL(B, 30);
      B := A;
      A := T;
    end;
    { Round 3. }
    for J := 40 to 59 do begin
      T := CircularSHL(A, 5) + (B and C or B and D or C and D) +
           E + X[J] + $8f1bbcdc;
      E := D;
      D := C;
      C := CircularSHL(B, 30);
      B := A;
      A := T;
    end;
    { Round 4. }
    for J := 60 to 79 do begin
      T := CircularSHL(A, 5) + (B xor C xor D) + E + X[J] + $ca62c1d6;
      E := D;
      D := C;
      C := CircularSHL(B, 30);
      B := A;
      A := T;
    end;
    Inc(P);
    { Update chaining values. }
    Inc(PSHAChainingVarArray(PChainingVars)^[shaA], A);
    Inc(PSHAChainingVarArray(PChainingVars)^[shaB], B);
    Inc(PSHAChainingVarArray(PChainingVars)^[shaC], C);
    Inc(PSHAChainingVarArray(PChainingVars)^[shaD], D);
    Inc(PSHAChainingVarArray(PChainingVars)^[shaE], E);
  end;
  inherited;
end;

class function TSHA1.AsString: string;
begin
  Result := 'SHA-1';
end;

{-------------------------------TRIPEMD160-------------------------------------}


const
  RIPEMD160InitialChainingValues: TRIPEMD160ChainingVarArray = (
   $67452301, $efcdab89, $98badcfe, $10325476, $c3d2e1f0
  );

  { Compression. }
  RIPEMD160ZL: array [0..79] of Byte = (
    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
    7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
    3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
    1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
    4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13
  );

  RIPEMD160ZR: array [0..79] of Byte = (
    5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
    6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
   15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
    8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
   12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11
  );

  { Word access. }
  RIPEMD160SL: array [0..79] of Byte = (
   11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
    7,  6,  8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
   11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
   11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
    9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6
  );

  RIPEMD160SR: array [0..79] of Byte = (
    8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
    9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
    9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
   15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
    8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11
  );

constructor TRIPEMD160.Create;
{
  Pre: None.
  Post: Returns an instance of class TRIPEMD160, capable of computing message
        digests using the RIPEMD-160 algorithm.
}
begin
  inherited CreateInternal(RIPEMD160BlockSize, RIPEMD160DigestSize,
                           RIPEMD160InitialChainingValues, False);
end;

destructor TRIPEMD160.Destroy;
begin
  inherited;
end;

procedure TRIPEMD160.TransformBlocks(const Blocks; const BlockCount: Longint);
{
  Pre: Addr(Blocks) <> nil and Blocks is an exact integral number of blocks
       of size SHABlockSize and BlockCount represents the number of blocks
       in Blocks and Blocks represents little-endian data. (This routine will
       swap bytes so that they are big-endian, in compliance with the SHA-1
       standard.)
  Post: Self will update its state to reflect the message digest after
        processing Blocks with the SHA-1 algorithm.
}
var
  I, J: Integer;
  T: TChainingVar;
  P: PRIPEMD160Block;
  AL, BL, CL, DL, EL: TChainingVar;
  AR, BR, CR, DR, ER: TChainingVar;
begin
  P := Addr(Blocks);
  (*$IFNDEF PreDelphi3*)
    Assert(Assigned(P), 'TSHA1.TransformBlocks: Addr(Blocks) = nil.');
    {
    Assert(BlockCount mod SHABlockSize = 0,
           'TSHA1.TransformBlocks: BlockCount mod SHABlockSize <> 0.');
    }
  (*$ENDIF*)
  for I := 1 to BlockCount do begin
    { Initialize working variables. }
    AL := PRIPEMD160ChainingVarArray(PChainingVars)^[ripA];
    BL := PRIPEMD160ChainingVarArray(PChainingVars)^[ripB];
    CL := PRIPEMD160ChainingVarArray(PChainingVars)^[ripC];
    DL := PRIPEMD160ChainingVarArray(PChainingVars)^[ripD];
    EL := PRIPEMD160ChainingVarArray(PChainingVars)^[ripE];
    AR := AL;
    BR := BL;
    CR := CL;
    DR := DL;
    ER := EL;
    { LEFT LINE. }
    { Round 1.}
    for J := 0 to 15 do begin
      { Left side. }
      T := EL + CircularSHL(AL + (BL xor CL xor DL) + P^(.RIPEMD160ZL[J].) +
                            $00000000, RIPEMD160SL[J]);
      AL := EL;
      EL := DL;
      DL := CircularSHL(CL, 10);
      CL := BL;
      BL := T;
      { Right side. }
      T := ER + CircularSHL(AR + (BR xor (CR or not DR)) + P^(.RIPEMD160ZR[J].) +
                            $50a28be6, RIPEMD160SR[J]);
      AR := ER;
      ER := DR;
      DR := CircularSHL(CR, 10);
      CR := BR;
      BR := T;
    end;
    { Round 2.}
    for J := 16 to 31 do begin
      { Left side. }
      T := EL + CircularSHL(AL + ((BL and CL) or (not BL and DL)) +
                            P^(.RIPEMD160ZL[J].) + $5a827999, RIPEMD160SL[J]);
      AL := EL;
      EL := DL;
      DL := CircularSHL(CL, 10);
      CL := BL;
      BL := T;
      { Right side. }
      T := ER + CircularSHL(AR + (BR and DR or CR and not DR) +
                            P^(.RIPEMD160ZR[J].) + $5c4dd124, RIPEMD160SR[J]);
      AR := ER;
      ER := DR;
      DR := CircularSHL(CR, 10);
      CR := BR;
      BR := T;
    end;
    { Round 3.}
    for J := 32 to 47 do begin
      { Left side. }
      T := EL + CircularSHL(AL + ((BL or not CL) xor DL) + P^(.RIPEMD160ZL[J].) +
                            $6ed9eba1, RIPEMD160SL[J]);
      AL := EL;
      EL := DL;
      DL := CircularSHL(CL, 10);
      CL := BL;
      BL := T;
      { Right side. }
      T := ER + CircularSHL(AR + ((BR or not CR) xor DR) + P^(.RIPEMD160ZR[J].) +
                            $6d703ef3, RIPEMD160SR[J]);
      AR := ER;
      ER := DR;
      DR := CircularSHL(CR, 10);
      CR := BR;
      BR := T;
    end;
    { Round 4.}
    for J := 48 to 63 do begin
      { Left side. }
      T := EL + CircularSHL(AL + (BL and DL or CL and not DL) +
                            P^(.RIPEMD160ZL[J].) + $8f1bbcdc, RIPEMD160SL[J]);
      AL := EL;
      EL := DL;
      DL := CircularSHL(CL, 10);
      CL := BL;
      BL := T;
      { Right side. }
      T := ER + CircularSHL(AR + (BR and CR or not BR and DR) +
                            P^(.RIPEMD160ZR[J].) + $7a6d76e9, RIPEMD160SR[J]);
      AR := ER;
      ER := DR;
      DR := CircularSHL(CR, 10);
      CR := BR;
      BR := T;
    end;
    { Round 5.}
    for J := 64 to 79 do begin
      { Left side. }
      T := EL + CircularSHL(AL + (BL xor (CL or not DL)) + P^(.RIPEMD160ZL[J].) +
                            $a953fd4e, RIPEMD160SL[J]);
      AL := EL;
      EL := DL;
      DL := CircularSHL(CL, 10);
      CL := BL;
      BL := T;
      { Right side. }
      T := ER + CircularSHL(AR + (BR xor CR xor DR) + P^(.RIPEMD160ZR[J].) +
                            $00000000, RIPEMD160SR[J]);
      AR := ER;
      ER := DR;
      DR := CircularSHL(CR, 10);
      CR := BR;
      BR := T;
    end;
    { Update chaining values. }
    T := PRIPEMD160ChainingVarArray(PChainingVars)^[ripB] + CL + DR;
    PRIPEMD160ChainingVarArray(PChainingVars)^[ripB] :=
     PRIPEMD160ChainingVarArray(PChainingVars)^[ripC] + DL + ER;
    PRIPEMD160ChainingVarArray(PChainingVars)^[ripC] :=
     PRIPEMD160ChainingVarArray(PChainingVars)^[ripD] + EL + AR;
    PRIPEMD160ChainingVarArray(PChainingVars)^[ripD] :=
     PRIPEMD160ChainingVarArray(PChainingVars)^[ripE] + AL + BR;
    PRIPEMD160ChainingVarArray(PChainingVars)^[ripE] :=
     PRIPEMD160ChainingVarArray(PChainingVars)^[ripA] + BL + CR;
    PRIPEMD160ChainingVarArray(PChainingVars)^[ripA] := T;
    Inc(P);
  end;
  inherited;
end;

class function TRIPEMD160.AsString: string;
begin
  Result := 'RIPEMD-160';
end;

end.