POS终端MAC算法－C语言实现 (转贴）

本文根据《中国银联直联POS终端规范》的阐述，用C语言编程实现，该算法在实际的商业POS终端中使用。POS终端采用ＥＣＢ的加密方式，简述如下：
a) 将欲发送给POS中心的消息中，从消息类型（MTI）到63域之间的部分构成MAC
ELEMEMENT BLOCK （MAB）。
b) 对MAB，按每8个字节做异或（不管信息中的字符格式），如果最后不满8个字
节，则添加“0X00”。
示例：
MAB = M1 M2 M3 M4
其中：
M1 = MS11 MS12 MS13 MS14 MS15 MS16 MS17 MS18
M2 = MS21 MS22 MS23 MS24 MS25 MS26 MS27 MS28
M3 = MS31 MS32 MS33 MS34 MS35 MS36 MS37 MS38
M4 = MS41 MS42 MS43 MS44 MS45 MS46 MS47 MS48

按如下规则进行异或运算：
MS11 MS12 MS13 MS14 MS15 MS16 MS17 MS18
XOR）MS21 MS22 MS23 MS24 MS25 MS26 MS27 MS28
---------------------------------------------------
TEMP BLOCK1 =TM11 TM12 TM13 TM14 TM15 TM16 TM17 TM18

然后，进行下一步的运算：
TM11 TM12 TM13 TM14 TM15 TM16 TM17 TM18
XOR） MS31 MS32 MS33 MS34 MS35 MS36 MS37 MS38
---------------------------------------------------
TEMP BLOCK2 =TM21 TM22 TM23 TM24 TM25 TM26 TM27 TM28

再进行下一步的运算：
TM21 TM22 TM23 TM24 TM25 TM26 TM27 TM28
XOR）MS41 MS42 MS43 MS44 MS45 MS46 MS47 MS48
---------------------------------------------------
RESULT BLOCK =TM31 TM32 TM33 TM34 TM35 TM36 TM37 TM38

c) 将异或运算后的最后8个字节（RESULT BLOCK）转换成16 个HEXDECIMAL：
RESULT BLOCK = TM31 TM32 TM33 TM34 TM35 TM36 TM37 TM38
= TM311 TM312 TM321 TM322 TM331 TM332 TM341 TM342 ||
TM351 TM352 TM361 TM362 TM371 TM372 TM381 TM382

d) 取前8 个字节用MAK加密：
ENC BLOCK1 = eMAK（TM311 TM312 TM321 TM322 TM331 TM332 TM341 TM342）
= EN11 EN12 EN13 EN14 EN15 EN16 EN17 EN18

e) 将加密后的结果与后8 个字节异或：
EN11 EN12 EN13 EN14 EN15 EN16 EN17 EN18
XOR） TM351 TM352 TM361 TM362 TM371 TM372 TM381 TM382
------------------------------------------------------------
TEMP BLOCK=TE11 TE12 TE13 TE14 TE15 TE16 TE17 TE18

f) 用异或的结果TEMP BLOCK 再进行一次单倍长密钥算法运算。
ENC BLOCK2 = eMAK（TE11 TE12 TE13 TE14 TE15 TE16 TE17 TE18）
= EN21 EN22 EN23 EN24 EN25 EN26 EN27 EN28

g) 将运算后的结果（ENC BLOCK2）转换成16 个HEXDECIMAL：
ENC BLOCK2 = EN21 EN22 EN23 EN24 EN25 EN26 EN27 EN28
= EM211 EM212 EM221 EM222 EM231 EM232 EM241 EM242 ||
EM251 EM252 EM261 EM262 EM271 EM272 EM281 EM282
示例：
ENC RESULT= %H84, %H56, %HB1, %HCD, %H5A, %H3F, %H84, %H84
转换成16 个HEXDECIMAL:
“8456B1CD5A3F8484”
h) 取前8个字节作为MAC值。
取”8456B1CD”为MAC值。

mac校验算法原理：

处理密钥:
从用户处获得64位密钥.(每第8位为校验位,为使密钥有正确的奇偶校验,每个密钥要有奇数个"1"位.(本文如未特指，均指二进制位)
具体过程:
对密钥实施变换,使得变换以后的密钥的各个位与原密钥位对应关系如下表所示:（表一为忽略校验位以后情况）.
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 49 38 30 22
14 6 61 53 45 37 29 21 13 5 28 20 12 4

把变换后的密钥等分成两部分,前28位记为C[0],后28位记为D[0].
计算子密钥(共16个)， 从i=1开始。
分别对C[i-1],D[i-1]作循环左移来生成C[i],D[i].(共16次)。
每次循环左移位数如下表所示：

轮 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
位数 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1

串联C[i],D[i]，得到一个56位数，然后对此数
作如下变换以产生48位子密钥K[i]。
变换过程如下：

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

1.2.3.3 按以上方法计算出16个子密钥。
对64位数据块的处理：

把数据分成64位的数据块，不够64位的以适当的方式填补。
对数据块作变换。

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

将变换后的数据块等分成前后两部分，前32位记为L[0],后32位记为R[0]。
用16个子密钥对数据加密。
根据下面的扩冲函数E，扩展32位的成48位

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

用E{R[i-1]}与K[i]作异或运算。
把所得的48位数分成8个6位数。1-6位为B[1]，7-12位为B[2],... 43-48位为B[8]。
用S密箱里的值替换B[j]。从j=1开始。S密箱里的值为4位数，共8个S密箱.
取出B[j]的第1和第6位串联起来成一个2位数,记为m.m即是S密箱里用来替换B[j]的数所在的列数。
取出B[j]的第2至第5位串联起来成一个4位数，记为n。n即是S密箱里用来替换B[j]的数所在的行数。
用S密箱里的值S[j][ m][ n]替换B[j]。8个S密箱如下所示：
S-BOXE:S1
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 14 0 4 15
0001 1 4 15 1 12
0010 2 13 7 14 8
0011 3 1 4 8 2
0100 4 2 14 13 4
0101 5 15 2 6 9
0110 6 11 13 2 1
0111 7 8 1 11 7
1000 8 3 10 15 5
1001 9 10 6 12 11
1010 10 6 12 9 3
1011 11 12 11 7 14
1100 12 5 9 3 10
1101 13 9 5 10 0
1110 14 0 3 5 6
1111 15 7 8 0 13
S-BOXE:S2
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 15 3 0 13
0001 1 1 13 14 8
0010 2 8 4 7 10
0011 3 14 7 11 1
0100 4 6 15 10 3
0101 5 11 2 4 15
0110 6 3 8 13 4
0111 7 4 14 1 2
1000 8 9 12 5 11
1001 9 7 0 8 6
1010 10 2 1 12 7
1011 11 13 10 6 12
1100 12 12 6 9 0
1101 13 0 9 3 5
1110 14 5 11 2 14
1111 15 10 5 15 9
S-BOXE:S3
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 10 13 13 1
0001 1 0 7 6 10
0010 2 9 0 4 13
0011 3 14 9 9 0
0100 4 6 3 8 6
0101 5 3 4 15 9
0110 6 15 6 3 8
0111 7 5 10 0 7
1000 8 1 2 11 4
1001 9 13 8 1 15
1010 10 12 5 2 14
1011 11 7 14 12 3
1100 12 11 12 5 11
1101 13 4 11 10 5
1110 14 2 15 14 2
1111 15 8 1 7 12
S-BOXE:S4
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 7 13 10 3
0001 1 13 8 6 15
0010 2 14 11 9 0
0011 3 3 5 0 6
0100 4 0 6 12 10
0101 5 6 15 11 1
0110 6 9 0 7 13
0111 7 10 3 13 8
1000 8 1 4 15 9
1001 9 2 7 1 4
1010 10 8 2 3 5
1011 11 5 12 14 11
1100 12 11 1 5 12
1101 13 12 10 2 7
1110 14 4 14 8 2
1111 15 15 9 4 14
S-BOXE:S5
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 2 14 4 11
0001 1 12 11 2 8
0010 2 4 2 1 12
0011 3 1 12 11 7
0100 4 7 4 10 1
0101 5 10 7 13 14
0110 6 11 13 7 2
0111 7 6 1 8 13
1000 8 8 5 15 6
1001 9 5 0 9 15
1010 10 3 15 12 0
1011 11 15 10 5 9
1100 12 13 3 6 10
1101 13 0 9 3 4
1110 14 14 8 0 5
1111 15 9 6 14 3
S-BOXE:S6
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 12 10 9 4
0001 1 1 15 14 3
0010 2 10 4 15 2
0011 3 15 2 5 12
0100 4 9 7 2 9
0101 5 2 12 8 5
0110 6 6 9 12 15
0111 7 8 5 3 10
1000 8 0 6 7 11
1001 9 13 1 0 14
1010 10 3 13 4 1
1011 11 4 14 10 7
1100 12 14 0 1 6
1101 13 7 11 13 0
1110 14 5 3 11 8
1111 15 11 8 6 13
S-BOXE:S7
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 4 13 1 6
0001 1 11 0 4 11
0010 2 2 11 11 13
0011 3 14 7 13 8
0100 4 15 4 12 1
0101 5 0 9 3 4
0110 6 8 1 7 10
0111 7 13 10 14 7
1000 8 3 14 10 9
1001 9 12 3 15 5
1010 10 9 5 6 0
1011 11 7 12 8 15
1100 12 5 2 0 14
1101 13 10 15 5 2
1110 14 6 8 9 3
1111 15 1 6 2 12
S-BOXE:S8
Binary d1d6 =>; 00 01 10 11
// d2..d5 // Dec 0 1 2 3
0000 0 13 1 7 2
0001 1 2 15 11 1
0010 2 8 13 4 14
0011 3 4 8 1 7
0100 4 6 10 9 4
0101 5 15 3 12 10
0110 6 11 7 14 8
0111 7 1 4 2 13
1000 8 10 12 0 15
1001 9 9 5 6 12
1010 10 3 6 10 9
1011 11 14 11 13 0
1100 12 5 0 15 3
1101 13 0 14 3 5
1110 14 12 9 5 6
1111 15 7 2 8 11




返回第一步直至8个数据块都被替换。
把B[1]至B[8]顺序串联起来得到一个32位数。对这个数做如下变换：

bit goes to bit bit goes to bit
16 1 2 17
7 2 8 18
20 3 24 19
21 4 14 20
29 5 32 21
12 6 27 22
28 7 3 23
17 8 9 24
1 9 19 25
15 10 13 26
23 11 30 27
26 12 6 28
5 13 22 29
18 14 11 30
31 15 4 31
10 16 25 32

把得到的结果与L[i-1]作异或运算。把计算结果賦给R[i]。
把R[i-1]的值賦给L[i]。
从a循环执行，直到K[16]也被用到。
把R[16]和L[16] 顺序串联起来得到一个64位数。对这个数实施II变换的逆变换。
以上就是DES算法如何加密一段64位数据块。解密时用同样的过程，只需把16个子密钥的顺续颠倒过来，应用的顺序为K[16]，K[15]，K[14]，...K[1]。