{
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at http://mozilla.org/MPL/2.0/
*
* Copyright (C) 2010-2013, Peter Johnson (www.delphidabbler.com).
*
* $Rev$
* $Date$
*
* This unit is a Delphi Pascal implementation of the MD5 Message-Digest
* algorithm. See RFC1321 (http://www.faqs.org/rfcs/rfc1321.html).
*
* This work is derived from the RSA Data Security, Inc. MD5 Message-Digest
* Algorithm. The copyright notice is included in this project's documentation.
* The notice must be included with any redistribution of this work or any
* derived work.
*
* Portions of the code are based on the reference implementation from the RFC,
* translated into Pascal from the original C. The MD5 algorithm and the
* reference implementation are Copyright (C) 1991-2, RSA Data Security, Inc.
* Created 1991. All rights reserved.
}
unit PJMD5;
// Delphi 2009 or later is required to compile
// Delphi XE2 or later need RTL unit names to be qualified with namespace
{$UNDEF CANCOMPILE}
{$UNDEF RTLNAMESPACES}
{$IFDEF CONDITIONALEXPRESSIONS}
{$IF CompilerVersion >= 20.0} // Delphi 2009
{$DEFINE CANCOMPILE}
{$IFEND}
{$IF CompilerVersion >= 23.0} // Delphi XE2
{$DEFINE RTLNAMESPACES}
{$IFEND}
{$ENDIF}
{$IFNDEF CANCOMPILE}
{$MESSAGE FATAL 'Delphi 2009 or later required'}
{$ENDIF}
// Check assumptions about size of data types
{$IF SizeOf(LongWord) <> 4}
{$MESSAGE FATAL 'Size of LongWord assumed to be 4 bytes'}
{$IFEND}
{$IF SizeOf(UINT64) <> 8}
{$MESSAGE FATAL 'Size of UINT64 assumed to be 8 bytes'}
{$IFEND}
{$WARN UNSAFE_CODE OFF}
{$WARN UNSAFE_TYPE OFF}
{$WARN UNSAFE_CAST OFF}
interface
uses
{$IFNDEF RTLNAMESPACES}
SysUtils, Classes;
{$ELSE}
System.SysUtils, System.Classes;
{$ENDIF}
type
/// <summary>Class of exception raised by TPJMD5 and TPJMD5Digest.</summary>
EPJMD5 = class(Exception);
type
/// <summary>
/// Record that encapsulates an MD5 digest.
/// </summary>
/// <remarks>
/// <para>Provides alternative ways of accessing the digest data: as a byte
/// array, using the Bytes[] field, as a LongWord array, using the
/// LongWords[] field or as four named LongWord fields: A, B, C and D.</para>
/// <para>Overloaded operators permit equality testing with, and implicit
/// casting to and from, strings and byte arrays.</para>
/// </remarks>
TPJMD5Digest = packed record
strict private
/// <summary>Read accessor for Parts[] property.</summary>
function GetLongWord(Idx: Integer): LongWord;
public
/// <summary>Compares two TPJMD5Digest records for equality.</summary>
class operator Equal(const D1, D2: TPJMD5Digest): Boolean;
/// <summary>Compares a TPJMD5Digest record and a TBytes array for
/// equality.</summary>
class operator Equal(const D: TPJMD5Digest; const B: TBytes): Boolean;
/// <summary>Compares a TBytes arrays and a TPJMD5Digest record for
/// equality.</summary>
class operator Equal(const B: TBytes; const D: TPJMD5Digest): Boolean;
/// <summary>Compares a TPJMD5Digest record and a Unicode string for
/// equality.</summary>
class operator Equal(const D: TPJMD5Digest; const S: string): Boolean;
/// <summary>Compares a Unicode string and a TPJMD5Digest record for
/// equality.</summary>
class operator Equal(const S: string; const D: TPJMD5Digest): Boolean;
/// <summary>Compares two TPJMD5Digest records for inequality.</summary>
class operator NotEqual(const D1, D2: TPJMD5Digest): Boolean;
/// <summary>Compares a TPJMD5Digest record and a TBytes array for
/// inequality.</summary>
class operator NotEqual(const D: TPJMD5Digest; const B: TBytes): Boolean;
/// <summary>Compares a TBytes arrays and a TPJMD5Digest record for
/// inequality.</summary>
class operator NotEqual(const B: TBytes; const D: TPJMD5Digest): Boolean;
/// <summary>Compares a TPJMD5Digest record and a Unicode string for
/// inequality.</summary>
class operator NotEqual(const D: TPJMD5Digest; const S: string): Boolean;
/// <summary>Compares a Unicode string and a TPJMD5Digest record for
/// inequality.</summary>
class operator NotEqual(const S: string; const D: TPJMD5Digest): Boolean;
/// <summary>Creates a 32 character hexadecimal Unicode string
/// representation of digest D.</summary>
class operator Implicit(const D: TPJMD5Digest): string;
/// <summary>Creates a TPJMD5Digest record from Unicode string S by
/// interpreting S as hexadecimal.</summary>
/// <remarks>S must have exactly 32 characters and may contain only valid
/// hexadecimal characters.</remarks>
class operator Implicit(const S: string): TPJMD5Digest;
/// <summary>Creates an array of bytes from the data contained in
/// TPJMD5Digest record D.</summary>
/// <remarks>The resulting byte array contains a copy of the record's
/// Bytes field.</remarks>
class operator Implicit(const D: TPJMD5Digest): TBytes;
/// <summary>Creates a TPJMD5Digest record from the data contained in byte
/// array B.</summary>
/// <remarks>B must have at least 16 elements. If B has more than 16
/// elements, elements from B[16] onwards are ignored.</remarks>
class operator Implicit(const B: TBytes): TPJMD5Digest;
/// <summary>Default array property that permits access to the long words
/// of the digest by index.</summary>
/// <remarks>Provided mainly to permit the record to be directly indexed:
/// D[Idx], D.Parts[Idx] and D.LongWords[Idx] are all equivalent if D is a
/// TPJMD5Digest.</remarks>
property Parts[Idx: Integer]: LongWord read GetLongWord; default;
/// <summary>Variant record that provides access to the digest as an array
/// of bytes, an array of LongWords or as LongWord fields named A, B, C and
/// D.</summary>
case Integer of
0: (
/// <summary>Digest's data represented as an array of bytes.</summary>
Bytes: packed array[0..15] of Byte
);
1: (
/// <summary>Digest's data represented as an array of long words.
/// </summary>
LongWords: packed array[0..3] of LongWord
);
2: (
/// <summary>First long word of digest's data.</summary>
/// <remarks>Equivalent to LongWords[0].</remarks>
A: LongWord;
/// <summary>Second long word of digest's data.</summary>
/// <remarks>Equivalent to LongWords[1].</remarks>
B: LongWord;
/// <summary>Third long word of digest's data.</summary>
/// <remarks>Equivalent to LongWords[2].</remarks>
C: LongWord;
/// <summary>Fourth long word of digest's data.</summary>
/// <remarks>Equivalent to LongWords[3].</remarks>
D: LongWord;
);
end;
type
/// <summary>
/// Class that implements the MD5 message digest algorithm.
/// </summary>
/// <remarks>
/// <para>Digests of single data sources can be created with one call to one
/// of the overloaded Calculate or the CalculateFile class methods.</para>
/// <para>Multiple data sources can be added to a digest using the one of the
/// overloaded Process or the ProcessFile methods. Each method updates the
/// current digest. Finalize ends processing and creates the digest which is
/// accessed via the Digest property.</para>
/// </remarks>
TPJMD5 = class(TObject)
strict private
const
/// <summary>Size, in long words, of a data block (chunk).</summary>
BlockSize = 16;
/// <summary>Size, in bytes, of a data chunk.</summary>
ChunkSize = SizeOf(LongWord) * BlockSize;
type
/// <summary>Data chunk.</summary>
/// <remarks>One chunk is processed at a time by Transform method.
/// </remarks>
TMDChunk = array[0..Pred(ChunkSize)] of Byte;
type
/// <summary>Buffer storing bytes to be processed.</summary>
TMDBuffer = record
/// <summary>Stores data being (or to be) processed.</summary>
Data: TMDChunk;
/// <summary>Current position in data storage.</summary>
Cursor: Byte;
/// <summary>Informs if Data buffer is empty.</summary>
function IsEmpty: Boolean;
/// <summary>Informs if Data buffer is full of data.</summary>
function IsFull: Boolean;
/// <summary>Returns amount of space remaining in Data buffer.
/// </summary>
function SpaceRemaining: Byte;
/// <summary>Copies Count bytes starting at index StartIdx from Bytes
/// array into Data buffer.</summary>
procedure Copy(const Bytes: array of Byte; const StartIdx: Cardinal;
const Count: Cardinal);
/// <summary>Clears and zeroes the Data buffer.</summary>
procedure Clear;
end;
var
/// <summary>Current state of digest.</summary>
fState: TPJMD5Digest;
/// <summary>Value of Digest property.</summary>
fDigest: TPJMD5Digest;
/// <summary>Value of Finalized property.</summary>
fFinalized: Boolean;
/// <summary>Number of bytes processed.</summary>
fByteCount: UINT64;
/// <summary>Buffer that stores unprocessed data.</summary>
fBuffer: TMDBuffer;
/// <summary>Value of ReadBufferSize property.</summary>
fReadBufferSize: Cardinal;
/// <summary>Getter for Digest property. Finalizes digest and returns it.
/// </summary>
function GetDigest: TPJMD5Digest;
/// <summary>Transforms byte array Bytes from starting position StartIdx,
/// updating digest.</summary>
procedure Transform(const Bytes: array of Byte; const StartIdx: Cardinal);
/// <summary>Updates digest by processing Count bytes from byte array X,
/// starting at index StartIdx. Any unprocessed bytes are buffered.
/// </summary>
procedure Update(const X: array of Byte; const StartIdx, Count: Cardinal);
/// <summary>Creates a TBytes array containing a copy of a given number of
/// bytes from a given untyped buffer.</summary>
class function BufferToBytes(const Buf; const ByteCount: Cardinal): TBytes;
/// <summary>Helper method to perform calculations of digests for most
/// Calculate methods.</summary>
/// <remarks>Calls anonymous method DoProcess to perform the actual
/// processing.</remarks>
class function DoCalculate(const DoProcess: TProc<TPJMD5>): TPJMD5Digest;
public
const
/// <summary>Default size of buffer for block reads from streams and
/// files.</summary>
DefReadBufferSize = 64 * 1024; // 64Kb
public
/// <summary>Object constructor. Sets up object and begins a new digest.
/// </summary>
constructor Create;
/// <summary>Object destructor. Tears down object.</summary>
destructor Destroy; override;
/// <summary>Calculates a digest of Count bytes read from byte array X,
/// starting at index StartIdx.</summary>
/// <remarks>
/// <para>Raises a EPJMD5 exception if there are less than Count bytes from
/// StartIdx to the end of the array.</para>
/// <para>If StartIdx is beyond the end of the array then no data is
/// processed.</para>
/// </remarks>
class function Calculate(const X: TBytes; const StartIdx, Count: Cardinal):
TPJMD5Digest; overload;
/// <summary>Calculates a digest of Count bytes read from byte array X.
/// </summary>
/// <remarks>Raises an EPJMD5 exception if Count is greater than the number
/// of elements in X.</remarks>
class function Calculate(const X: TBytes; const Count: Cardinal):
TPJMD5Digest; overload;
/// <summary>Calculates a digest of all the bytes of byte array X.
/// </summary>
class function Calculate(const X: TBytes): TPJMD5Digest; overload;
/// <summary>Calculates a digest of Count bytes read from untyped buffer
/// Buf.</summary>
/// <remarks>Buf must contain at least Count bytes (this is not checked).
/// </remarks>
class function Calculate(const Buf; const Count: Cardinal): TPJMD5Digest;
overload;
/// <summary>Calculates a digest of the characters of ANSI string S.
/// </summary>
class function Calculate(const S: RawByteString): TPJMD5Digest; overload;
/// <summary>Calculates a digest of the characters of short string S.
/// </summary>
class function Calculate(const S: ShortString): TPJMD5Digest; overload;
/// <summary>Calculates a digest of all the wide characters of wide string
/// S.</summary>
class function Calculate(const S: WideString): TPJMD5Digest; overload;
/// <summary>Calculates a digest of the bytes of Unicode string S according
/// to the given encoding.</summary>
class function Calculate(const S: UnicodeString;
const Encoding: TEncoding): TPJMD5Digest; overload;
/// <summary>Calculates a digest of the bytes of Unicode string S according
/// to the default encoding.</summary>
class function Calculate(const S: UnicodeString): TPJMD5Digest; overload;
/// <summary>Calculates a digest of the bytes from the current position to
/// the end of the given Stream.</summary>
/// <remarks>The stream is read in chunks of size DefReadBufferSize.
/// </remarks>
class function Calculate(const Stream: TStream): TPJMD5Digest; overload;
/// <summary>Calculates a digest of up to Count bytes from the current
/// position in the given stream.</summary>
/// <remarks>
/// <para>If Count is greater than available bytes in stream, an EPJMD5
/// exception is raised.</para>
/// <para>The stream is read in chunks of size DefReadBufferSize.</para>
/// </remarks>
class function Calculate(const Stream: TStream;
const Count: Int64): TPJMD5Digest; overload;
/// <summary>Calculates a digest of all the bytes of the named file.
/// </summary>
/// <remarks>The file is read in chunks of size DefReadBufferSize.
/// </remarks>
class function CalculateFile(const FileName: TFileName): TPJMD5Digest;
/// <summary>Adds Count bytes from byte array X, starting at index
/// StartIdx, to the digest.</summary>
/// <remarks>
/// <para>If there are less than Count bytes from StartIdx to the end of
/// the array then an EPJMD5 exception is raised.</para>
/// <para>If StartIdx is beyond the end of the array or if Count is zero
/// then there is nothing to do and the digest remains unchanged.</para>
/// </remarks>
procedure Process(const X: TBytes; const StartIdx, Count: Cardinal);
overload;
/// <summary>Adds Count bytes from a byte array X to the digest.</summary>
/// <remarks>If Count is greater than the size of the array an EPJMD5
/// exception is raised.</remarks>
procedure Process(const X: TBytes; const Count: Cardinal); overload;
/// <summary>Adds all the bytes from a byte array X to the digest.
/// </summary>
procedure Process(const X: TBytes); overload;
/// <summary>Adds Count bytes from untyped buffer Buf to the digest.
/// </summary>
/// <remarks>Buf must contain sufficient data (this is not checked).
/// </remarks>
procedure Process(const Buf; const Count: Cardinal); overload;
/// <summary>Adds all the characters from ANSI string S as bytes to the
/// digest.</summary>
procedure Process(const S: RawByteString); overload;
/// <summary>Adds all the characters from short string S as bytes to the
/// digest.</summary>
procedure Process(const S: ShortString); overload;
/// <summary>Adds all the wide characters from wide string S to the digest.
/// </summary>
procedure Process(const S: WideString); overload;
/// <summary>Adds bytes from Unicode string S, according to the given
/// encoding, to the digest.</summary>
procedure Process(const S: UnicodeString; const Encoding: TEncoding);
overload;
/// <summary>Adds bytes from Unicode string S, according to the Default
/// encoding, to the digest.</summary>
procedure Process(const S: UnicodeString); overload;
/// <summary>Adds bytes to the digest from a stream starting from the
/// current position up to the end of the stream.</summary>
/// <remarks>
/// <para>An EPJMD5 exception is raised if Stream is nil</para>
/// <para>The stream is read in chunks of size ReadBufferSize.</para>
/// </remarks>
procedure Process(const Stream: TStream); overload;
/// <summary>Adds up to Count bytes from to the digest from a stream,
/// starting from the current position.</summary>
/// <remarks>
/// <para>If Count is greater than available bytes in stream an EPJMD5
/// exception is raised. If Count is -ve it is treated as if it were 0.
/// </para>
/// <para>An EPJMD5 exception is raised if Stream is nil</para>
/// <para>The stream is read in chunks of size ReadBufferSize.</para>
/// </remarks>
procedure Process(const Stream: TStream; const Count: Int64); overload;
/// <summary>Adds all the bytes from the named file to the digest.
/// </summary>
/// <remarks>The file is read in chunks of size ReadBufferSize.</remarks>
procedure ProcessFile(const FileName: TFileName);
/// <summary>Discards any current digest, whether finalized or not.
/// </summary>
/// <remarks>Sets the Finalized property to False.</remarks>
procedure Reset;
/// <summary>Finalizes the current digest.</summary>
/// <remarks>Sets the Finalized property to True. An exception will be
/// raised if any Process method is called after finalization.</remarks>
procedure Finalize;
/// <summary>Returns the MD5 digest.</summary>
/// <remarks>Referencing this property finalizes the digest by calling
/// Finalize. The Finalized property is set to True. Once the property is
/// read no further data can be added to the digest.</remarks>
property Digest: TPJMD5Digest read GetDigest;
/// <summary>Gets and sets the size of buffer used when reading from stream
/// or files.</summary>
property ReadBufferSize: Cardinal
read fReadBufferSize write fReadBufferSize default DefReadBufferSize;
/// <summary>Informs if the digest has been finalized.</summary>
/// <remarks>It is an error to process any further data once the digest has
/// been finalized.</remarks>
property Finalized: Boolean read fFinalized;
end;
implementation
uses
{$IFNDEF RTLNAMESPACES}
Math;
{$ELSE}
System.Math;
{$ENDIF}
/// <summary>Rotates LongWord X left by N bits.</summary>
function RotateLeft(const X: LongWord; const N: Byte): LongWord; inline;
begin
Result := (X shl N) or (X shr (32 - N));
end;
/// <summary>Generalisation of MD5 transformations for rounds 1 to 4.</summary>
procedure Transformer(var A: LongWord; const B, C, D, X: LongWord;
const S: Byte; const AC: LongWord;
const Fn: TFunc<LongWord, LongWord, LongWord, LongWord>);
begin
A := RotateLeft(A + Fn(B, C, D) + X + AC, S) + B;
end;
/// <summary>MD5 transformation for "round 1".</summary>
procedure FF(var A: LongWord; const B, C, D, X: LongWord; const S: Byte;
const AC: LongWord);
begin
Transformer(
A, B, C, D, X, S, AC,
function (X, Y, Z: LongWord): LongWord
begin
// this is the MD5 basic function "F" in reference implementation
Result := (X and Y) or ((not X) and Z);
end
);
end;
/// <summary>MD5 transformation for "round 2".</summary>
procedure GG(var A: LongWord; const B, C, D, X: LongWord; const S: Byte;
const AC: LongWord);
begin
Transformer(
A, B, C, D, X, S, AC,
function (X, Y, Z: LongWord): LongWord
begin
// this is the MD5 basic function "G" in reference implementation
Result := (X and Z) or (Y and not Z);
end
);
end;
/// <summary>MD5 transformation for "round 3".</summary>
procedure HH(var A: LongWord; const B, C, D, X: LongWord; const S: Byte;
const AC: LongWord);
begin
Transformer(
A, B, C, D, X, S, AC,
function (X, Y, Z: LongWord): LongWord
begin
// this is the MD5 basic function "H" in reference implementation
Result := X xor Y xor Z;
end
);
end;
/// <summary>MD5 transformation for "round 4".</summary>
procedure II(var A: LongWord; const B, C, D, X: LongWord; const S: Byte;
const AC: LongWord);
begin
Transformer(
A, B, C, D, X, S, AC,
function (X, Y, Z: LongWord): LongWord
begin
// this is the MD5 basic function "I" in reference implementation
Result := Y xor (X or not Z);
end
);
end;
resourcestring
// Error messages
sAlreadyFinalized = 'Can''t update a finalised digest';
sBadMD5StrLen = 'Can''t cast string of length %d to TPJMD5Digest';
sBadMD5StrChars = 'Can''t cast string %s to TPJMD5Digest: invalid hex digits';
sByteArrayTooShort = 'Can''t cast TBytes array of length %d to TPJMD5Digest: '
+ 'it is too short';
sStreamTooShort = 'Can''t read %0:d bytes from stream. '
+ 'Only %1:d bytes remaining';
sTBytesTooShort = 'Can''t read %0:d bytes from array of length %1:d';
sTBytesIndexTooShort = 'Can''t read %0:d bytes from array of length %1:d '
+ 'starting at index %2:d';
sStreamIsNil = 'Can''t read from stream: stream is nil';
{ TPJMD5 }
class function TPJMD5.BufferToBytes(const Buf; const ByteCount: Cardinal):
TBytes;
begin
SetLength(Result, ByteCount);
if ByteCount > 0 then
Move(Buf, Pointer(Result)^, ByteCount);
end;
class function TPJMD5.Calculate(const Buf; const Count: Cardinal): TPJMD5Digest;
begin
// Can't call DoCalculate with callback anonymous method because Buf is not
// recognised by the compiler in the callback.
with Create do
try
Process(Buf, Count);
Result := Digest;
finally
Free;
end;
end;
class function TPJMD5.Calculate(const S: RawByteString): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(S); end
);
end;
class function TPJMD5.Calculate(const X: TBytes): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(X); end
);
end;
class function TPJMD5.Calculate(const X: TBytes;
const Count: Cardinal): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(X, Count); end
);
end;
class function TPJMD5.Calculate(const X: TBytes; const StartIdx,
Count: Cardinal): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(X, StartIdx, Count); end
);
end;
class function TPJMD5.Calculate(const Stream: TStream): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(Stream); end
);
end;
class function TPJMD5.Calculate(const Stream: TStream;
const Count: Int64): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(Stream, Count); end
);
end;
class function TPJMD5.Calculate(const S: WideString): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(S); end
);
end;
class function TPJMD5.Calculate(const S: ShortString): TPJMD5Digest;
var
SS: ShortString; // copy of parameter S
begin
// this assignement required since close below can't capture parameter S
SS := S;
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(SS); end
);
end;
class function TPJMD5.Calculate(const S: UnicodeString): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(S); end
);
end;
class function TPJMD5.Calculate(const S: UnicodeString;
const Encoding: TEncoding): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.Process(S, Encoding); end
);
end;
class function TPJMD5.CalculateFile(const FileName: TFileName): TPJMD5Digest;
begin
Result := DoCalculate(
procedure(Instance: TPJMD5) begin Instance.ProcessFile(FileName); end
);
end;
constructor TPJMD5.Create;
begin
inherited Create;
Reset;
fReadBufferSize := DefReadBufferSize;
end;
destructor TPJMD5.Destroy;
begin
fBuffer.Clear;
inherited;
end;
class function TPJMD5.DoCalculate(const DoProcess: TProc<TPJMD5>): TPJMD5Digest;
var
Instance: TPJMD5;
begin
Instance := TPJMD5.Create;
try
DoProcess(Instance);
Result := Instance.Digest;
finally
Instance.Free;
end;
end;
procedure TPJMD5.Finalize;
var
Offset: Cardinal;
PadLen: Cardinal;
BitCount: UINT64;
BitCountBytes: TBytes;
const
// Padding applied to end of data stream is a subset of these bytes
Padding: array[0..63] of Byte = (
$80, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00,
$00, $00, $00, $00, $00, $00, $00, $00
);
begin
if fFinalized then
Exit;
// Total bytes must be multiple of 64 and end with $80 followed by 0 or more
// $00 bytes and terminate in 8 byte bit count.
// Calculate bit count, letting it wrap round if necessary. This must be done
// before padding added to digest because this changes fByteCount. Wrapping
// round requires that range check are off.
{$IFOPT R+}
{$DEFINE RANGECHECKS}
{$R-}
{$ELSE}
{$UNDEF RANGECHECKS}
{$ENDIF}
BitCount := 8 * fByteCount;
{$IFDEF RANGECHECKS}
{$R+}
{$ENDIF}
// Update digest with required padding bytes
Offset := fByteCount mod 64;
if Offset < (64 - SizeOf(BitCount)) then
// below 56th byte
PadLen := (64 - SizeOf(BitCount)) - Offset
else
// at or beyond 56th byte
PadLen := (128 - SizeOf(BitCount)) - Offset;
Update(Padding, 0, PadLen);
// Update digest with bit count: these are last 8 bytes
BitCountBytes := BufferToBytes(BitCount, SizeOf(BitCount));
Update(BitCountBytes, 0, Length(BitCountBytes));
Assert(fBuffer.IsEmpty);
fDigest := fState;
fFinalized := True;
end;
function TPJMD5.GetDigest: TPJMD5Digest;
begin
if not fFinalized then
Finalize;
Result := fDigest;
end;
procedure TPJMD5.Process(const S: UnicodeString; const Encoding: TEncoding);
begin
Process(Encoding.GetBytes(S));
end;
procedure TPJMD5.Process(const S: UnicodeString);
begin
Process(S, TEncoding.Default);
end;
procedure TPJMD5.Process(const Buf; const Count: Cardinal);
var
Bytes: TBytes;
BytesToRead: Cardinal;
BufSize: Cardinal;
BufPtr: PByte;
begin
BufPtr := @Buf;
BytesToRead := Count;
while BytesToRead > 0 do
begin
BufSize := Min(fReadBufferSize, BytesToRead);
Bytes := BufferToBytes(BufPtr^, BufSize);
Process(Bytes);
Dec(BytesToRead, BufSize);
Inc(BufPtr, BufSize);
end;
end;
procedure TPJMD5.Process(const S: RawByteString);
begin
Process(BufferToBytes(Pointer(S)^, Length(S) * SizeOf(AnsiChar)));
end;
procedure TPJMD5.Process(const Stream: TStream);
begin
Process(Stream, Stream.Size - Stream.Position);
end;
procedure TPJMD5.Process(const Stream: TStream; const Count: Int64);
var
BytesRead: Cardinal;
BytesToRead: Int64;
Bytes: TBytes;
begin
if not Assigned(Stream) then
raise EPJMD5.Create(sStreamIsNil);
if Count > Stream.Size - Stream.Position then
raise EPJMD5.CreateFmt(
sStreamTooShort, [Count, Stream.Size - Stream.Position]
);
BytesToRead := Max(Count, 0); // prevent Count < 0: use 0 in this case
SetLength(Bytes, fReadBufferSize);
while BytesToRead > 0 do
begin
BytesRead := Stream.Read(
Pointer(Bytes)^, Min(fReadBufferSize, BytesToRead)
);
Process(Bytes, BytesRead);
Dec(BytesToRead, BytesRead);
end;
end;
procedure TPJMD5.Process(const S: WideString);
begin
Process(BufferToBytes(Pointer(S)^, Length(S) * SizeOf(WideChar)));
end;
procedure TPJMD5.Process(const S: ShortString);
begin
Process(BufferToBytes(S[1], Length(S) * SizeOf(AnsiChar)));
end;
procedure TPJMD5.Process(const X: TBytes);
begin
Update(X, 0, Length(X));
end;
procedure TPJMD5.Process(const X: TBytes; const Count: Cardinal);
begin
if Count = 0 then
Exit;
if Count > Cardinal(Length(X)) then
raise EPJMD5.CreateFmt(sTBytesTooShort, [Count, Length(X)]);
Update(X, 0, Count);
end;
procedure TPJMD5.Process(const X: TBytes; const StartIdx, Count: Cardinal);
begin
if (StartIdx >= Cardinal(Length(X))) or (Count = 0) then
Exit;
if StartIdx + Count > Cardinal(Length(X)) then
raise EPJMD5.CreateFmt(sTBytesIndexTooShort, [Count, Length(X), StartIdx]);
Update(X, StartIdx, Count);
end;
procedure TPJMD5.ProcessFile(const FileName: TFileName);
var
Stm: TFileStream;
begin
Stm := TFileStream.Create(FileName, fmOpenRead or fmShareDenyNone);
try
Process(Stm);
finally
Stm.Free;
end;
end;
procedure TPJMD5.Reset;
begin
fState.A := $67452301;
fState.B := $efcdab89;
fState.C := $98badcfe;
fState.D := $10325476;
FillChar(fDigest, SizeOf(fDigest), 0);
fBuffer.Clear; // flags buffer as empty
fFinalized := False;
fByteCount := 0;
end;
procedure TPJMD5.Transform(const Bytes: array of Byte;
const StartIdx: Cardinal);
const
// Constants for transformation routines FF, GG, HH and II.
S11 = 7; S12 = 12; S13 = 17; S14 = 22;
S21 = 5; S22 = 9; S23 = 14; S24 = 20;
S31 = 4; S32 = 11; S33 = 16; S34 = 23;
S41 = 6; S42 = 10; S43 = 15; S44 = 21;
var
Block: array[0..Pred(BlockSize)] of LongWord;
A, B, C, D: LongWord;
begin
Assert(SizeOf(Block) = SizeOf(TMDChunk));
Assert(UInt64(Length(Bytes)) - StartIdx >= SizeOf(TMDChunk));
// Store states
A := fState.A;
B := fState.B;
C := fState.C;
D := fState.D;
// Copy bytes from given start index into Block, low order bytes 1st
Move(Bytes[StartIdx], Block[0], SizeOf(Block));
// Round 1
FF(A, B, C, D, Block[ 0], S11, $d76aa478); // 1
FF(D, A, B, C, Block[ 1], S12, $e8c7b756); // 2
FF(C, D, A, B, Block[ 2], S13, $242070db); // 3
FF(B, C, D, A, Block[ 3], S14, $c1bdceee); // 4
FF(A, B, C, D, Block[ 4], S11, $f57c0faf); // 5
FF(D, A, B, C, Block[ 5], S12, $4787c62a); // 6
FF(C, D, A, B, Block[ 6], S13, $a8304613); // 7
FF(B, C, D, A, Block[ 7], S14, $fd469501); // 8
FF(A, B, C, D, Block[ 8], S11, $698098d8); // 9
FF(D, A, B, C, Block[ 9], S12, $8b44f7af); // 10
FF(C, D, A, B, Block[10], S13, $ffff5bb1); // 11
FF(B, C, D, A, Block[11], S14, $895cd7be); // 12
FF(A, B, C, D, Block[12], S11, $6b901122); // 13
FF(D, A, B, C, Block[13], S12, $fd987193); // 14
FF(C, D, A, B, Block[14], S13, $a679438e); // 15
FF(B, C, D, A, Block[15], S14, $49b40821); // 16
// Round 2
GG(A, B, C, D, Block[ 1], S21, $f61e2562); // 17
GG(D, A, B, C, Block[ 6], S22, $c040b340); // 18
GG(C, D, A, B, Block[11], S23, $265e5a51); // 19
GG(B, C, D, A, Block[ 0], S24, $e9b6c7aa); // 20
GG(A, B, C, D, Block[ 5], S21, $d62f105d); // 21
GG(D, A, B, C, Block[10], S22, $2441453); // 22
GG(C, D, A, B, Block[15], S23, $d8a1e681); // 23
GG(B, C, D, A, Block[ 4], S24, $e7d3fbc8); // 24
GG(A, B, C, D, Block[ 9], S21, $21e1cde6); // 25
GG(D, A, B, C, Block[14], S22, $c33707d6); // 26
GG(C, D, A, B, Block[ 3], S23, $f4d50d87); // 27
GG(B, C, D, A, Block[ 8], S24, $455a14ed); // 28
GG(A, B, C, D, Block[13], S21, $a9e3e905); // 29
GG(D, A, B, C, Block[ 2], S22, $fcefa3f8); // 30
GG(C, D, A, B, Block[ 7], S23, $676f02d9); // 31
GG(B, C, D, A, Block[12], S24, $8d2a4c8a); // 32
// Round 3
HH(A, B, C, D, Block[ 5], S31, $fffa3942); // 33
HH(D, A, B, C, Block[ 8], S32, $8771f681); // 34
HH(C, D, A, B, Block[11], S33, $6d9d6122); // 35
HH(B, C, D, A, Block[14], S34, $fde5380c); // 36
HH(A, B, C, D, Block[ 1], S31, $a4beea44); // 37
HH(D, A, B, C, Block[ 4], S32, $4bdecfa9); // 38
HH(C, D, A, B, Block[ 7], S33, $f6bb4b60); // 39
HH(B, C, D, A, Block[10], S34, $bebfbc70); // 40
HH(A, B, C, D, Block[13], S31, $289b7ec6); // 41
HH(D, A, B, C, Block[ 0], S32, $eaa127fa); // 42
HH(C, D, A, B, Block[ 3], S33, $d4ef3085); // 43
HH(B, C, D, A, Block[ 6], S34, $4881d05); // 44
HH(A, B, C, D, Block[ 9], S31, $d9d4d039); // 45
HH(D, A, B, C, Block[12], S32, $e6db99e5); // 46
HH(C, D, A, B, Block[15], S33, $1fa27cf8); // 47
HH(B, C, D, A, Block[ 2], S34, $c4ac5665); // 48
// Round 4
II(A, B, C, D, Block[ 0], S41, $f4292244); // 49
II(D, A, B, C, Block[ 7], S42, $432aff97); // 50
II(C, D, A, B, Block[14], S43, $ab9423a7); // 51
II(B, C, D, A, Block[ 5], S44, $fc93a039); // 52
II(A, B, C, D, Block[12], S41, $655b59c3); // 53
II(D, A, B, C, Block[ 3], S42, $8f0ccc92); // 54
II(C, D, A, B, Block[10], S43, $ffeff47d); // 55
II(B, C, D, A, Block[ 1], S44, $85845dd1); // 56
II(A, B, C, D, Block[ 8], S41, $6fa87e4f); // 57
II(D, A, B, C, Block[15], S42, $fe2ce6e0); // 58
II(C, D, A, B, Block[ 6], S43, $a3014314); // 59
II(B, C, D, A, Block[13], S44, $4e0811a1); // 60
II(A, B, C, D, Block[ 4], S41, $f7537e82); // 61
II(D, A, B, C, Block[11], S42, $bd3af235); // 62
II(C, D, A, B, Block[ 2], S43, $2ad7d2bb); // 63
II(B, C, D, A, Block[ 9], S44, $eb86d391); // 64
// Update state from results
Inc(fState.A, A);
Inc(fState.B, B);
Inc(fState.C, C);
Inc(fState.D, D);
// For security
FillChar(Block, SizeOf(Block), 0);
end;
procedure TPJMD5.Update(const X: array of Byte;
const StartIdx, Count: Cardinal);
var
BytesLeft: Cardinal;
BytesToCopy: Cardinal;
begin
if fFinalized then
raise EPJMD5.Create(sAlreadyFinalized);
if (Length(X) = 0) or (Count = 0) then
Exit;
BytesLeft := Count;
if not fBuffer.IsEmpty then
begin
// buffer contains some data: we must add our new data here until buffer is
// full or we have no more data
// we add either sufficient data to fill buffer or all we've got if its less
// than remaining space in buffer
BytesToCopy := Min(fBuffer.SpaceRemaining, BytesLeft);
fBuffer.Copy(X, StartIdx + Count - BytesLeft, BytesToCopy);
Inc(fByteCount, BytesToCopy);
Dec(BytesLeft, BytesToCopy);
if fBuffer.IsFull then
begin
// if we filled buffer we Transform the digest from it and empty it
Transform(fBuffer.Data, 0);
fBuffer.Clear;
end;
end;
// if we have more than a buffers worth of data we Transform the digest from
// it until there's less than a buffer's worth left
while BytesLeft >= ChunkSize do
begin
Transform(X, StartIdx + Count - BytesLeft);
Inc(fByteCount, ChunkSize);
Dec(BytesLeft, ChunkSize);
end;
// the following assertion must be true because:
// case 1: buffer is empty and above loop only terminates when X has less
// than ChunkSize bytes remaining
// case 2: X had less than enough bytes to fill buffer so they were all copied
// there => X has no bytes left
Assert((BytesLeft = 0) or (fBuffer.IsEmpty and (BytesLeft < ChunkSize)));
// above assertion implies following because:
// case 1: if ByteLeft = 0 it must be <= space remaining in buffer
// case 2: if ByteLeft <> 0 it is less than ChunkSize which is equal to
// buffer space remaining since buffer is empty
Assert(BytesLeft <= fBuffer.SpaceRemaining);
if BytesLeft > 0 then
begin
// we have bytes left over (which must be less than space remaining)
// we copy all the remaining bytes to the buffer and, if it gets full we
// Transform the digest from the buffer and empty it
fBuffer.Copy(X, StartIdx + Count - BytesLeft, BytesLeft);
Inc(fByteCount, BytesLeft);
if fBuffer.IsFull then
begin
Transform(fBuffer.Data, 0);
fBuffer.Clear;
end;
end;
end;
{ TPJMD5.TMDBuffer }
procedure TPJMD5.TMDBuffer.Clear;
var
I: Integer;
begin
for I := 0 to Length(Data) - 1 do
Data[I] := 0;
Cursor := 0;
end;
procedure TPJMD5.TMDBuffer.Copy(const Bytes: array of Byte;
const StartIdx: Cardinal; const Count: Cardinal);
var
Idx: Integer;
begin
Assert(Count <= SpaceRemaining);
for Idx := StartIdx to StartIdx + Count - 1 do
begin
Data[Cursor] := Bytes[Idx];
Inc(Cursor);
end;
end;
function TPJMD5.TMDBuffer.IsEmpty: Boolean;
begin
Result := Cursor = 0;
end;
function TPJMD5.TMDBuffer.IsFull: Boolean;
begin
Result := SpaceRemaining = 0;
end;
function TPJMD5.TMDBuffer.SpaceRemaining: Byte;
begin
Result := SizeOf(Data) - Cursor;
end;
{ TPJMD5Digest }
class operator TPJMD5Digest.Equal(const D1, D2: TPJMD5Digest): Boolean;
var
Idx: Integer;
begin
Result := True;
for Idx := Low(D1.LongWords) to High(D1.LongWords) do
if D1.LongWords[Idx] <> D2.LongWords[Idx] then
Exit(False);
end;
class operator TPJMD5Digest.Equal(const B: TBytes;
const D: TPJMD5Digest): Boolean;
begin
Result := D = B;
end;
class operator TPJMD5Digest.Equal(const D: TPJMD5Digest;
const B: TBytes): Boolean;
var
DB: TPJMD5Digest;
begin
if Length(B) <> Length(D.Bytes) then
Exit(False);
DB := B;
Result := DB = D;
end;
class operator TPJMD5Digest.Equal(const D: TPJMD5Digest;
const S: string): Boolean;
var
Idx: Integer;
B: Integer;
DS: TPJMD5Digest;
begin
if Length(S) <> 2 * Length(D.Bytes) then
Exit(False);
Idx := 1;
while Idx < Length(S) do
begin
if not TryStrToInt('$' + S[Idx] + S[Idx + 1], B) then
Exit(False);
Inc(Idx, 2);
end;
DS := S;
Result := DS = D;
end;
class operator TPJMD5Digest.Equal(const S: string;
const D: TPJMD5Digest): Boolean;
begin
Result := D = S;
end;
function TPJMD5Digest.GetLongWord(Idx: Integer): LongWord;
begin
Assert((Idx >= Low(LongWords)) and (Idx <= High(LongWords)));
Result := Self.LongWords[Idx];
end;
class operator TPJMD5Digest.Implicit(const D: TPJMD5Digest): string;
var
B: Byte;
const
Digits: array[0..15] of Char = (
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
);
begin
Result := '';
for B in D.Bytes do
Result := Result + Digits[(B shr 4) and $0f] + Digits[B and $0f];
end;
class operator TPJMD5Digest.Implicit(const S: string): TPJMD5Digest;
var
Idx: Integer;
B: Integer;
ByteStr: string;
begin
FillChar(Result, SizeOf(Result), 0);
if Length(S) <> 2 * Length(Result.Bytes) then
raise EPJMD5.CreateFmt(sBadMD5StrLen, [Length(S)]);
// we know string is correct length (32)
for Idx := 0 to Pred(Length(Result.Bytes)) do
begin
ByteStr := S[2 * Idx + 1] + S[2 * Idx + 2];
if not TryStrToInt('$' + ByteStr, B) then
raise EPJMD5.CreateFmt(sBadMD5StrChars, [S]);
Result.Bytes[Idx] := Byte(B);
end;
end;
class operator TPJMD5Digest.Implicit(const B: TBytes): TPJMD5Digest;
var
Idx: Integer;
begin
Assert(Low(B) = Low(Result.Bytes));
if Length(B) < Length(Result.Bytes) then
raise EPJMD5.CreateFmt(sByteArrayTooShort, [Length(B)]);
for Idx := Low(Result.Bytes) to High(Result.Bytes) do
Result.Bytes[Idx] := B[Idx];
end;
class operator TPJMD5Digest.Implicit(const D: TPJMD5Digest): TBytes;
var
Idx: Integer;
begin
SetLength(Result, Length(D.Bytes));
Assert(Low(D.Bytes) = Low(Result));
for Idx := Low(D.Bytes) to High(D.Bytes) do
Result[Idx] := D.Bytes[Idx];
end;
class operator TPJMD5Digest.NotEqual(const D: TPJMD5Digest;
const B: TBytes): Boolean;
begin
Result := not (D = B);
end;
class operator TPJMD5Digest.NotEqual(const B: TBytes;
const D: TPJMD5Digest): Boolean;
begin
Result := not (B = D);
end;
class operator TPJMD5Digest.NotEqual(const D1, D2: TPJMD5Digest): Boolean;
begin
Result := not (D1 = D2);
end;
class operator TPJMD5Digest.NotEqual(const D: TPJMD5Digest;
const S: string): Boolean;
begin
Result := not (D = S);
end;
class operator TPJMD5Digest.NotEqual(const S: string;
const D: TPJMD5Digest): Boolean;
begin
Result := not (S = D);
end;
end.
