//Delphi version
//ZswangY37, October 2006
//
//THIS SOFTWARE IS PROVIDED "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
//FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
//DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
//OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
//OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
//SUCH DAMAGE.
unit DESUtils;
interface
type
TDesKey = array of Longword;
function des_createKeys(key: string): TDesKey;
function des(key: string; message: string;
encrypt: Boolean; mode: Boolean; iv: string): string;
implementation
//设计 Zswang 2006-10-26 wjhu111#21cn.com 尊重作者,转贴请注明出处
//des_createKeys
//this takes as input a 64 bit key (even though only 56 bits are used)
//as an array of 2 integers, and returns 16 48 bit keys
function des_createKeys(key: string): TDesKey;
const
//declaring this locally speeds things up a bit
pc2bytes0: array[0..15] of Integer = (0, $4, $20000000, $20000004, $10000,
$10004, $20010000, $20010004, $200, $204, $20000200, $20000204, $10200,
$10204, $20010200, $20010204);
pc2bytes1: array[0..15] of Integer = (0, $1, $100000, $100001, $4000000,
$4000001, $4100000, $4100001, $100, $101, $100100, $100101, $4000100,
$4000101, $4100100, $4100101);
pc2bytes2: array[0..15] of Integer = (0, $8, $800, $808, $1000000, $1000008,
$1000800, $1000808, 0, $8, $800, $808, $1000000, $1000008, $1000800,
$1000808);
pc2bytes3: array[0..15] of Integer = (0, $200000, $8000000, $8200000, $2000,
$202000, $8002000, $8202000, $20000, $220000, $8020000, $8220000, $22000,
$222000, $8022000, $8222000);
pc2bytes4: array[0..15] of Integer = (0, $40000, $10, $40010, 0, $40000, $10,
$40010, $1000, $41000, $1010, $41010, $1000, $41000, $1010, $41010);
pc2bytes5: array[0..15] of Integer = (0, $400, $20, $420, 0, $400, $20, $420,
$2000000, $2000400, $2000020, $2000420, $2000000, $2000400, $2000020,
$2000420);
pc2bytes6: array[0..15] of Integer = (0, $10000000, $80000, $10080000, $2,
$10000002, $80002, $10080002, 0, $10000000, $80000, $10080000, $2,
$10000002, $80002, $10080002);
pc2bytes7: array[0..15] of Integer = (0, $10000, $800, $10800, $20000000,
$20010000, $20000800, $20010800, $20000, $30000, $20800, $30800, $20020000,
$20030000, $20020800, $20030800);
pc2bytes8: array[0..15] of Integer = (0, $40000, 0, $40000, $2, $40002, $2,
$40002, $2000000, $2040000, $2000000, $2040000, $2000002, $2040002,
$2000002, $2040002);
pc2bytes9: array[0..15] of Integer = (0, $10000000, $8, $10000008, 0,
$10000000, $8, $10000008, $400, $10000400, $408, $10000408, $400, $10000400,
$408, $10000408);
pc2bytes10: array[0..15] of Integer = (0, $20, 0, $20, $100000, $100020,
$100000, $100020, $2000, $2020, $2000, $2020, $102000, $102020, $102000,
$102020);
pc2bytes11: array[0..15] of Integer = (0, $1000000, $200, $1000200, $200000,
$1200000, $200200, $1200200, $4000000, $5000000, $4000200, $5000200,
$4200000, $5200000, $4200200, $5200200);
pc2bytes12: array[0..15] of Integer = (0, $1000, $8000000, $8001000, $80000,
$81000, $8080000, $8081000, $10, $1010, $8000010, $8001010, $80010, $81010,
$8080010, $8081010);
pc2bytes13: array[0..15] of Integer = (0, $4, $100, $104, 0, $4, $100, $104,
$1, $5, $101, $105, $1, $5, $101, $105);
shifts: array[0..15] of Boolean = (False, False, True, True, True, True, True,
True, False, True, True, True, True, True, True, False);
var
//other variables
iterations: Longword;
lefttemp, righttemp: Longword;
m, n, temp: Longword;
i, j: Longword;
left, right: Longword;
begin
//how many iterations (1 for des, 3 for triple des)
if Length(key) >= 24 then
iterations := 3
else iterations := 1;
//stores the return keys
SetLength(Result, 32 * iterations);
//now define the left shifts which need to be done
m := 1;
n := 0;
for j := 1 to iterations do //either 1 or 3 iterations
begin
left := (Ord(Key[m]) shl 24) or (Ord(Key[m + 1]) shl 16) or
(Ord(Key[m + 2]) shl 8) or Ord(Key[m + 3]);
Inc(m, 4);
right := (Ord(Key[m]) shl 24) or (Ord(Key[m + 1]) shl 16) or
(Ord(Key[m + 2]) shl 8) or Ord(Key[m + 3]);
Inc(m, 4);
temp := ((left shr 4) xor right) and $0f0f0f0f;
right := right xor temp;
left := left xor (temp shl 4);
temp := ((Int64(right) shr -16) xor left) and $0000ffff;
left := left xor temp;
right := right xor Longword(Int64(temp) shl -16);
temp := ((left shr 2) xor right) and $33333333;
right := right xor temp;
left := left xor (temp shl 2);
temp := ((Int64(right) shr -16) xor left) and $0000ffff;
left := left xor temp;
right := right xor Longword(Int64(temp) shl -16);
temp := ((left shr 1) xor right) and $55555555;
right := right xor temp;
left := left xor (temp shl 1);
temp := ((right shr 8) xor left) and $00ff00ff;
left := left xor temp;
right := right xor (temp shl 8);
temp := ((left shr 1) xor right) and $55555555;
right := right xor temp;
left := left xor (temp shl 1);
//the right side needs to be shifted and to get the last four bits of the left side
temp := (left shl 8) or ((right shr 20) and $000000f0);
//left needs to be put upside down
left := (right shl 24) or ((right shl 8) and $ff0000) or ((right shr 8) and $ff00) or ((right shr 24) and $f0);
right := temp;
//now go through and perform these shifts on the left and right Result
for i := Low(shifts) to High(shifts) do
begin
//shift the Result either one or two bits to the left
if shifts[i] then
begin
left := (left shl 2) or (left shr 26);
right := (right shl 2) or (right shr 26);
end else
begin
left := (left shl 1) or (left shr 27);
right := (right shl 1) or (right shr 27);
end;
left := left and -$f;
right := right and -$f;
//now apply PC-2, in such a way that E is easier when encrypting or decrypting
//this conversion will look like PC-2 except only the last 6 bits of each byte are used
//rather than 48 consecutive bits and the order of lines will be according to
//how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7
lefttemp := pc2bytes0[left shr 28] or pc2bytes1[(left shr 24) and $f] or
pc2bytes2[(left shr 20) and $f] or pc2bytes3[(left shr 16) and $f] or
pc2bytes4[(left shr 12) and $f] or pc2bytes5[(left shr 8) and $f] or
pc2bytes6[(left shr 4) and $f];
righttemp := pc2bytes7[right shr 28] or pc2bytes8[(right shr 24) and $f]
or pc2bytes9[(right shr 20) and $f] or pc2bytes10[(right shr 16) and $f]
or pc2bytes11[(right shr 12) and $f] or pc2bytes12[(right shr 8) and $f]
or pc2bytes13[(right shr 4) and $f];
temp := ((righttemp shr 16) xor lefttemp) and $0000ffff;
Result[n] := lefttemp xor temp;
Inc(n);
Result[n] := Integer(righttemp xor (temp shl 16));
Inc(n);
end;
end; //for each iterations
end; //end of des_createKeys
//des
//this takes the key, the message, and whether to encrypt or decrypt
function des(key: string; message: string; encrypt: Boolean;
mode: Boolean; iv: string): string;
const
//declaring this locally speeds things up a bit
spfunction1: array[0..63] of Integer = ($1010400, 0, $10000, $1010404,
$1010004, $10404, $4, $10000, $400, $1010400, $1010404, $400, $1000404,
$1010004, $1000000, $4, $404, $1000400, $1000400, $10400, $10400, $1010000,
$1010000, $1000404, $10004, $1000004, $1000004, $10004, 0, $404, $10404,
$1000000, $10000, $1010404, $4, $1010000, $1010400, $1000000, $1000000,
$400, $1010004, $10000, $10400, $1000004, $400, $4, $1000404, $10404,
$1010404, $10004, $1010000, $1000404, $1000004, $404, $10404, $1010400,
$404, $1000400, $1000400, 0, $10004, $10400, 0, $1010004);
spfunction2: array[0..63] of Integer = (-$7fef7fe0, -$7fff8000, $8000,
$108020, $100000, $20, -$7fefffe0, -$7fff7fe0, -$7fffffe0, -$7fef7fe0,
-$7fef8000, -$80000000, -$7fff8000, $100000, $20, -$7fefffe0, $108000,
$100020, -$7fff7fe0, 0, -$80000000, $8000, $108020, -$7ff00000, $100020,
-$7fffffe0, 0, $108000, $8020, -$7fef8000, -$7ff00000, $8020, 0, $108020,
-$7fefffe0, $100000, -$7fff7fe0, -$7ff00000, -$7fef8000, $8000, -$7ff00000,
-$7fff8000, $20, -$7fef7fe0, $108020, $20, $8000, -$80000000, $8020,
-$7fef8000, $100000, -$7fffffe0, $100020, -$7fff7fe0, -$7fffffe0, $100020,
$108000, 0, -$7fff8000, $8020, -$80000000, -$7fefffe0, -$7fef7fe0, $108000);
spfunction3: array[0..63] of Integer = ($208, $8020200, 0, $8020008, $8000200,
0, $20208, $8000200, $20008, $8000008, $8000008, $20000, $8020208, $20008,
$8020000, $208, $8000000, $8, $8020200, $200, $20200, $8020000, $8020008,
$20208, $8000208, $20200, $20000, $8000208, $8, $8020208, $200, $8000000,
$8020200, $8000000, $20008, $208, $20000, $8020200, $8000200, 0, $200,
$20008, $8020208, $8000200, $8000008, $200, 0, $8020008, $8000208, $20000,
$8000000, $8020208, $8, $20208, $20200, $8000008, $8020000, $8000208, $208,
$8020000, $20208, $8, $8020008, $20200);
spfunction4: array[0..63] of Integer = ($802001, $2081, $2081, $80, $802080,
$800081, $800001, $2001, 0, $802000, $802000, $802081, $81, 0, $800080,
$800001, $1, $2000, $800000, $802001, $80, $800000, $2001, $2080, $800081,
$1, $2080, $800080, $2000, $802080, $802081, $81, $800080, $800001, $802000,
$802081, $81, 0, 0, $802000, $2080, $800080, $800081, $1, $802001, $2081,
$2081, $80, $802081, $81, $1, $2000, $800001, $2001, $802080, $800081,
$2001, $2080, $800000, $802001, $80, $800000, $2000, $802080);
spfunction5: array[0..63] of Integer = ($100, $2080100, $2080000, $42000100,
$80000, $100, $40000000, $2080000, $40080100, $80000, $2000100, $40080100,
$42000100, $42080000, $80100, $40000000, $2000000, $40080000, $40080000, 0,
$40000100, $42080100, $42080100, $2000100, $42080000, $40000100, 0,
$42000000, $2080100, $2000000, $42000000, $80100, $80000, $42000100, $100,
$2000000, $40000000, $2080000, $42000100, $40080100, $2000100, $40000000,
$42080000, $2080100, $40080100, $100, $2000000, $42080000, $42080100,
$80100, $42000000, $42080100, $2080000, 0, $40080000, $42000000, $80100,
$2000100, $40000100, $80000, 0, $40080000, $2080100, $40000100);
spfunction6: array[0..63] of Integer = ($20000010, $20400000, $4000,
$20404010, $20400000, $10, $20404010, $400000, $20004000, $404010, $400000,
$20000010, $400010, $20004000, $20000000, $4010, 0, $400010, $20004010,
$4000, $404000, $20004010, $10, $20400010, $20400010, 0, $404010, $20404000,
$4010, $404000, $20404000, $20000000, $20004000, $10, $20400010, $404000,
$20404010, $400000, $4010, $20000010, $400000, $20004000, $20000000, $4010,
$20000010, $20404010, $404000, $20400000, $404010, $20404000, 0, $20400010,
$10, $4000, $20400000, $404010, $4000, $400010, $20004010, 0, $20404000,
$20000000, $400010, $20004010);
spfunction7: array[0..63] of Integer = ($200000, $4200002, $4000802, 0, $800,
$4000802, $200802, $4200800, $4200802, $200000, 0, $4000002, $2, $4000000,
$4200002, $802, $4000800, $200802, $200002, $4000800, $4000002, $4200000,
$4200800, $200002, $4200000, $800, $802, $4200802, $200800, $2, $4000000,
$200800, $4000000, $200800, $200000, $4000802, $4000802, $4200002, $4200002,
$2, $200002, $4000000, $4000800, $200000, $4200800, $802, $200802, $4200800,
$802, $4000002, $4200802, $4200000, $200800, 0, $2, $4200802, 0, $200802,
$4200000, $800, $4000002, $4000800, $800, $200002);
spfunction8: array[0..63] of Integer = ($10001040, $1000, $40000, $10041040,
$10000000, $10001040, $40, $10000000, $40040, $10040000, $10041040, $41000,
$10041000, $41040, $1000, $40, $10040000, $10000040, $10001000, $1040,
$41000, $40040, $10040040, $10041000, $1040, 0, 0, $10040040, $10000040,
$10001000, $41040, $40000, $41040, $40000, $10041000, $1000, $40, $10040040,
$1000, $41040, $10001000, $40, $10000040, $10040000, $10040040, $10000000,
$40000, $10001040, 0, $10041040, $40040, $10000040, $10040000, $10001000,
$10001040, 0, $10041040, $41000, $41000, $1040, $1040, $40040, $10000000,
$10041000);
var
keys: TDesKey;
m, i, j: Longword;
temp, temp2, right1, right2, left, right: Longword;
looping: array of Integer;
cbcleft, cbcleft2, cbcright, cbcright2: Longword;
endloop, loopinc: Longword;
len: Longword;
chunk: Longword;
iterations: Longword;
tempresult: string;
begin
keys := des_createKeys(key);
len := Length(message);
chunk := 0;
cbcleft2 := 0;
cbcright2 := 0;
cbcleft := 0;
cbcright := 0;
//set up the loops for single and triple des
if Length(Keys) = 32 then
iterations := 3
else iterations := 9;
if (iterations = 3) then
begin
SetLength(looping, 3);
if encrypt then
begin
looping[0] := 0;
looping[1] := 32;
looping[2] := 2;
end else
begin
looping[0] := 30;
looping[1] := -2;
looping[2] := -2;
end;
end else
begin
SetLength(looping, 9);
if encrypt then
begin
looping[0] := 0;
looping[1] := 32;
looping[2] := 2;
looping[3] := 62;
looping[4] := 30;
looping[5] := -2;
looping[6] := 64;
looping[7] := 96;
looping[8] := 2;
end else
begin
looping[0] := 94;
looping[1] := 62;
looping[2] := -2;
looping[3] := 32;
looping[4] := 64;
looping[5] := 2;
looping[6] := 30;
looping[7] := -2;
looping[8] := -2;
end;
end;
message := message + #0#0#0#0#0#0#0#0; //pad the message out with null bytes
//store the result here
Result := '';
tempresult := '';
m := 1;
if mode then //CBC mode
begin
cbcleft := (Ord(iv[m]) shl 24) or (Ord(iv[m + 1]) shl 16) or
(Ord(iv[m + 2]) shl 8) or Ord(iv[m + 3]);
cbcright := (Ord(iv[m]) shl 24) or (Ord(iv[m + 1]) shl 16) or
(Ord(iv[m + 2]) shl 8) or Ord(iv[m + 3]);
m := 1;
end;
//loop through each 64 bit chunk of the message
while m <= len do
begin
left := (Ord(message[m]) shl 24) or (Ord(message[m + 1]) shl 16) or
(Ord(message[m + 2]) shl 8) or Ord(message[m + 3]);
Inc(m, 4);
right := (Ord(message[m]) shl 24) or (Ord(message[m + 1]) shl 16) or
(Ord(message[m + 2]) shl 8) or Ord(message[m + 3]);
Inc(m, 4);
//for Cipher Block Chaining mode, xor the message with the previous result
if mode then
begin
if encrypt then
begin
left := left xor cbcleft;
right := right xor cbcright;
end else
begin
cbcleft2 := cbcleft;
cbcright2 := cbcright;
cbcleft := left;
cbcright := right;
end;
end;
//first each 64 but chunk of the message must be permuted according to IP
temp := ((left shr 4) xor right) and $0f0f0f0f;
right := right xor temp;
left := left xor (temp shl 4);
temp := ((left shr 16) xor right) and $0000ffff;
right := right xor temp;
left := left xor (temp shl 16);
temp := ((right shr 2) xor left) and $33333333;
left := left xor temp;
right := right xor (temp shl 2);
temp := ((right shr 8) xor left) and $00ff00ff;
left := left xor temp;
right := right xor (temp shl 8);
temp := ((left shr 1) xor right) and $55555555;
right := right xor temp;
left := left xor (temp shl 1);
left := ((left shl 1) or (left shr 31));
right := ((right shl 1) or (right shr 31));
//do this either 1 or 3 times for each chunk of the message
j := 0;
while j < iterations do
begin
endloop := looping[j + 1];
loopinc := looping[j + 2];
//now go through and perform the encryption or decryption
i := looping[j];
while i <> endloop do
begin
right1 := right xor keys[i];
right2 := ((right shr 4) or (right shl 28)) xor keys[i + 1];
//the result is attained by passing these bytes through the S selection functions
temp := left;
left := right;
right := temp xor Longword(spfunction2[(right1 shr 24) and $3f] or
spfunction4[(right1 shr 16) and $3f] or
spfunction6[(right1 shr 8) and $3f] or spfunction8[right1 and $3f] or
spfunction1[(right2 shr 24) and $3f] or
spfunction3[(right2 shr 16) and $3f] or
spfunction5[(right2 shr 8) and $3f] or spfunction7[right2 and $3f]);
i := i + loopinc; //for efficiency
end;
temp := left;
left := right;
right := temp; //unreverse left and right
Inc(j, 3);
end; //for either 1 or 3 iterations
//move then each one bit to the right
left := ((left shr 1) or (left shl 31));
right := ((right shr 1) or (right shl 31));
//now perform IP-1, which is IP in the opposite direction
temp := ((left shr 1) xor right) and $55555555;
right := right xor temp;
left := left xor (temp shl 1);
temp := ((right shr 8) xor left) and $00ff00ff;
left := left xor temp;
right := right xor (temp shl 8);
temp := ((right shr 2) xor left) and $33333333;
left := left xor temp;
right := right xor (temp shl 2);
temp := ((left shr 16) xor right) and $0000ffff;
right := right xor temp;
left := left xor (temp shl 16);
temp := ((left shr 4) xor right) and $0f0f0f0f;
right := right xor temp;
left := left xor (temp shl 4);
//for Cipher Block Chaining mode, xor the message with the previous result
if (mode) then
begin
if (encrypt) then
begin
cbcleft := left;
cbcright := right;
end else
begin
left := left xor cbcleft2;
right := right xor cbcright2;
end;
end;
tempresult := tempresult + Char(left shr 24) + Char((left shr 16) and $ff) +
Char(left shr 8 and $ff) + Char(left and $ff) + Char(right shr 24) +
Char((right shr 16) and $ff) + Char((right shr 8) and $ff) +
Char(right and $ff);
chunk := chunk + 8;
if chunk = 512 then
begin
Result := Result + tempresult;
tempresult := '';
chunk := 0;
end;
end; //for every 8 characters, or 64 bits in the message
//return the result as an array
Result := Result + tempresult;
end; //end of des
end.
扫一扫
3684
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
