DES 编码的原理及实现
DES(Data Encryption Standard), 出自于IBM的研究项目， 1977 年被美国政府正式采用.
DES的特点为 Working On Bits
假设有一组KEY为 "133457799BBCDFF1" 8 bytes, 资料为 "0123456789ABCDEF" 8 bytes, 则加密后的资料为 8 bytes 的 "85E813540F0AB405"那么加密的算法为何?
1) 首先将 KEY "133457799BBCDFF1" 转换成 64 bits binary string:
K+： 0001001100110100010101110111100110011011101111001101111111110001
它是由一组对应表转换而成。
my %codemap = ('0' => '0000', '1' => '0001', '2' => '0010', '3' => '0011',
'4' => '0100', '5' => '0101', '6' => '0110', '7' => '0111',
'8' => '1000', '9' => '1001', 'A' => '1010', 'B' => '1011',
'C' => '1100', 'D' => '1101', 'E' => '1110', 'F' => '1111');
2) 再由一组置换阵列
(其数值就表示 K+ 中的第几个 bit, starting from 1, instead of from 0)
my @pc1map = (57, 49, 41, 33, 25, 17, 9,1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4);
转换成 56 bits binary string
K0: 11110000110011001010101011110101010101100110011110001111
3) 将 K0 分成左右两个部分，每个部分为 28 bits binary string
C0: 1111000011001100101010101111D0: 0101010101100110011110001111
Ci 与 Di (i=1..16) 分别按下表进行位移处理:
my %iterations = ( 1 => 1, 2 => 1, 3 => 2, 4 => 2, 5 => 2, 6 => 2, 7 => 2,
8 => 2, 9 => 1, 10 => 2, 11 => 2, 12 => 2, 13 => 2,
14 => 2, 15 => 2, 16 => 1);
按上表 C1=》C0 位移 1 位: C0 的第 2 位为 C1 的第 1 位, C0 的第 3 位为 C1 的第 2 位,
..., C0 的第 1 位为 C1 的最后 1 位
D1=》D0 位移 1 位: D0 的第 2 位为 D1 的第 1 位, D0 的第 3 位为 D1 的第 2 位,
..., D0 的第 1 位为 D1 的最后 1 位
C3=》C2 位移 2 位: C2 的第 3 位为 C3 的第 1 位, C2 的第 4 位为 C3 的第 2 位,...,
C2 的第 1 位为 C3 的倒数第 2 位, C2 的第 2 位为 C3 的最后 1 位
D3=》D2 位移 2 位: D2 的第 3 位为 D3 的第 1 位, D2 的第 4 位为 D3 的第 2 位,...,
D2 的第 1 位为 D3 的倒数第 2 位, D2 的第 2 位为 D3 的最后 1 位
依此可得C1 = 1110000110011001010101011111
D1 = 1010101011001100111100011110
C2 = 1100001100110010101010111111
D2 = 0101010110011001111000111101
C3 = 0000110011001010101011111111
D3 = 0101011001100111100011110101
C4 = 0011001100101010101111111100
D4 = 0101100110011110001111010101
C5 = 1100110010101010111111110000
D5 = 0110011001111000111101010101
C6 = 0011001010101011111111000011
D6 = 1001100111100011110101010101
C7 = 1100101010101111111100001100
D7 = 0110011110001111010101010110
C8 = 0010101010111111110000110011
D8 = 1001111000111101010101011001
C9 = 0101010101111111100001100110
D9 = 0011110001111010101010110011
C10 = 0101010111111110000110011001
D10 = 1111000111101010101011001100
C11 = 0101011111111000011001100101
D11 = 1100011110101010101100110011
C12 = 0101111111100001100110010101
D12 = 0001111010101010110011001111
C13 = 0111111110000110011001010101
D13 = 0111101010101011001100111100
C14 = 1111111000011001100101010101
D14 = 1110101010101100110011110001
C15 = 1111100001100110010101010111
D15 = 1010101010110011001111000111
C16 = 1111000011001100101010101111
D16 = 0101010101100110011110001111
4) 将 Ci, Di 组合起来 CiDi 再经过置换阵列
my @pc2map = (14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32);
转换可得 16 组 subkeys
K1 = 000110110000001011101111111111000111000001110010
K2 = 011110011010111011011001110110111100100111100101
K3 = 010101011111110010001010010000101100111110011001
K4 = 011100101010110111010110110110110011010100011101
K5 = 011111001110110000000111111010110101001110101000
K6 = 011000111010010100111110010100000111101100101111
K7 = 111011001000010010110111111101100001100010111100
K8 = 111101111000101000111010110000010011101111111011
K9 = 111000001101101111101011111011011110011110000001
K10 = 101100011111001101000111101110100100011001001111
K11 = 001000010101111111010011110111101101001110000110
K12 = 011101010111000111110101100101000110011111101001
K13 = 100101111100010111010001111110101011101001000001
K14 = 010111110100001110110111111100101110011100111010
K15 = 101111111001000110001101001111010011111100001010
K16 = 110010110011110110001011000011100001011111110101
Step2: 对每个 64 bit data block 进行编码
1) 将 Data '0123456789ABCDEF' 转换成 64 bits binary string
M = '0000000100100011010001010110011110001001101010111100110111101111'
2) 将 M 进行第一次的置换
my @IP = (58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7);
可得: IP = '1100110000000000110011001111111111110000101010101111000010101010'
3) 将 IP 分为左右两个部分, 每部分 32 bits binary string
L0 = 11001100000000001100110011111111
R0 = 11110000101010101111000010101010
4) 将 L0, R0 按如下规则迭代运算: i=1..16
L[i] = R[i-1]
R[i] = L[i-1] + f(R[i-1], K[i])
上式的加法为 XOR on bits, f 的作用为
*1 R[i-1] 为 32 bit, 而 K[i] 为 48 bit, 需要将 R[i-1] 扩充为 48 bit, 规则如下置换阵列
my @selection_table = (32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1);
以计算 L1, R1 为例: EXP = 011110100001010101010101011110100001010101010101
*2 扩充好的 binary string exp 与 K[i] 作用 xor on bits,
可得 48 bits binary string - xor
EXP = 011110100001010101010101011110100001010101010101K1 = 000110110000001011101111111111000111000001110010
---------------------------------------------------------
XOR = 011000010001011110111010100001100110010100100111
*3 计算 XOR 的 sboxes： 将 XOR 6 bit 为 1 组分成 8 组 xor[i] (i=0..7)
每一组对应一组 sbox, 可得 8 个 sbox index
my @sb1 = (14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13);
my @sb2 = (15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9);
my @sb3 = (10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13 , 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12);
my @sb4 = ( 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14);
my @sb5 = ( 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3);
my @sb6 = (12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11 , 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13);
my @sb7 = ( 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12);
my @sb8 = (13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11);
以上例解释: XOR 可分为 011000 010001 011110 111010 100001 100110 010100 100111
其 sbox index 的运算规则为 row number = 第 1 位与最后 1 位组合起来的值; col number = 中间 4 位组合起来的值
依序可得 sbox index
(00, 1100), (01, 1000), (00, 1111), (10, 1101), (11, 0000), (10, 0011), (00, 1010), (11, 0011)
取值为
(0, 12), (1, 8), (0, 15), (2, 13), (3, 0), (2, 3), (0, 10), (3, 3)
依序对应
SB1[0, 12], SB2[1, 8], SB3[0, 15], SB4[2, 13], SB5[3, 0], SB6[2, 3], SB7[0, 10], SB8[3, 3]
=>
5, 12, 8, 2, 11, 5, 9, 7
=>
0101, 1100, 1000, 0010, 1011, 0101, 1001, 0111
SBS = 0101 1100 1000 0010 1011 0101 1001 0111
*4 SBS 经置换阵列
my @sp = (16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25);
PC = 00100011010010101010100110111011
依此规则可得:
L1 = 11110000101010101111000010101010
R1 = 11101111010010100110010101000100
L2 = 11101111010010100110010101000100
R2 = 11001100000000010111011100001001
L3 = 11001100000000010111011100001001
R3 = 10100010010111000000101111110100
L4 = 10100010010111000000101111110100
R4 = 01110111001000100000000001000101
L5 = 01110111001000100000000001000101
R5 = 10001010010011111010011000110111
L6 = 10001010010011111010011000110111
R6 = 11101001011001111100110101101001
L7 = 11101001011001111100110101101001
R7 = 00000110010010101011101000010000
L8 = 00000110010010101011101000010000
R8 = 11010101011010010100101110010000
L9 = 11010101011010010100101110010000
R9 = 00100100011111001100011001111010
L10 = 00100100011111001100011001111010
R10 = 10110111110101011101011110110010
L11 = 10110111110101011101011110110010
R11 = 11000101011110000011110001111000
L12 = 11000101011110000011110001111000
R12 = 01110101101111010001100001011000
L13 = 01110101101111010001100001011000
R13 = 00011000110000110001010101011010
L14 = 00011000110000110001010101011010
R14 = 11000010100011001001011000001101
L15 = 11000010100011001001011000001101
R15 = 01000011010000100011001000110100
L16 = 01000011010000100011001000110100
R16 = 00001010010011001101100110010101
5) 将 R16 与 L16 组合成 R16L16, 再经过最后一个置换即可得加密后的资料 FINAL
my @fp = (40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25);
FINAL = 85E813540F0AB405
Perl code 实现如下:
#!/usr/bin/perl -w
# DES algorithm - reference to http://orlingrabbe.com/des.htm
sub iteration_handle {
my ($bitstring, $pad) = @_;
my $bitstringp = pack 'b*', $bitstring;
my @bitarray = split(//, unpack('b*',$bitstringp));
my @subkey;
# perl give four zeros append the last of packed string
my ($d1, $d2) = (scalar(@bitarray) - 4, scalar(@bitarray) - 1);
delete @bitarray[$d1..$d2];
#print "PAD=$pad\n";
# handle last $pad bits
for ($n=$pad; $n>0; $n--) {
$subkey[scalar(@bitarray)-$n] = $bitarray[$pad - $n];
}
# handle head of bits
for($i=0; $i<(scalar(@bitarray)-$pad); $i++) {
#if ($i == $#bitarray) {
# $subkey[$i] = $bitarray[0];
#} else {
$subkey[$i] = $bitarray[$i+$pad];
#}
#print $i. ": ". $subkey[$i]. "\n";
}
return join('', @subkey);
}
sub tobit {
my $uncode = shift;
my %codemap = ('0' => '0000', '1' => '0001', '2' => '0010', '3' => '0011',
'4' => '0100', '5' => '0101', '6' => '0110', '7' => '0111',
'8' => '1000', '9' => '1001', 'A' => '1010', 'B' => '1011',
'C' => '1100', 'D' => '1101', 'E' => '1110', 'F' => '1111');
my $coded = '';
my @chars = split('', $uncode);
foreach $c (@chars) {
$coded .= $codemap{$c};
}
return $coded;
}
sub tohex {
my $origin = shift;
my @hexbits = split(//, $origin);
my $ret = '';
for ($j=0; $j<@hexbits; $j=$j+4) {
$hex = join '', @hexbits[$j..($j+3)];
$ret .= sprintf ("%x", oct('0b' .$hex));
}
return $ret;
}
sub permuted {
my $unpermuted = shift;
# the first permutation chooser map table
my @pc1map = (57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4);
my $permuted = '';
my @unpermutation = split(//, $unpermuted);
foreach $d (@pc1map) {
$permuted .= $unpermutation[$d-1]; # start from index 1
}
return $permuted;
}
sub generate_subkey {
my $origin = shift;
# the second permutation chooser map table
my @pc2map = (14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32);
my $permuted = '';
my @unpermutation = split(//, $origin);
foreach $d (@pc2map) {
$permuted .= $unpermutation[$d-1]; # start from index 1
}
return $permuted;
}
sub initial_permutation {
my $origin = shift;
# the initial permutation map table
my @IP = (58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7);
my $permuted = '';
my @unpermutation = split(//, $origin);
foreach $d (@IP) {
$permuted .= $unpermutation[$d-1]; # start from index 1
}
return $permuted;
}
sub expand {
my $origin = shift;
# bit selection table
my @selection_table = (32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1);
my $permuted = '';
my @unpermutation = split(//, $origin);
foreach $d (@selection_table) {
#print "array of position $d: $unpermutation[$d-1]\n";
$permuted .= $unpermutation[$d-1]; # start from index 1
}
return $permuted;
}
sub subxor {
my ($a, $b) = @_;
my @as = split(//, $a);
my @bs = split(//, $b);
my @targets;
for ($z=0; $z<@as; $z++) {
if ($as[$z] eq '0' && $bs[$z] eq '0') {
$targets[$z] = '0';
} elsif ($as[$z] eq '1' && $bs[$z] eq '1') {
$targets[$z] = '0';
} else {
$targets[$z] = '1';
}
}
return join '', @targets;
}
sub cal_sboxes {
my $origin = shift;
my @sboxes;
my @scalars = split(//, $origin);
my @sb1 = (14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13);
my @sb2 = (15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9);
my @sb3 = (10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13 , 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12);
my @sb4 = ( 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14);
my @sb5 = ( 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3);
my @sb6 = (12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11 , 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13);
my @sb7 = ( 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12);
my @sb8 = (13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11);
@sboxes = (\@sb1, \@sb2, \@sb3, \@sb4, \@sb5, \@sb6, \@sb7, \@sb8);
my $ret = '';
my $index = 0;
for ($i=0; $i<@scalars; $i=$i+6, $index++) {
$row = oct('0b'. join ('', @scalars[$i,($i+5)]));
$col = oct ('0b'. join ('', @scalars[($i+1)..($i+4)]));
#print "ROW: $row, COL= $col\n";
$sindex = $row == 0 ? ($row * 15 + $col) : ($row * 16 + $col);
#print "SINDEX = $sindex\n";
#print "ROW= $row, COL= $col, V= $sboxes[$index][$sindex]\n";
#print sprintf("%04b", $sboxes[$index][$sindex]);
$ret .= sprintf("%04b", $sboxes[$index][$sindex]);
}
return $ret;
}
sub second_permutation {
my $origin = shift;
# bit selection table
my @sp = (16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25);
my $permuted = '';
my @unpermutation = split(//, $origin);
foreach $d (@sp) {
$permuted .= $unpermutation[$d-1]; # start from index 1
}
return $permuted;
}
sub handle_func {
my ($rp, $key) = @_;
# expand $rp[n-1] from 32 bits to 48 bits
my $expands = expand $rp;
#print "EXP= $expands\n";
# XOR
my $xor = subxor $key, $expands;
#print "XOR= $xor\n";
my $ret = '';
# calcute sboxes
my $sbs = cal_sboxes($xor);
#print "SBS= $sbs\n";
$ret = second_permutation $sbs;
#print "FP = $final\n";
return $ret;
}
sub final_permutation {
my $origin = shift;
# bit selection table
my @fp = (40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25);
my $permuted = '';
my @unpermutation = split(//, $origin);
foreach $d (@fp) {
$permuted .= $unpermutation[$d-1]; # start from index 1
}
return $permuted;
}
# Step1: Create 16 subkeys, each of which is 48-bits long.
$original_key = '133457799BBCDFF1';
print "KEY = ". $original_key. "\n";
my $keybits = tobit $original_key;
print "K = ". $keybits. "\n";
$permutation = permuted $keybits;
print "K+ = ". $permutation. "\n\n";
my @subkeys;
$subkeys[0] = $permutation;
my @permutations = split(//, $permutation);
my @leftpart;
my @rightpart;
$leftpart[0] = join('', @permutations[0..27]);
$rightpart[0] = join ('', @permutations[28..55]);
print "C0: ". $leftpart[0]. "\n";
print "D0: ". $rightpart[0]. "\n\n";
# irations table for shift N
my %iterations = (1 => 1, 2 => 1, 3 => 2, 4 => 2, 5 => 2, 6 => 2, 7 => 2,
8 => 2, 9 => 1, 10 => 2, 11 => 2, 12 => 2, 13 => 2,
14 => 2, 15 => 2, 16 => 1);
for ($j=1; $j<=16; $j++) {
$leftpart [$j] = iteration_handle $leftpart[$j-1], $iterations{$j};
$rightpart[$j] = iteration_handle $rightpart[$j-1], $iterations{$j};
#print "C". $j. " = ". $leftpart[$j]. "\n";
#print "D". $j. " = ". $rightpart[$j]. "\n\n";
$subkeys[$j] = generate_subkey($leftpart[$j]. $rightpart[$j]);
print "K". $j. " = ". $subkeys[$j]. "\n";
}
# Step 2: Encode each 64-bit block of data
my $data = '0123456789ABCDEF';
print "DATA = ". tobit($data). "\n";
my $ip = initial_permutation(tobit($data));
print "IP = ". $ip. "\n";
# $ip = $lp[0] + $rp[0]
my (@lp, @rp);
$lp[0] = join '', (split(//, $ip))[0..31];
$rp[0] = join '', (split(//, $ip))[32..63];
print "L0 = ". $lp[0]. "\n";
print "R0 = ". $rp[0]. "\n";
for ($x=1; $x<=16; $x++) {
$lp[$x] = $rp[$x-1];
#print "L". $x. " = ". $lp[$x]. "\n";
#print "R". ($x-1). " = ". $rp[$x-1]. "\n";
#print "K". $x. " = ". $subkeys[$x]. "\n";
#print "L". ($x-1). " = ". $lp[$x-1]. "\n";
$rp[$x] = subxor($lp[$x-1], handle_func($rp[$x-1], $subkeys[$x]));
#print "R". $x. " = ". $rp[$x]. "\n";
}
my $reverse = $rp[16]. $lp[16];
#print "R16L16 = ". $reverse. "\n";
my $final = final_permutation $reverse;
$final = uc(tohex $final);
print "FINAL = $final\n";