📄 lbcipher.pas
字号:
$B4, $CC, $5C, $34, $11, $41, $E8, $CE, $A1, $54, $86, $AF, $7C, $72, $E9, $93);
type
pMD5ContextEx = ^TMD5ContextEx;
TMD5ContextEx = packed record
Count : array [0..1] of DWord; {number of bits handled mod 2^64}
State : array [0..3] of DWord; {scratch buffer}
Buf : array [0..63] of Byte; {input buffer}
end;
TLMDContextEx = packed record
DigestIndex : LongInt;
Digest : array [0..255] of Byte;
KeyIndex : LongInt;
case Byte of
0: (KeyInts : array [0..3] of LongInt);
1: (Key : TKey128);
end;
TBlock2048 = array [0..255] of Byte;
type
{bit mixing types}
T128Bit = array [0..3] of DWord;
T256Bit = array [0..7] of DWord;
const
BCSalts: array [0..3] of DWord =
($55555555, $AAAAAAAA, $33333333, $CCCCCCCC);
type
TBCHalfBlock = array [0..1] of LongInt;
TBFBlockEx = packed record
Xl : array[0..3] of Byte;
Xr : array[0..3] of Byte;
end;
{ Blowfish tables }
{$I LbBF.inc } {!!.01}
{ SHA-1 constants }
const
{ 5 magic numbers }
SHA1_A = DWORD( $67452301 );
SHA1_B = DWORD( $EFCDAB89 );
SHA1_C = DWORD( $98BADCFE );
SHA1_D = DWORD( $10325476 );
SHA1_E = DWORD( $C3D2E1F0 );
{ four rounds consts }
SHA1_K1 = DWORD( $5A827999 );
SHA1_K2 = DWORD( $6ED9EBA1 );
SHA1_K3 = DWORD( $8F1BBCDC );
SHA1_K4 = DWORD( $CA62C1D6 );
{ Maskes used in byte swap }
LBMASK_HI = DWORD( $FF0000 );
LBMASK_LO = DWORD( $FF00 );
{ Rijndael constants }
const
RDLNb128 = 4; { 128 bit block }
RDLNb192 = 6; { 192 bit block (not used) }
RDLNb256 = 8; { 256 bit block (not used) }
RDLNk128 = 4; { 128 bit key }
RDLNk192 = 6; { 192 bit key }
RDLNk256 = 8; { 256 bit key }
{ Rijndael structures }
type
TRDLVectors = array[0..(RDLNb128 - 1)] of TRDLVector;
TRDLMixColMatrix = array[0..3, 0..3] of Byte;
{ Rijndael tables }
{$I LbRDL.inc} {!!.01}
{ ========================================================================== }
procedure EncryptLBC(const Context : TLBCContext; var Block : TLBCBlock);
var
Blocks : array[0..1] of TBCHalfBlock; {!!.01}
Work : TBCHalfBlock;
Right : TBCHalfBlock;
Left : TBCHalfBlock;
AA, BB : LongInt;
CC, DD : LongInt;
R, T : LongInt;
begin
Move(Block, Blocks, SizeOf(Blocks)); {!!.01}
Right := Blocks[0];
Left := Blocks[1];
for R := 0 to Context.Rounds - 1 do begin
{transform the right side}
AA := Right[0];
BB := TBCHalfBlock(Context.SubKeys64[R])[0];
CC := Right[1];
DD := TBCHalfBlock(Context.SubKeys64[R])[1];
{mix it once...}
AA := AA + DD; DD := DD + AA; AA := AA xor (AA shr 7);
BB := BB + AA; AA := AA + BB; BB := BB xor (BB shl 13);
CC := CC + BB; BB := BB + CC; CC := CC xor (CC shr 17);
DD := DD + CC; CC := CC + DD; DD := DD xor (DD shl 9);
AA := AA + DD; DD := DD + AA; AA := AA xor (AA shr 3);
BB := BB + AA; AA := AA + BB; BB := BB xor (BB shl 7);
CC := CC + BB; BB := BB + CC; CC := CC xor (DD shr 15);
DD := DD + CC; CC := CC + DD; DD := DD xor (DD shl 11);
{swap sets...}
T := AA; AA := CC; CC := T;
T := BB; BB := DD; DD := T;
{mix it twice}
AA := AA + DD; DD := DD + AA; AA := AA xor (AA shr 7);
BB := BB + AA; AA := AA + BB; BB := BB xor (BB shl 13);
CC := CC + BB; BB := BB + CC; CC := CC xor (CC shr 17);
DD := DD + CC; CC := CC + DD; DD := DD xor (DD shl 9);
AA := AA + DD; DD := DD + AA; AA := AA xor (AA shr 3);
BB := BB + AA; AA := AA + BB; BB := BB xor (BB shl 7);
CC := CC + BB; BB := BB + CC; CC := CC xor (DD shr 15);
DD := DD + CC; CC := CC + DD; DD := DD xor (DD shl 11);
Work[0] := Left[0] xor AA xor BB;
Work[1] := Left[1] xor CC xor DD;
Left := Right;
Right := Work;
end;
Blocks[0] := Left;
Blocks[1] := Right;
Move(Blocks, Block, SizeOf(Block)); {!!.01}
end;
{ -------------------------------------------------------------------------- }
procedure EncryptLBCCBC(const Context : TLBCContext; const Prev : TLBCBlock; var Block : TLBCBlock);
begin
if Context.Encrypt then begin
XorMem(Block, Prev, SizeOf(Block));
EncryptLBC(Context, Block);
end else begin
EncryptLBC(Context, Block);
XorMem(Block, Prev, SizeOf(Block));
end;
end;
{ -------------------------------------------------------------------------- }
procedure InitEncryptDES(const Key : TKey64; var Context : TDESContext; Encrypt : Boolean);
const
PC1 : array [0..55] of Byte =
(56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26,
18, 10, 2, 59, 51, 43, 35, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21,
13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3);
PC2 : array [0..47] of Byte =
(13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, 22, 18, 11, 3, 25, 7,
15, 6, 26, 19, 12, 1, 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31);
CTotRot : array [0..15] of Byte = (1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28);
CBitMask : array [0..7] of Byte = (128, 64, 32, 16, 8, 4, 2, 1);
var
PC1M : array [0..55] of Byte;
PC1R : array [0..55] of Byte;
KS : array [0..7] of Byte;
I, J, L, M : LongInt;
begin
{convert PC1 to bits of key}
for J := 0 to 55 do begin
L := PC1[J];
M := L mod 8;
PC1M[J] := Ord((Key[L div 8] and CBitMask[M]) <> 0);
end;
{key chunk for each iteration}
for I := 0 to 15 do begin
{rotate PC1 the right amount}
for J := 0 to 27 do begin
L := J + CTotRot[I];
if (L < 28) then begin
PC1R[J] := PC1M[L];
PC1R[J + 28] := PC1M[L + 28];
end else begin
PC1R[J] := PC1M[L - 28];
PC1R[J + 28] := PC1M[L];
end;
end;
{select bits individually}
FillChar(KS, SizeOf(KS), 0);
for J := 0 to 47 do
if Boolean(PC1R[PC2[J]]) then begin
L := J div 6;
KS[L] := KS[L] or CBitMask[J mod 6] shr 2;
end;
{now convert to odd/even interleaved form for use in F}
if Encrypt then begin
Context.TransformedKey[I * 2] := (LongInt(KS[0]) shl 24) or (LongInt(KS[2]) shl 16) or
(LongInt(KS[4]) shl 8) or (LongInt(KS[6]));
Context.TransformedKey[I * 2 + 1] := (LongInt(KS[1]) shl 24) or (LongInt(KS[3]) shl 16) or
(LongInt(KS[5]) shl 8) or (LongInt(KS[7]));
end else begin
Context.TransformedKey[31 - (I * 2 + 1)] := (LongInt(KS[0]) shl 24) or (LongInt(KS[2]) shl 16) or
(LongInt(KS[4]) shl 8) or (LongInt(KS[6]));
Context.TransformedKey[31 - (I * 2)] := (LongInt(KS[1]) shl 24) or (LongInt(KS[3]) shl 16) or
(LongInt(KS[5]) shl 8) or (LongInt(KS[7]));
end;
end;
Context.Encrypt := Encrypt;
end;
{ -------------------------------------------------------------------------- }
procedure InitEncryptLBC(const Key : TKey128; var Context : TLBCContext; Rounds: LongInt; Encrypt : Boolean);
type
TSubKeys = packed record
case Byte of
0: (SubKeys64 : array [0..15] of TKey64);
1: (SubKeysInts : array [0..3, 0..7] of LongInt);
end;
var
KeyArray : pLongIntArray;
AA, BB : LongInt;
CC, DD : LongInt;
EE, FF : LongInt;
GG, HH : LongInt;
I, R : LongInt;
Temp : TSubKeys;
begin
KeyArray := @Key;
Context.Encrypt := Encrypt;
Context.Rounds := Max(4, Min(16, Rounds));
{fill subkeys by propagating seed}
for I := 0 to 3 do begin
{interleave the key with the salt}
AA := KeyArray^[0]; BB := BCSalts[I];
CC := KeyArray^[1]; DD := BCSalts[I];
EE := KeyArray^[2]; FF := BCSalts[I];
GG := KeyArray^[3]; HH := BCSalts[I];
{mix all the bits around for 8 rounds}
{achieves avalanche and eliminates funnels}
for R := 0 to 7 do begin
AA := AA xor (BB shl 11); DD := DD + AA; BB := BB + CC;
BB := BB xor (CC shr 2); EE := EE + BB; CC := CC + DD;
CC := CC xor (DD shl 8); FF := FF + CC; DD := DD + EE;
DD := DD xor (EE shr 16); GG := GG + DD; EE := EE + FF;
EE := EE xor (FF shl 10); HH := HH + EE; FF := FF + GG;
FF := FF xor (GG shr 4); AA := AA + FF; GG := GG + HH;
GG := GG xor (HH shl 8); BB := BB + GG; HH := HH + AA;
HH := HH xor (AA shr 9); CC := CC + HH; AA := AA + BB;
end;
{assign value to subkey}
Context.SubKeysInts[I, 0] := AA;
Context.SubKeysInts[I, 1] := BB;
Context.SubKeysInts[I, 2] := CC;
Context.SubKeysInts[I, 3] := DD;
Context.SubKeysInts[I, 4] := EE;
Context.SubKeysInts[I, 5] := FF;
Context.SubKeysInts[I, 6] := GG;
Context.SubKeysInts[I, 7] := HH;
end;
{reverse subkeys if decrypting - easier for EncryptLBC routine}
if not Encrypt then begin
for I := 0 to Context.Rounds - 1 do
Temp.SubKeys64[(Context.Rounds - 1) - I] := Context.SubKeys64[I];
for I := 0 to Context.Rounds - 1 do
Context.SubKeys64[I] := Temp.SubKeys64[I];
end;
end;
{ -------------------------------------------------------------------------- }
procedure EncryptDES(const Context : TDESContext; var Block : TDESBlock);
const
SPBox : array [0..7, 0..63] of DWord =
(($01010400, $00000000, $00010000, $01010404, $01010004, $00010404, $00000004, $00010000,
$00000400, $01010400, $01010404, $00000400, $01000404, $01010004, $01000000, $00000004,
$00000404, $01000400, $01000400, $00010400, $00010400, $01010000, $01010000, $01000404,
$00010004, $01000004, $01000004, $00010004, $00000000, $00000404, $00010404, $01000000,
$00010000, $01010404, $00000004, $01010000, $01010400, $01000000, $01000000, $00000400,
$01010004, $00010000, $00010400, $01000004, $00000400, $00000004, $01000404, $00010404,
$01010404, $00010004, $01010000, $01000404, $01000004, $00000404, $00010404, $01010400,
$00000404, $01000400, $01000400, $00000000, $00010004, $00010400, $00000000, $01010004),
($80108020, $80008000, $00008000, $00108020, $00100000, $00000020, $80100020, $80008020,
$80000020, $80108020, $80108000, $80000000, $80008000, $00100000, $00000020, $80100020,
$00108000, $00100020, $80008020, $00000000, $80000000, $00008000, $00108020, $80100000,
$00100020, $80000020, $00000000, $00108000, $00008020, $80108000, $80100000, $00008020,
$00000000, $00108020, $80100020, $00100000, $80008020, $80100000, $80108000, $00008000,
$80100000, $80008000, $00000020, $80108020, $00108020, $00000020, $00008000, $80000000,
$00008020, $80108000, $00100000, $80000020, $00100020, $80008020, $80000020, $00100020,
$00108000, $00000000, $80008000, $00008020, $80000000, $80100020, $80108020, $00108000),
($00000208, $08020200, $00000000, $08020008, $08000200, $00000000, $00020208, $08000200,
$00020008, $08000008, $08000008, $00020000, $08020208, $00020008, $08020000, $00000208,
$08000000, $00000008, $08020200, $00000200, $00020200, $08020000, $08020008, $00020208,
$08000208, $00020200, $00020000, $08000208, $00000008, $08020208, $00000200, $08000000,
$08020200, $08000000, $00020008, $00000208, $00020000, $08020200, $08000200, $00000000,
$00000200, $00020008, $08020208, $08000200, $08000008, $00000200, $00000000, $08020008,
$08000208, $00020000, $08000000, $08020208, $00000008, $00020208, $00020200, $08000008,
$08020000, $08000208, $00000208, $08020000, $00020208, $00000008, $08020008, $00020200),
($00802001, $00002081, $00002081, $00000080, $00802080, $00800081, $00800001, $00002001,
$00000000, $00802000, $00802000, $00802081, $00000081, $00000000, $00800080, $00800001,
$00000001, $00002000, $00800000, $00802001, $00000080, $00800000, $00002001, $00002080,
$00800081, $00000001, $00002080, $00800080, $00002000, $00802080, $00802081, $00000081,
$00800080, $00800001, $00802000, $00802081, $00000081, $00000000, $00000000, $00802000,
$00002080, $00800080, $00800081, $00000001, $00802001, $00002081, $00002081, $00000080,
$00802081, $00000081, $00000001, $00002000, $00800001, $00002001, $00802080, $00800081,
$00002001, $00002080, $00800000, $00802001, $00000080, $00800000, $00002000, $00802080),
($00000100, $02080100, $02080000, $42000100, $00080000, $00000100, $40000000, $02080000,
$40080100, $00080000, $02000100, $40080100, $42000100, $42080000, $00080100, $40000000,
$02000000, $40080000, $40080000, $00000000, $40000100, $42080100, $42080100, $02000100,
$42080000, $40000100, $00000000, $42000000, $02080100, $02000000, $42000000, $00080100,
$00080000, $42000100, $00000100, $02000000, $40000000, $02080000, $42000100, $40080100,
$02000100, $40000000, $42080000, $02080100, $40080100, $00000100, $02000000, $42080000,
$42080100, $00080100, $42000000, $42080100, $02080000, $00000000, $40080000, $42000000,
$00080100, $02000100, $40000100, $00080000, $00000000, $40080000, $02080100, $40000100),
($20000010, $20400000, $00004000, $20404010, $20400000, $00000010, $20404010, $00400000,
$20004000, $00404010, $00400000, $20000010, $00400010, $20004000, $20000000, $00004010,
$00000000, $00400010, $20004010, $00004000, $00404000, $20004010, $00000010, $20400010,
$20400010, $00000000, $00404010, $20404000, $00004010, $00404000, $20404000, $20000000,
$20004000, $00000010, $20400010, $00404000, $20404010, $00400000, $00004010, $20000010,
$00400000, $20004000, $20000000, $00004010, $20000010, $20404010, $00404000, $20400000,
$00404010, $20404000, $00000000, $20400010, $00000010, $00004000, $20400000, $00404010,
$00004000, $00400010, $20004010, $00000000, $20404000, $20000000, $00400010, $20004010),
($00200000, $04200002, $04000802, $00000000, $00000800, $04000802, $00200802, $04200800,
$04200802, $00200000, $00000000, $04000002, $00000002, $04000000, $04200002, $00000802,
$04000800, $00200802, $00200002, $04000800, $04000002, $04200000, $04200800, $00200002,
$04200000, $00000800, $00000802, $04200802, $00200800, $00000002, $04000000, $00200800,
$04000000, $00200800, $00200000, $04000802, $04000802, $04200002, $04200002, $00000002,
$00200002, $04000000, $04000800, $00200000, $04200800, $00000802, $00200802, $04200800,
$00000802, $04000002, $04200802, $04200000, $00200800, $00000000, $00000002, $04200802,
$00000000, $00200802, $04200000, $00000800, $04000002, $04000800, $00000800, $00200002),
($10001040, $00001000, $00040000, $10041040, $10000000, $10001040, $00000040, $10000000,
$00040040, $10040000, $10041040, $00041000, $10041000, $00041040, $00001000, $00000040,
$10040000, $10000040, $10001000, $00001040, $00041000, $00040040, $10040040, $10041000,
$00001040, $00000000, $00000000, $10040040, $10000040, $10001000, $00041040, $00040000,
$00041040, $00040000, $10041000, $00001000, $00000040, $10040040, $00001000, $00041040,
$10001000, $00000040, $10000040, $10040000, $10040040, $10000000, $00040000, $10001040,
$00000000, $10041040, $00040040, $10000040, $10040000, $10001000, $10001040, $00000000,
$10041040, $00041000, $00041000, $00001040, $00001040, $00040040, $10000000, $10041000));
var
I, L, R, Work : DWord;
CPtr : PDWord;
procedure SplitBlock(const Block : TDESBlock; var L, R : DWord); register;
asm
push ebx
push eax
mov eax, [eax]
mov bh, al
mov bl, ah
rol ebx, 16
shr eax, 16
mov bh, al
mov bl, ah
mov [edx], ebx
pop eax
mov eax, [eax+4]
mov bh, al
mov bl, ah
rol ebx, 16
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -