Android/java源代码实现DES算法原理+整理

本篇基于前一篇关于DES算法原理完整版
转载请注明出处啊。博主花了好久时间整理得。


1.初始置换/IP置换
// 初始置换表
private static final int[] IP_Table = { 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置换表里的数据表示的是64位原始数据的位置/下标，不是值！！
使用java表示初始置换
int[] M = new int[64];//IP置换后的数据
for (i = 0; i < 64; i++) {
M[i] = timeData[IP_Table[i] - 1];// 明文数据初始置换(IP置换)
}//int[] timeData是64位二进制原始数据
2.函数f过程
初始化各个常量数据
// 扩展置换E表
private static final int[] E_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 };
// P-盒置换
private static final int[] P_Table = { 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-1
private static final int[] PC_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, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4 };
// PC-2
private static final int[] PC_2 = { 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 };
// 循环左移位数表
private static final int[] LOOP_left = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
// S-盒1
private static final int S_Box1[][] = { { 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 } };
// S2
private static final int S_BOX2[][] = { { 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 } };
// S3
private static final int S_BOX3[][] = { { 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 } };
// S4
private static final int S_BOX4[][] = { { 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 } };
// S5
private static final int S_BOX5[][] = { { 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 } };
// S6
private static final int S_BOX6[][] = { { 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 } };
// S7
private static final int S_BOX7[][] = { { 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 } };
// S8
private static final int S_BOX8[][] = { { 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 } };
private static final int[][][] S_BOX = { S_Box1, S_BOX2, S_BOX3, S_BOX4, S_BOX5, S_BOX6, S_BOX7, S_BOX8 };
2.1 秘钥置换--字秘钥的生成

/**
* 循环左移
*
* @param k
* 子密钥
* @param offset
* 循环左移的位数
*/
private void LeftBitMove(int[] k, int offset) {
int i;
int[] c0 = new int[28];
int[] d0 = new int[28];
int[] c1 = new int[28];
int[] d1 = new int[28];
for (i = 0; i < 28; i++) {
c0[i] = k[i];
d0[i] = k[i + 28];
}
if (offset == 1) {// 循环左移1位
for (i = 0; i < 27; i++) {
c1[i] = c0[i + 1];
d1[i] = d0[i + 1];
}
c1[27] = c0[27];
d1[27] = d0[27];
} else if (offset == 2) {// 循环左移2位
for (i = 0; i < 26; i++) {
c1[i] = c0[i + 2];
d1[i] = d0[i + 2];
}
c1[26] = c0[0];
d1[26] = d0[0];
c1[27] = c0[1];
d1[27] = d0[1];
}
for (i = 0; i < 28; i++) {
k[i] = c1[i];
k[i + 28] = d1[i];
}
}

/**
* 初始化子密钥
*
* @param key
*            56位密钥
* @param keyarray
*            子密钥数组
*/
private void KeyInitialize(int[] key, int[][] keyarray) {
int i;
int j;
int[] K0 = new int[56];
for (i = 0; i < 56; i++) {// PC_1置换
K0[i] = key[PC_1[i] - 1];
}
for (i = 0; i < 16; i++) {// 进行十六次，分别得到16个子密钥
LeftBitMove(K0, LOOP_left[i]);// 循环左移
for (j = 0; j < 48; j++) {// 循环左移之后进行PC_2置换得到子密钥
keyarray[i][j] = K0[PC_2[j] - 1];// 生成16个48位的子密钥
}
}
}

2.2 扩展置换E(E位选择表)+S盒置换+P盒置换
/**
*
* @param M
* 64位经过IP置换后的明文数据
* @param times
* 迭代轮数
* @param flag
* 1为加密
* @param keyarray
* 子密钥数组
*/
private void functionF(int[] M, int times, int flag, int[][] keyarray) {
int i;
int j;
int x = 0;
int y = 0;
int[] L0 = new int[32];
int[] R0 = new int[32];
int[] L1 = new int[32];
int[] R1 = new int[32];
int[] RE = new int[48];// E扩展置换之后并且与子密钥异或运算得到48位数据
int[][] S = new int[8][6];// S盒输入数据8组6位
// S盒数据是6位输入，4位输出
int[] sBoxData = new int[8];
int[] sValue = new int[32];
int[] RP = new int[32];
for (i = 0; i < 32; i++) {// 将明文分成左右两部分
L0[i] = M[i];
R0[i] = M[i + 32];
}
for (i = 0; i < 48; i++) {// 右半部份进行扩展E置换,得到48位RE
RE[i] = R0[E_Table[i] - 1];
RE[i] = RE[i] + keyarray[times][i];// 与子密钥按位做不进位加法运算（R0和子密钥做异或运算）
if (RE[i] == 2) {
RE[i] = 0;
}
}
for (i = 0; i < 8; i++) {
for (j = 0; j < 6; j++) {
S[i][j] = RE[(i * 6) + j];
} // 把扩展之后的数据分成8组6位的数组
//在上一篇讲到，S盒的计算方法，例如Data = D0D1D2D3D4D5（十进制）;则对应的S盒行是D0D5的值，对应的S盒列是D1D2D3D4的值。
//所以行=D0D5，用二进制表示是D0*2+D1*1等价于(D0<<1)+D5
//列=D1D2D3D4，用二进制表示是(D1*8+D2*4+D3*2+D4*1)等价于((D1<<3)+(D2<<2)+(D3<<1)+D4)
//注意左移运算要用括号包围起来，因为存在运算优先级，如果没有使用括号，会运算出错
x = (S[i][0] << 1) + S[i][5];
y = (S[i][1] << 3) + (S[i][2] << 2) + (S[i][3] << 1) + (S[i][4]);
sBoxData[i] = S_BOX[i][x][y];// 经过S盒得到8个十进制数字
for (j = 0; j < 4; j++) {// 把十进制数字转成4位二进制
sValue[(i * 4 + 3) - j] = sBoxData[i] % 2;
sBoxData[i] = sBoxData[i] / 2;
}
} // 经过S盒得到32位数组
for (i = 0; i < 32; i++) {
RP[i] = sValue[P_Table[i] - 1];// P盒置换得到数组就是函数f最终数组
// 左右进行交换
L1[i] = R0[i];
R1[i] = L0[i] + RP[i];
if (R1[i] == 2) {
R1[i] = 0;
}
// 注意最后一次和第一次变换时，左右不进行交换
if ((flag == 0) && (times == 0) || ((flag == 1) && (times == 15))) {// 第一次和最后一次再交换一次实现不变
M[i] = R1[i];
M[i + 32] = L1[i];
} else {
M[i] = L1[i];
M[i + 32] = R1[i];
}
}
}注意：左移运算和循环左移是不一样的概念！！

3. IP置换+函数F+逆置换

/**
* IP置换+函数F+逆置换
* @param timeData
* @param flag
* @param keyarray
* @return
*/
private byte[] Encrypt(int[] timeData, int flag, int[][] keyarray) {
int i = 0;
int[] M = new int[64];
int[] MIP_1 = new int[64];
byte[] encrypt = new byte[8];
for (i = 0; i < 64; i++) {
M[i] = timeData[IP_Table[i] - 1];// 明文数据初始置换(IP置换)
}
if (flag == 1) {// 加密
for (i = 0; i < 16; i++) {
functionF(M, i, flag, keyarray);
}
} else if (flag == 0) {// 解密:在上一篇说过，DES算法加密和解密可以使用相同的算法。加密和解密唯一不同的是秘钥的次序是相反的
for (i = 15; i >= 0; i--) {
functionF(M, i, flag, keyarray);
}
}
// 逆运算
for (i = 0; i < 64; i++) {
MIP_1[i] = M[IPR_Table[i] - 1];
}
// 返回加密数据
GetEncryptResultOfByteArray(MIP_1, encrypt);
return encrypt;

}

4. 其它辅助方法

/**
* 将64位二进制数据的数组转换成为8个整数
*
* @param data
* @param value
*/
private void GetEncryptResultOfByteArray(int[] data, byte[] value) {
int i, j;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {// i*8等价于i<<3
value[i] += data[i * 8 + j] << (7 - j);// 每位二进制数据乘于2的(7-j)次方，就是每位二进制左移(7-j)
}
}
// 如果绝对值大于255则是负数
for (i = 0; i < 8; i++) {
value[i] %= 256;
if (value[i] > 128) {
value[i] -= 255;
}
}
}

/**
* 格式化字节数组,添加填充位
* @param data
* @param flag
* @return
*/
private byte[] ByteDataFormat(byte[] data, int flag) {
int len = data.length;
int padlen = 8 - (len % 8);
int newlen = len + padlen;// 8的倍数长度
byte[] newdata = new byte[newlen];
System.arraycopy(data, 0, newdata, 0, len);
for (int i = len; i < newlen; i++) {// 易错点，i=len
newdata[i] = (byte) padlen;//随意填充任何值，不一定非要padlen
}
return newdata;
}

int[] keydata = new int[64];// 二进制加密数据
int[] encryptdata = new int[64];// 加密操作完成后的字节数据
byte[] EncrypeCode = new byte[8];// 密钥初始化成二维数组
int[][] KeyArray = new int[16][48];// 将密钥字节数组转换成二进制字节数组
byte[] bytekey;

public MyDES() {
String key = "abcdefgh";
String data = "qwertyui";
//		key = "原始秘钥";
// data = "原始数据";
this.bytekey = key.getBytes();
MyUtils.log("加密前明文：" + data);
byte[] result = DesEncrypt(data.getBytes(), 1);
MyUtils.log("加密后密文：" + new String(result));
MyUtils.log("解密后明文：" + new String(DesEncrypt(result, 0)));
}

private byte[] DesEncrypt(byte[] des_data, int flag) {
byte[] format_key = ByteDataFormat(bytekey, flag);
byte[] format_data = ByteDataFormat(des_data, flag);
int datalen = format_data.length;
int unitcount = datalen / 8;
byte[] result_data = new byte[datalen];
for (int i = 0; i < unitcount; i++) {
byte[] tmpkey = new byte[8];
byte[] tmpdata = new byte[8];
System.arraycopy(format_key, 0, tmpkey, 0, 8);
System.arraycopy(format_data, i * 8, tmpdata, 0, 8);
byte[] tmpresult = UnitDes(tmpkey, tmpdata, flag);
System.arraycopy(tmpresult, 0, result_data, i * 8, 8);
}
byte[] decryptbytearray = null;
if (flag == 0) {// 解密
int total_len = datalen;
int delete_len = result_data[total_len - 8 - 1];
delete_len = ((delete_len >= 1) && (delete_len <= 8)) ? delete_len : 0;
decryptbytearray = new byte[total_len - delete_len - 8];
boolean del_flag = true;
for (int k = 0; k < delete_len; k++) {
if (delete_len != result_data[total_len - 8 - (k + 1)]) {
del_flag = false;
}
}
if (del_flag) {
System.arraycopy(result_data, 0, decryptbytearray, 0, total_len - delete_len - 8);
}
}
return (flag == 1) ? result_data : decryptbytearray;
}

/**
* @return
*/
private byte[] UnitDes(byte[] des_key, byte[] des_data, int flag) {
if ((des_key.length != 8) || (des_data.length != 8) || ((flag != 0) && (flag != 1))) {// 检测输入参数格式是否正确，错误直接返回空值null
throw new RuntimeException("Data Format Error!");
}
int flags = flag;
int[] keydata = new int[64];// 二进制加密密钥
int[] encryptdata = new int[64];// 二进制加密数据
byte[] EncryptCode = new byte[8];// 加密操作完成后的字节数组
int[][] KeyArray = new int[16][48];// 密钥初始化成二维数组
keydata = ReadDataToBinnaryIntArray(des_key);// 将密钥字节数组转换成二进制
encryptdata = ReadDataToBinnaryIntArray(des_data);// 将加密数据字节数组转换成二进制字节数组
KeyInitialize(keydata, KeyArray);// 初始化密钥为二位密钥数组
EncryptCode = Encrypt(encryptdata, flags, KeyArray);// 执行加密解密操作
return EncryptCode;
}

5.运行结果





注意：秘钥和数据都要64位的。1个字节=8位，1个字母=1个字节，1个汉字=2个字节。

附上源码下载链接

参考文档 http://wenku.baidu.com/link?url=sYfhhjaaLrQBUze3nPCecbnLFyTOoQ2Osp7xiyJ54-XDTmYCw5EJQUW2on4obtiJ8VIPNJ38lyTScS0f3VXL6WiUkgm1g7uHFQcy-0DNvBK