📄 unitfymd5.pas
字号:
procedure BFDecryptECB(const Data: TBlowfishData; Input, Output: Pointer);
var
L, R: longword;
begin
Move(Input^, L, 4);
Move(Pointer(integer(Input) + 4)^, R, 4);
L := (L shr 24) or ((L shr 8) and $FF00) or ((L shl 8) and $FF0000) or (L shl 24);
R := (R shr 24) or ((R shr 8) and $FF00) or ((R shl 8) and $FF0000) or (R shl 24);
L := L xor Data.PBoxM[17];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[16];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[15];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[14];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[13];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[12];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[11];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[10];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[9];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[8];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[7];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[6];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[5];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[4];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[3];
R := R xor (((Data.SBoxM[0, (L shr 24) and $FF] + Data.SBoxM[1, (L shr 16) and $FF])
xor Data.SBoxM[2, (L shr 8) and $FF]) + Data.SBoxM[3, L and $FF]) xor Data.PBoxM[2];
L := L xor (((Data.SBoxM[0, (R shr 24) and $FF] + Data.SBoxM[1, (R shr 16) and $FF])
xor Data.SBoxM[2, (R shr 8) and $FF]) + Data.SBoxM[3, R and $FF]) xor Data.PBoxM[1];
R := R xor Data.PBoxM[0];
L := (L shr 24) or ((L shr 8) and $FF00) or ((L shl 8) and $FF0000) or (L shl 24);
R := (R shr 24) or ((R shr 8) and $FF00) or ((R shl 8) and $FF0000) or (R shl 24);
Move(R, Output^, 4);
Move(L, Pointer(integer(Output) + 4)^, 4);
end;
function BFTest : Boolean;
const
Key: array[0..7] of byte = ($01, $23, $45, $67, $89, $AB, $CD, $EF);
InBlock: array[0..7] of byte = ($11, $11, $11, $11, $11, $11, $11, $11);
OutBlock: array[0..7] of byte = ($61, $F9, $C3, $80, $22, $81, $B0, $96);
var
Block: array[0..7] of byte;
Data: TBlowfishData;
begin
BFInit(Data, @Key, SizeOf(Key), nil);
BFEncryptECB(Data, @InBlock, @Block);
Result := CompareMem(@Block, @OutBlock, Sizeof(Block));
BFDecryptECB(Data, @Block, @Block);
Result := Result and CompareMem(@Block, @InBlock, Sizeof(Block));
FillChar(Data,SizeOf(Data),#0);
end;
procedure BFInit(var Data: TBlowfishData; Key: Pointer; Len: integer; IV: Pointer);
var
i, k: integer;
A: longword;
KeyB: PByteArray;
Block: array[0..7] of byte;
begin
KeyB := Key;
Move(SBox, Data.SBoxM, Sizeof(SBox));
Move(PBox, Data.PBoxM, Sizeof(PBox));
with Data do
begin
if IV = nil then
begin
FillChar(InitBlock, 8, 0);
FillChar(LastBlock, 8, 0);
end
else
begin
Move(IV^, InitBlock, 8);
Move(IV^, LastBlock, 8);
end;
k := 0;
for i := 0 to 17 do
begin
A := KeyB[(k + 3) mod Len];
A := A + (KeyB[(k + 2) mod Len] shl 8);
A := A + (KeyB[(k + 1) mod Len] shl 16);
A := A + (KeyB[k] shl 24);
PBoxM[i] := PBoxM[i] xor A;
k := (k + 4) mod Len;
end;
FillChar(Block, Sizeof(Block), 0);
for i := 0 to 8 do
begin
BFEncryptECB(Data, @Block, @Block);
PBoxM[i * 2] := Block[3] + (Block[2] shl 8) + (Block[1] shl 16)
+ (Block[0] shl 24);
PBoxM[i * 2 + 1] := Block[7] + (Block[6] shl 8) + (Block[5] shl 16) +
(Block[4] shl 24);
end;
for k := 0 to 3 do
begin
for i := 0 to 127 do
begin
BFEncryptECB(Data, @Block, @Block);
SBoxM[k, i * 2] := Block[3] + (Block[2] shl 8) + (Block[1] shl 16) +
(Block[0] shl 24);
SBoxM[k, i * 2 + 1] := Block[7] + (Block[6] shl 8) +
(Block[5] shl 16) + (Block[4] shl 24);
end;
end;
end;
end;
procedure BFEncrypt(var Data: TBlowfishData; Input, Output: Pointer);
begin
XorBlock(Input, @Data.LastBlock, Output, 8);
BFEncryptECB(Data, Output, Output);
Move(Output^, Data.LastBlock, 8);
end;
procedure BFDecrypt(var Data: TBlowfishData; Input, Output: Pointer);
var
Block: array[0..7] of byte;
begin
Move(Input^, Block, 8);
BFDecryptECB(Data, Input, Output);
XorBlock(Output, @Data.LastBlock, Output, 8);
Move(Block, Data.LastBlock, 8);
end;
procedure BFReset(var Data: TBlowfishData);
begin
Move(Data.InitBlock, Data.LastBlock, 8);
end;
{$WARNINGS OFF}
end.
Network Working Group R. Rivest
Request for Comments: 1321 MIT Laboratory for Computer Science
and RSA Data Security, Inc.
April 1992
The MD5 Message-Digest Algorithm
Status of this Memo
This memo provides information for the Internet community. It does
not specify an Internet standard. Distribution of this memo is
unlimited.
Acknowlegements
We would like to thank Don Coppersmith, Burt Kaliski, Ralph Merkle,
David Chaum, and Noam Nisan for numerous helpful comments and
suggestions.
Table of Contents
1. Executive Summary 1
2. Terminology and Notation 2
3. MD5 Algorithm Description 3
4. Summary 6
5. Differences Between MD4 and MD5 6
References 7
APPENDIX A - Reference Implementation 7
Security Considerations 21
Author's Address 21
1. Executive Summary
This document describes the MD5 message-digest algorithm. The
algorithm takes as input a message of arbitrary length and produces
as output a 128-bit "fingerprint" or "message digest" of the input.
It is conjectured that it is computationally infeasible to produce
two messages having the same message digest, or to produce any
message having a given prespecified target message digest. The MD5
algorithm is intended for digital signature applications, where a
large file must be "compressed" in a secure manner before being
encrypted with a private (secret) key under a public-key cryptosystem
such as RSA.
Rivest [Page 1]
RFC 1321 MD5 Message-Digest Algorithm April 1992
The MD5 algorithm is designed to be quite fast on 32-bit machines. In
addition, the MD5 algorithm does not require any large substitution
tables; the algorithm can be coded quite compactly.
The MD5 algorithm is an extension of the MD4 message-digest algorithm
1,2]. MD5 is slightly slower than MD4, but is more "conservative" in
design. MD5 was designed because it was felt that MD4 was perhaps
being adopted for use more quickly than justified by the existing
critical review; because MD4 was designed to be exceptionally fast,
it is "at the edge" in terms of risking successful cryptanalytic
attack. MD5 backs off a bit, giving up a little in speed for a much
greater likelihood of ultimate security. It incorporates some
suggestions made by various reviewers, and contains additional
optimizations. The MD5 algorithm is being placed in the public domain
for review and possible adoption as a standard.
For OSI-based applications, MD5's object identifier is
md5 OBJECT IDENTIFIER ::=
iso(1) member-body(2) US(840) rsadsi(113549) digestAlgorithm(2) 5}
In the X.509 type AlgorithmIdentifier [3], the parameters for MD5
should have type NULL.
2. Terminology and Notation
In this document a "word" is a 32-bit quantity and a "byte" is an
eight-bit quantity. A sequence of bits can be interpreted in a
natural manner as a sequence of bytes, where each consecutive group
of eight bits is interpreted as a byte with the high-order (most
significant) bit of each byte listed first. Similarly, a sequence of
bytes can be interpreted as a sequence of 32-bit words, where each
consecutive group of four bytes is interpreted as a word with the
low-order (least significant) byte given first.
Let x_i denote "x sub i". If the subscript is an expression, we
surround it in braces, as in x_{i+1}. Similarly, we use ^ for
superscripts (exponentiation), so that x^i denotes x to the i-th
power.
Let the symbol "+" denote addition of words (i.e., modulo-2^32
addition). Let X <<< s denote the 32-bit value obtained by circularly
shifting (rotating) X left by s bit positions. Let not(X) denote the
bit-wise complement of X, and let X v Y denote the bit-wise OR of X
and Y. Let X xor Y denote the bit-wise XOR of X and Y, and let XY
denote the bit-wise AND of X and Y.
Rivest [Page 2]
RFC 1321 MD5 Message-Digest Algorithm April 1992
3. MD5 Algorithm Description
We begin by supposing that we have a b-bit message as input, and that
we wish to find its message digest. Here b is an arbitrary
nonnegative integer; b may be zero, it need not be a multiple of
eight, and it may be arbitrarily large. We imagine the bits of the
message written down as follows:
m_0 m_1 ... m_{b-1}
The following five steps are performed to compute the message digest
of the message.
3.1 Step 1. Append Padding Bits
The message is "padded" (extended) so that its length (in bits) is
congruent to 448, modulo 512. That is, the message is extended so
that it is just 64 bits shy of being a multiple of 512 bits long.
Padding is always performed, even if the length of the message is
already congruent to 448, modulo 512.
Padding is performed as follows: a single "1" bit is appended to the
message, and then "0" bits are appended so that the length in bits of
the padded message becomes congruent to 448, modulo 512. In all, at
least one bit and at most 512 bits are appended.
3.2 Step 2. Append Length
A 64-bit representation of b (the length of the message before the
padding bits were added) is appended to the result of the previous
step. In the unlikely event that b is greater than 2^64, then only
the low-order 64 bits of b are used. (These bits are appended as two
32-bit words and appended low-order word first in accordance with the
previous conventions.)
At this point the resulting message (after padding with bits and with
b) has a length that is an exact multiple of 512 bits. Equivalently,
this message has a length that is an exact multiple of 16 (32-bit)
words. Let M[0 ... N-1] denote the words of the resulting message,
where N is a multiple of 16.
3.3 Step 3. Initialize MD Buffer
A four-word buffer (A,B,C,D) is used to compute the message digest.
Here each of A, B, C, D is a 32-bit register. These registers are
initialized to the following values in hexadecimal, low-order bytes
first):
Rivest [Page 3]
RFC 1321 MD5 Message-Digest Algorithm April 1992
word A: 01 23 45 67
word B: 89 ab cd ef
word C: fe dc ba 98
word D: 76 54 32 10
3.4 Step 4. Process Message in 16-Word Blocks
We first define four auxiliary functions that each take as input
three 32-bit words and produce as output one 32-bit word.
F(X,Y,Z) = XY v not(X) Z
G(X,Y,Z) = XZ v Y not(Z)
H(X,Y,Z) = X xor Y xor Z
I(X,Y,Z) = Y xor (X v not(Z))
In each bit position F acts as a conditional: if X then Y else Z.
The function F could have been defined using + instead of v since XY
and not(X)Z will never have 1's in the same bit position.) It is
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -