简单介绍
- DES算法为密码体制中的对称密码体制，又被称为美国数据加密标准，2000年以前一直是业界的标准。
- DES是一个分组加密算法，以64位为分组对数据加密（每次处理固定长度的数据段，称之为分组）。如果加密的数据长度不是64位的倍数，可以按照某种具体的规则来填充位。
- DES的明文长为64位，密钥长64位，但密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1），分组后的明文组和56位的密钥按位替代或交换的方法形成密文组。
- DES算法具体通过对明文进行一系列的排列和替换操作来将其加密。DES 解密算法与加密算法完全相同，只需要将子密钥的使用顺序反过来就行了。
算法流程
DES加密算法流程总体如上图所示，主体内容为中间操作（包括密码函数f和异或操作）循环16次。
DES加密算法五个最值得注意的部分为：
- IP置换；
- 子密钥 Ki 的获取；
- 密码函数 f ；
- 逆IP置换；
- 其他；
IP置换
IP（initial permutation 初始排列）是一个 8x8 的置换表：
// Replacement Table（RT）
final int RT_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置换表的含义为：原来的58位现在排在第一位，50位排在第二位…以此类推【下文所有置换都是这个含义】。注：该过程输入是64位的分组，IP置换以后得到的是一个 64 位的输出。
子密钥 Ki 的获取
-
根据密钥选择置换表
RT_Key，将 64 位输入密钥变成 56 位。（去掉了奇偶校验位） -
将
RT_Key置换得到的 56 位密钥（其实这也是一种压缩置换，特指去掉了奇偶校验位的过程），分为前28位 C0 和后28位 D0，分别对它们进行循环左移，C0左移得到 C1，D0 左移得到 D1。 -
将 C1 和 D1 合并，然后通过
RT_Compress表进行压缩置换，得到当前这一轮的 48 位子密钥 K1 。 -
然后对 C1 和 D1 进行左移和压缩置换，获取下一轮的子密钥……一共进行16轮，得到 16 个 48 位的子密钥。
这部分需要用到的置换表和移动位数记录等常量如下：
// 密钥选择（置换）表，64位密钥去掉校验位，选择剩下的56位作为新的密钥。可以发现，去掉校验位的同时还打乱了顺序
final int RT_Key[] = {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位密钥压缩成48位子密钥,同时打乱顺序
final int RT_Compress[] = {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};
// 每轮左移的位数
final int shiftBits[] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
密码函数 f
密码函数f(R, K)接受两个输入：32 位的R数据（明文的右半部分）和 48 位的子密钥（Ki）。然后：
-
通过表 E 进行扩展置换，将输入的 32 位数据扩展为 48 位；
-
将扩展后的 48 位数据与 48 位的子密钥进行异或运算；
-
将异或得到的 48 位数据分成 8 个 6 位的块，每一个块通过对应的一个 S 表产生一个 4 位的输出。其中，每个 S 表都是 4 行 16 列。具体的置换过程如下：把 6 位输入中的第 1 位和第 6 位取出来行成一个两位的二进制数 x ，作为 Si 表中的行数（0~3）；把 6 位输入的中间 4 位构成另外一个二进制数 y，作为 Si 表的列数（0~15）；查出 Si 表中 x 行 y 列所对应的整数，将该整数转换为一个 4 位的二进制数。
-
把通过 S 表置换得到的 8 个 4 位连在一起，形成一个 32 位的数据。然后将该 32 位数据通过表 P 进行置换（称为P-置换），置换后得到一个仍然是 32 位的结果数据，这就是f(R, K)函数的输出。
这部分用到了扩展置换表RT_E，8个S表以及P-置换表(RT_P)，如下：
// 扩展置换表 RT_E，将32位扩展至48位 final int RT_E[] = {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}; // S盒，每个S盒Si是4x16的置换表，6位 -> 4位 final int S_BOX[][][] ={ { {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} }, { {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} }, { {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} }, { {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} }, { {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} }, { {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} }, { {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} }, { {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} } }; // P置换，32位 -> 32位 final int RT_P[] = {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 };
逆IP置换
合并 L16 和 R16 得到一个 64 位的数据，再经过尾置换后得到的就是 64 位的密文。注意：要将 L16和 R16 合并成 R16L16（即左右互换）。逆IP置换表如下：
// 逆IP置换表
final int RT_InverseIP [] = {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};
注意：逆IP置换就是IP置换的反操作，A经过IP置换得到B，那B经过逆IP置换就可以得到A。逆IP置换表中第一个数是40，而IP置换表中，第40个元素为1。
现在我们可以回到本文的开头，去看看 DES 算法的整体流程图，思路就已经很清楚了。
其他
- 异或运算（图中的⊕符号）是指两个多位比特流之间的异或，操作为：对比特流逐位采用异或运算再拼接起来。异或运算规则为：[相同为0，不同为1，即1 ^ 1 = 0；0 ^ 0 = 0；1 ^ 0 = 1]
代码实现
package lesson;
public class DES {
// Replacement Table（RT）IP置换表
final static int[] RT_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 };
// 密钥选择（置换）表，64位密钥去掉校验位，选择剩下的56位作为新的密钥。可以发现，去掉校验位的同时还打乱了顺序
final static int[] RT_Key = {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位密钥压缩成48位子密钥
final static int[] RT_Compress = {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};
// 每轮左移的位数
final static int[] shiftBits = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
// 扩展置换表 RT_E，将32位扩展至48位
final static int[] RT_E = {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};
// S盒，每个S盒Si是4x16的置换表，6位 -> 4位
final static int[][][] S_BOX ={
{
{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}
},
{
{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}
},
{
{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}
},
{
{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}
},
{
{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}
},
{
{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}
},
{
{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}
},
{
{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}
}
};
// P置换，32位 -> 32位
final static int[] RT_P = {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 };
// 逆IP置换表
final static int[] RT_InverseIP = {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};
/**********************************************************************/
/* */
/* 下面是DES算法实现 */
/* */
/**********************************************************************/
//生成16个子密钥
public static StringBuffer[] GenerateSubKey(StringBuffer str, boolean flag) throws Exception{
if(str.length()!=64){
throw new Exception("输入密钥长度不是64位！");
}
else {
//密钥选择
StringBuffer choosedKey = new StringBuffer();
for (int i = 0; i < RT_Key.length; i++) {
choosedKey.append(str.charAt(RT_Key[i]-1));
}
//拆分密钥
// System.out.println("choosedKey.length():"+choosedKey.length());
StringBuffer leftString = new StringBuffer(choosedKey.substring(0,28));
StringBuffer rightString = new StringBuffer(choosedKey.substring(28,56));
//16次循环得到16个子密钥
StringBuffer[] res = new StringBuffer[16];
for (int i = 0; i < 16; i++) {
int shiftBit=shiftBits[i];
//两部分密钥分别左移
StringBuffer temp_left=new StringBuffer(leftString);
StringBuffer temp_right=new StringBuffer(rightString);
for (int j = 0; j < leftString.length(); j++) {
if(j-shiftBit<0){
leftString.setCharAt(j,temp_left.charAt(j-shiftBit+28));
rightString.setCharAt(j,temp_right.charAt(j-shiftBit+28));
}else{
leftString.setCharAt(j,temp_left.charAt(j-shiftBit));
rightString.setCharAt(j,temp_right.charAt(j-shiftBit));
}
}
//压缩置换
StringBuffer temp=new StringBuffer(leftString);
StringBuffer input = temp.append(rightString);
StringBuffer subKey = new StringBuffer();
for (int k = 0; k < RT_Compress.length; k++) {
subKey.append(input.charAt(RT_Compress[k]-1));
}
res[i]=subKey;
}
StringBuffer[] res_reverse = new StringBuffer[16];
for (int i = 0; i < res.length; i++) {
res_reverse[i]=res[res.length-i-1];
}
return flag?res:res_reverse;
}
}
//IP置换
public static StringBuffer IPReplacement(StringBuffer str){
StringBuffer res = new StringBuffer();
for (int i = 0; i < RT_IP.length; i++) {
res.append(str.charAt(RT_IP[i]-1));
}
return res;
}
//执行F密码函数
public static StringBuffer function(StringBuffer subKey, StringBuffer R) throws Exception {
//1.扩展置换
StringBuffer extendedString = new StringBuffer();
for (int i = 0; i < RT_E.length; i++) {
extendedString.append(R.charAt(RT_E[i]-1));
}
//2.异或操作
StringBuffer xor = XOR(extendedString, subKey);
if(xor.length()!=48){
throw new Exception("异或结果不等于48位！");
}else{
//3.S盒
StringBuffer S_output =new StringBuffer();
for (int i = 0; i < 8; i++) {
//3.1 拆分为6位子串substring
String substring = xor.substring(6 * i, 6 * (i+1));
//3.2 将substring取0,5位为x;其余4位为y【二进制转换】
int x=binaryToDecimal(substring.substring(0,1)+substring.substring(5,6));
int y=binaryToDecimal(substring.substring(1,5));
//3.3 从S盒取S[i][x][y]转化为4位输出
String s = Integer.toBinaryString(S_BOX[i][x][y]);
StringBuffer stringBuffer = new StringBuffer(s);
//3.4 如果输出未达到4位则往前补0，补齐4位
while(4-stringBuffer.length()!=0){
stringBuffer.insert(0,'0');
}
S_output.append(stringBuffer);
}
//4.P盒
StringBuffer res = new StringBuffer();
for (int i = 0; i < RT_P.length; i++) {
res.append(S_output.charAt(RT_P[i]-1));
}
return res;
}
}
//执行异或操作
public static StringBuffer XOR(StringBuffer L, StringBuffer output) throws Exception{
if(L.length()!=output.length()){
throw new Exception("两者长度不同，不能进行异或运算！");
}else{
StringBuffer res = new StringBuffer(L.length());
for (int i = 0; i < L.length(); i++) {
int temp =0;
if(L.charAt(i)!=output.charAt(i)){temp=1;}
res.append(temp);
}
return res;
}
}
//逆IP置换
public static StringBuffer ReverseIPReplacement(StringBuffer str){
StringBuffer res = new StringBuffer();
for (int i = 0; i < RT_InverseIP.length; i++) {
res.append(str.charAt(RT_InverseIP[i]-1));
}
return res;
}
//二进制转化为10进制
public static int binaryToDecimal(String str){
int len = str.length();
int res=0;
for (int i = 0; i < len; i++) {
res+=Integer.parseInt(String.valueOf(str.charAt(len-i-1)))*Math.pow(2,i);
}
return res;
}
//完整加密过程
public static StringBuffer Encryption(StringBuffer Plaintext, StringBuffer Key) throws Exception {
//1.获取子密钥
StringBuffer[] subKeys =GenerateSubKey(Key,true);
//2.IP置换
StringBuffer stringBuffer = IPReplacement(Plaintext);
StringBuffer Leftstring = new StringBuffer(stringBuffer.substring(0, 32));
StringBuffer Rightstring = new StringBuffer(stringBuffer.substring(32,64));
//3.for循环16轮
for (int i = 0; i < 16; i++) {
//3.1 f函数
StringBuffer f_output=function(subKeys[i],Rightstring);
//3.2 异或
StringBuffer temp=XOR(Leftstring,f_output);
//3.3 更新Li和Ri
Leftstring=Rightstring;
Rightstring=temp;
}
//4.左右互换
StringBuffer res = Rightstring.append(Leftstring);
//5.逆IP置换
res=ReverseIPReplacement(res);
return res;
}
//完整解密过程
public static StringBuffer Decryption(StringBuffer Plaintext, StringBuffer Key) throws Exception {
//1.获取子密钥
StringBuffer[] subKeys =GenerateSubKey(Key,false);
//2.IP置换
StringBuffer stringBuffer = IPReplacement(Plaintext);
StringBuffer Leftstring = new StringBuffer(stringBuffer.substring(0, 32));
StringBuffer Rightstring = new StringBuffer(stringBuffer.substring(32,64));
//3.for循环16轮
for (int i = 0; i < 16; i++) {
//3.1 f函数
StringBuffer f_output=function(subKeys[i],Rightstring);
//3.2 异或
StringBuffer temp=XOR(Leftstring,f_output);
//3.3 更新Li和Ri
Leftstring=Rightstring;
Rightstring=temp;
}
//4.左右互换
StringBuffer res = Rightstring.append(Leftstring);
//5.逆IP置换
res=ReverseIPReplacement(res);
return res;
}
/**********************************************************************/
/* */
/* 下面是测试代码 */
/* */
/**********************************************************************/
// a) 使用同一密钥，对两组明文进行加密和解密。
// 64位密钥：
// 00000010 10010110 01001000 11000100 00111000 00110000 00111000 01100100
//
// 64位明文块1：
// 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
//
// 64位明文块2（与明文块1仅有一位的不同）：
// 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
//
// 输出两个密文块的二进制流，统计两个密文块间不同数据位的数量。
//
// b) 对同一段明文，使用不同密钥进行加密和解密操作。
// 64位密钥1：
// 11100010 11110110 11011110 00110000 00111010 00001000 01100010 11011100
//
// 64位密钥2（与密钥1仅有一位的不同）：
// 01100010 11110110 11011110 00110000 00111010 00001000 01100010 11011100
//
// 明文：
// 01101000 10000101 00101111 01111010 00010011 01110110 11101011 10100100
//
// 输出两个密文块的二进制流，统计两个密文块间不同数据位的数量。
public static void main(String[] args) throws Exception {
System.out.println();
System.out.println("a):使用同一密钥，对两组明文进行加密");
String key ="00000010 10010110 01001000 11000100 00111000 00110000 00111000 01100100";
String plaintext_1 ="00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000";
String plaintext_2 ="10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000";
StringBuffer Key= new StringBuffer(key.replaceAll(" ",""));
StringBuffer Plaintext_1= new StringBuffer(plaintext_1.replaceAll(" ",""));
StringBuffer Plaintext_2= new StringBuffer(plaintext_2.replaceAll(" ",""));
StringBuffer Ciphertext_1 = Encryption(Plaintext_1, Key);
StringBuffer Ciphertext_2 = Encryption(Plaintext_2, Key);
System.out.println("密钥："+Key);
System.out.println("明文1："+Plaintext_1);
System.out.println("明文2："+Plaintext_2);
System.out.println("========================================================================");
System.out.println("密文1："+Ciphertext_1);
System.out.println("密文2："+Ciphertext_2);
Helper(Ciphertext_1, Ciphertext_2);
System.out.println();
System.out.println("b):对同一段明文，使用不同密钥进行加密操作");
String key_1 ="11100010 11110110 11011110 00110000 00111010 00001000 01100010 11011100";
String key_2 ="01100010 11110110 11011110 00110000 00111010 00001000 01100010 11011100";
String plaintext ="01101000 10000101 00101111 01111010 00010011 01110110 11101011 10100100";
StringBuffer Key_1= new StringBuffer(key_1.replaceAll(" ",""));
StringBuffer Key_2= new StringBuffer(key_2.replaceAll(" ",""));
StringBuffer Plaintext= new StringBuffer(plaintext.replaceAll(" ",""));
StringBuffer Ciphertext_b1 = Encryption(Plaintext_1, Key);
StringBuffer Ciphertext_b2 = Encryption(Plaintext_2, Key);
System.out.println("密钥1："+Key_1);
System.out.println("密钥2："+Key_2);
System.out.println("明文："+Plaintext);
System.out.println("===========================================================================");
System.out.println("密文1："+Ciphertext_b1);
System.out.println("密文2："+Ciphertext_b2);
Helper(Ciphertext_b1, Ciphertext_b2);
System.out.println();
System.out.println("c):附加，对一个明文和密钥，先加密后解密");
StringBuffer Ciphertext_c = Encryption(Plaintext_1, Key);
StringBuffer Plaintext_c = Decryption(Ciphertext_c, Key);
System.out.println("明文："+Plaintext_1);
System.out.println("密钥："+Key);
System.out.println("===========================================================================");
System.out.println("加密后密文："+Ciphertext_c);
System.out.println("再解密后明文："+Plaintext_c);
}
//帮助统计两个比特流之间不同的位数的数量
public static void Helper(StringBuffer str1,StringBuffer str2){
int res=0;
for (int i = 0; i < str1.length(); i++) {
int add=str1.charAt(i)==str2.charAt(i)?0:1;
res+=add;
}
System.out.println("两个密文块间不同数据位的数量为:"+res);
}
}
结果图：
总结和思考
-
要多用StringBuffer（或StringBuilder）可以比 String 类更高效地处理字符串，如append操作不需要索引，setCharAt(index,‘s’) 可以更改某一个位置的char值（String做不到）。但是去除空格的时候还是得转成String类。
//去除字符串头尾的空格 System.out.println(str.trim()); //只去除字符串中的空格 System.out.println(str.replaceAll(" ", "")); //去除空白字符, \s 可以匹配空格、制表符、换页符等空白字符的其中任意一个 System.out.println(str.replaceAll("\\s*", "")); -
DES加密解密就是密钥顺序反一下就好。Java函数没有默认参数（除非重载或者工厂方法实现…)，所以生成子密钥需要手动输入参数flag，显式定义是子密钥在数组中顺排还是逆排（对应是加密还是解密）。
-
二进制与十进制间的转换
//10进制转化为二进制字符串 Integer.toBinaryString() //二进制转化为10进制，注意：幂次用Math.pow(2,i)，而不要用2^i，后者相当于2+i public static int binaryToDecimal(String str){ int len = str.length(); int res=0; for (int i = 0; i < len; i++) { res+=Integer.parseInt(String.valueOf(str.charAt(len-i-1)))*Math.pow(2,i); } return res; } -
Java不像C++那样有指针。在给对象初始化的时候，记得不要用对象直接赋值的方式，而应该new一个新对象
//压缩置换 StringBuffer temp=new StringBuffer(leftString); StringBuffer input = temp.append(rightString); //这里不能写成这样，这是把leftString指针给了temp，后面操作temp其实就是操作leftString StringBuffer temp=leftString; //这里也不能写成这样，这样leftString就会变长，因为append了一个rightString StringBuffer input = leftString.append(rightString); -
什么是雪崩效益？根据以上结果，说明DES加密算法是否具有该性质：在密码学中，雪崩效应（Avalanche effect）指加密算法（尤其是块密码和加密散列函数）的一种理想属性。雪崩效应是指当输入发生最微小的改变（例如，反转一个二进制位）时，也会导致输出的剧变（如，输出中一半的二进制位发生反转）。在高品质的块密码中，无论密钥或明文的任何细微变化都应当引起密文的剧烈改变。DES有很好的雪崩效应，即使明文或密钥只更改了一位，密文也会有很大的差别（27位）。
1434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
