package des;
/**
* 加密过程：
* 1.初始置换IP：将明文顺序打乱重新排列，置换输出为64位。
* 2.将置换输出的64位明文分成左右凉拌，左一半为L0，右一半称为R0，各32位。
* 3。计算函数的16轮迭代。
* a）第一轮加密迭代：左半边输入L0，右半边输入R0：由轮函数f实现子密钥K1对R0的加密，
* 结果为32位数据组f(R0,K1),
* b)第二轮加密迭代：左半边输入L1=R0，右半边输入R1=L0⊕f(R0,K1),由轮函数f实现子密钥
* K2对R1的加密，结果为32位数据组f(R1，K2)，f(R1,K2)与L1模2相加，得到一个32为数据组L1⊕f(R1,K2).
* c)第3到16轮迭代分别用密钥K3，K4……K16进行。4.再经过逆初始置换IP-1，将数据打乱重排，生成64位密文。
*
* 子密钥生成过程：
* 1.将64位的密钥经过PC-1置换生成56位密钥。
* 2.将56位的密钥分成左右两部分，分别进行移位操作（一共进行16轮），产生16个56位长度的子密钥。
* 3.将16个56位的子密钥分别进行PC-2置换生成16个48位的子密钥。
*
* 轮函数f的工作过程：
* 1.在第i次加密迭代过程中，扩展置换E对32位的Ri-1的各位通过置换表置换为48位的输出。
* 2.将该48位的输出与子密钥Ki进行异或操作，运算结果经过S盒代换运算，得到一个32位比特的输出。
* 3。该32位比特输出再经过P置换表进行P运算，将其各位打乱重排，生成32位的输出。
*
* @author Ouyang
*
*/
public class Des {
int[] byteKey;
public Des(int[] byteKey) {
this.byteKey = byteKey;
}
private static final int[] 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
private static final int[] IP_1 = { 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 }; // 64
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 }; // 56
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 }; // 48
private static final int[] 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 }; // 48 private static final int[] 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 }; // 32
private static final int[][][] S_Box = {// S-盒
{// S_Box[1]
{ 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 } }, { // S_Box[2]
{ 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 } }, { // S_Box[3]
{ 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 } }, { // S_Box[4]
{ 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 } }, { // S_Box[5]
{ 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 } }, { // S_Box[6]
{ 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 } }, { // S_Box[7]
{ 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 } }, { // S_Box[8]
{ 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[] LeftMove = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
/**
* 对64位明文进行IP置换处理，
* @param data 需要经过初始IP置换的明文
* @return 64位经过置换处理的明文
*/
public int[] IpReplace(int[] data){
int[] ipMingWen = new int[64];
for (int i = 0; i < ipMingWen.length; i++) {
ipMingWen[i] = data[IP[i]-1];
}
return ipMingWen;
}
public static int[] StringToBits(String data){
byte[] test = data.getBytes();
int[] IntVa = new int[64];
int[] IntDa = new int[8];
for (int i = 0; i < 8; i++) {
IntDa[i] = test[i];
if (IntDa[i] < 0) {
IntDa[i] += 256;
IntDa[i] %= 256;
}
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
IntVa[((i * 8) + 7) - j] = IntDa[i] % 2;
IntDa[i] = IntDa[i] / 2;
}
}
return IntVa;
}
/**
* 功能：对给定的数组按照offset指定的位数进行循环左移，输出经过左移后的数组* 作用：将经过pc-1置换处理后的56位密钥先分成左右各28位，然后根据左移表要求对密钥进行左移
* @param key 经过pc-1处理后的56位密钥
* @return 单个56位的子密钥（初步，未经过pc2置换）
*/
public int[] LeftMove(int[] key,int offset){
int[] subKey = new int[56];
int[] C0 = new int[28];
int[] D0 = new int[28];
int[] C1 = new int[28];
int[] D1 = new int[28];
for (int i = 0; i < 28; i++) {
C0[i] = key[i];
D0[i] = key[i+28];
}
if(offset == 1){
for(int i = 0; i < 27;i++){
C1[i] = C0[i+1];
D1[i] = D0[i+1];
}
C1[27] = C0[0];
D1[27] = D0[0];
}else if(offset == 2){
for (int 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 (int i = 0; i < 28; i++) {
subKey[i] = C1[i];
subKey[i+28] = D1[i];
}
return subKey;
}
/**
* 根据经过PC-1置换后的56位密钥生成16个56位的子密钥。再经过PC-2置换生成16个48位的子密钥
* @param key 经过pc-1置换后的56位密钥
* @return 处理完全的16个48位子密钥(以二维数组的形式存储)
*/
public int[][] SubKeyGenerate(int[] key){
int[][] subKeyArrayTemp = new int[16][56];
int[][] subKey = new int[16][48];
int[] K0 = new int[56];// 特别注意：xxx[IP[i]-1]等类似变换
//对64位的密钥进行pc-1置换变成56位的密钥
for (int i = 0; i < 56; i++) {
K0[i] = key[PC_1[i] - 1]; // 密钥进行PC-1变换
}
//由经过pc-1置换生成的56位密钥经过16轮左移，pc-2置换等操作生成16个48位的子密钥
for (int i = 0; i < 16; i++) {
subKeyArrayTemp[i] = LeftMove(K0,LeftMove[i]);
System.arraycopy(subKeyArrayTemp[i],0 , K0, 0, 56);
}
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 48; j++) {
subKey[i][j] = subKeyArrayTemp[i][PC_2[j]-1];
}
}
return subKey;
}
/**
* 对64位明文右半部分（32位）进行扩展，以进行与子密钥异或的操作
* @param data 32位的经过处理的明文
* @return 扩展后的48位明文
*/
public int[] EExpend(int[] data){
int[] dataExpend = new int[48];
for (int i = 0; i < dataExpend.length; i++) {
dataExpend[i] = data[E[i]-1];
}
return dataExpend;
}
/**
* 对输入的数据进行按位异或操作后输出，主要用在为明文右半部分（48位）和子密钥（48）异或，
* 经过S盒代换后的f函数输出（32位）与明文左半部分（32位）的异或操作
* @param data 48位的明文部分
* @param key 48位的子密钥
* @return 48位进过异或操作的输出
*/
public int[] XOR(int[] data1,int[] data2){
int[] XORResult = new int[data1.length];
for (int i = 0; i < data1.length; i++) {
XORResult[i] = data1[i]+data2[i];
if(XORResult[i] == 2){
XORResult[i] = 0;
}
}
return XORResult;
}
/**
* 将48位的经过异或处理的明密文进行S盒代换，然后对产生的32位中间结果进行P代换
* @param temp 48位的经过异或处理的中间结果
* @return 32位的经过S盒代换和P置换后的中间结果
*/
public static int[] SBoxReplace(int[] temp){
int[] sBoxResult = new int[32];//存储经过S盒代换的32位二进制处理中间结果
int[] pReplaceResult = new int[32];//存储经过S盒代换和P代换的32位的F函数处理结果
int[][] tempArray = new int[8][6];
int[] tempRowTemp = new int[8];
int roundCount = temp.length/6;
//将48位的经过异或处理的中间结果以6个为一组（共分成8组）存储在二维数组中
for (int i = 0; i < roundCount; i++) {
for (int j = 0; j < 6; j++) {
tempArray[i][j] = temp[(i*6)+j];
}
//将分成的8组（每组6个）数据根据S盒代换规则对每组6个数据进行拆分并进行S盒代换
tempRowTemp[i]=S_Box[i][(tempArray[i][0]<<1)+(tempArray[i][5])] [(tempArray[i][1]<<3)+(tempArray[i][2]<<2)+(tempArray[i][3]<<1)+(tempArray[i][4])];
//将生成的8个数（每个都是经过S盒代换后的十进制数）转换成二进制数，并按顺序存储到结果数组中
for (int j = 0; j < 4; j++) {
sBoxResult[(i*4+3)-j]=tempRowTemp[i]%2;
tempRowTemp[i] = tempRowTemp[i]/2;
}
}
for (int i = 0; i < 32; i++) {
pReplaceResult[i] = sBoxResult[P[i]-1];
}
return pReplaceResult;
}
public int[] Ip1Replace(int[] data){
int[] ipMingWen = new int[64];
for (int i = 0; i < ipMingWen.length; i++) {
ipMingWen[i] = data[IP_1[i]-1];
}
return ipMingWen;
}
/**
* 实现加密和解密工作
*
* @param data
* @param key2
* @param flag
* @return
*/
public int[] EnAndDecrypt(int[] data, int flag) {
int[] mingwen = IpReplace(data);
int[] mingwenTemp = new int[64];
int[] miwen = IpReplace(data);
int[] miwenTemp = new int[64];
int[][] keyArray = SubKeyGenerate(byteKey);
int[] temp = new int[48];
int[] tempSBox = new int[32];
int[] L0 = new int[32];
int[] R0 = new int[32];
int[] L1 = new int[32];
int[] R1 = new int[32];
int[] ER0 = new int[48];
if(1 == flag){
System.arraycopy(mingwen, 0, L0, 0, 32);
System.arraycopy(mingwen, 32, R0, 0, 32);
for (int i = 0; i < 16; i++) {
System.arraycopy(R0, 0, L1, 0, 32);
ER0 = EExpend(R0);
temp = XOR(ER0,keyArray[i]);
tempSBox = SBoxReplace(temp);
R1 = XOR(L0,tempSBox);
System.arraycopy(L1, 0, L0, 0, 32);
System.arraycopy(R1, 0, R0, 0, 32);
}
for (int i = 0; i < 32; i++) {
mingwenTemp[i] = R1[i];
mingwenTemp[i+32] = L1[i];
}
mingwen = Ip1Replace(mingwenTemp); }else if(0 == flag){
System.arraycopy(mingwen, 0, L0, 0, 32);
System.arraycopy(mingwen, 32, R0, 0, 32);
for (int i = 0; i < 16; i++) {
System.arraycopy(R0, 0, L1, 0, 32);
ER0 = EExpend(R0);
temp = XOR(ER0,keyArray[15 - i]);
tempSBox = SBoxReplace(temp);
R1 = XOR(L0,tempSBox);
System.arraycopy(L1, 0, L0, 0, 32);
System.arraycopy(R1, 0, R0, 0, 32);
}
for (int i = 0; i < 32; i++) {
miwenTemp[i] = R1[i];
miwenTemp[i+32] = L1[i];
}
miwen = Ip1Replace(miwenTemp);
}
return (flag==1) ? mingwen : miwen;
}
public static void main(String[] args) {
String dataString = "10101001";
System.out.println("明文为："+dataString);
int[] data = StringToBits(dataString);
//测试用
// int[] data = {0,0,0,0,0,0,0,1,
// 0,0,1,0,0,0,1,1,
// 0,1,0,0,0,1,0,1,
// 0,1,1,0,0,1,1,1,
// 1,0,0,0,1,0,0,1,
// 1,0,1,0,1,0,1,1,
// 1,1,0,0,1,1,0,1,
// 1,1,1,0,1,1,1,1};
System.out.println("明文的二进制表示为：");
for (int i = 0; i < 64; i++) {
System.out.print(data[i]);
}
System.out.println();
String keyString = "10101010";
System.out.println("密钥为："+keyString);
int[] key = StringToBits(dataString);
//测试用
// int[] key = {0,0,0,1,0,0,1,1,
// 0,0,1,1,0,1,0,0,
// 0,1,0,1,0,1,1,1,
// 0,1,1,1,1,0,0,1,
// 1,0,0,1,1,0,1,1,
// 1,0,1,1,1,1,0,0,
// 1,1,0,1,1,1,1,1,
// 1,1,1,1,0,0,0,1};
System.out.println("密钥的二进制表示为：");
for (int i = 0; i < 64; i++) {
System.out.print(key[i]);
}
System.out.println();
Des des = new Des(key);
int[] result = des.EnAndDecrypt(data, 1);
System.out.print("加密后的密文的二进制为：");
for (int i = 0; i < result.length; i++) {
System.out.print(result[i]);
}
System.out.println();
int[] testResult = des.EnAndDecrypt(result, 0);
System.out.print("还原为明文为：");
for (int i = 0; i < testResult.length; i++) {
System.out.print(testResult[i]);
}
}
}
package des; /** * 加密过程： * 1.初始置换IP：将明文顺序打乱重新排列，置换输出为64位。 * 2.将置换输出的64位明文分成左右凉拌，左一半为L0，右一半称为R0，各32位。 * 3。计算函数的16轮迭代。 * a）第一轮加密迭代：左半边输入L0，右半边输入R0：由轮函数f实现子密钥K1对R0的加密， * 结果为32位数据组f(R0,K1), * b)第二轮加密迭代：左半边输入L1=R0，右半边输入R1=L0⊕f(R0,K1),由轮函数f实现子密钥 * K2对R1的加密，结果为32位数据组f(R1，K2)，f(R1,K2)与L1模2相加，得到一个32为数据组L1⊕f(R1,K2). * c)第3到16轮迭代分别用密钥K3，K4……K16进行。4.再经过逆初始置换IP-1，将数据打乱重排，生成64位密文。 * * 子密钥生成过程： * 1.将64位的密钥经过PC-1置换生成56位密钥。 * 2.将56位的密钥分成左右两部分，分别进行移位操作（一共进行16轮），产生16个56位长度的子密钥。 * 3.将16个56位的子密钥分别进行PC-2置换生成16个48位的子密钥。 * * 轮函数f的工作过程： * 1.在第i次加密迭代过程中，扩展置换E对32位的Ri-1的各位通过置换表置换为48位的输出。 * 2.将该48位的输出与子密钥Ki进行异或操作，运算结果经过S盒代换运算，得到一个32位比特的输出。 * 3。该32位比特输出再经过P置换表进行P运算，将其各位打乱重排，生成32位的输出。 * * author Ouyang * */ public class Des { int[] byteKey; public Des(int[] byteKey) { this.byteKey = byteKey; } private static final int[] 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,
DES算法及其程序实现 一．D ES算法概述 ①DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。 ②DES算法的特点：分组比较短、密钥太短、密码生命周期短、运算速度较慢。 ③DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，整个算法的主流程图如下： 二．D ES算法的编程实现 #include
const static char ip[] = { //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 }; const static char 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 }; const static char sbox[8][64] = { //s_box /* S1 */ 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 */ 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 */ 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 */ 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,
#include
void main() { //声明变量 char MingWen[104]; //存放原始的明文 char target[8]; //将明文断成8个字符的一个分组 char InputKey[8]; //存放字符型的八位密钥 int text[64]; //存放一个分组转成二进制后的数据 int text_ip[64]; //存放第一次初始换位的结果 int L0[32],Li[32]; //将64位分成左右各32位进行迭代 int R0[32],Ri[32]; int RE0[48]; //存放右半部分经过E表扩展换位后的48位数据 int key[64]; //存放密钥的二进制形式 int keyPC1[56]; //存放密钥key经过PC1换位表后变成的56位二进制 int A[28]; //将keyPC1分成左右两部分，左部A，右部B，各28位，以便进行循环左移 int B[28]; int keyAB[56]; //将循环左移后两部分的结果合并起来 int K[16][48]; //存放16次循环左移产生的子密钥 int RK[48]; //存放RE和K异或运算后的结果 int RKS[8]; //存放经过查找8个S表后得到的8个十进制结果 int SP[32]; //将RKS表中的十进制数化成二进制 int RKSP[32]; //存放SP表经过P盒换位后的结果 int text_end[64]; //存放经过左右32位换位后的结果 int text_out[14][64]; //存放初始化向量和所有经过DES的分组的二进制 char init[9]={"HTmadeit"}; //设置初始化向量为“HTmadeit” int CBC[64]; int result[13][64];
DES算法实现过程分析 来源：中国论文下载中心 [ 03-03-18 14:30:00 ] 作者：本站会员编辑：丢oO丢oO 1. 处理密钥: 1.1 从用户处获得64位密钥.(每第8位为校验位,为使密钥有正确的奇偶校验,每个密钥要有奇数个”1”位.(本文如未特指，均指二进制位) 1.2 具体过程: 1.2.1 对密钥实施变换,使得变换以后的密钥的各个位与原密钥位对应关系如下表所示: 表一为忽略校验位以后情况 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 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 1.2.2 把变换后的密钥等分成两部分,前28位记为C[0], 后28位记为D[0]. 1.2.3 计算子密钥(共16个)，从i=1开始。 1.2.3.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 1.2.3.2 串联C[i],D[i]，得到一个56位数，然后对此数作如下变换以产生48位子密钥K[i]。变换过程如下： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 14 17 11 24 1 5 3 28 15 6 21 10 23 19 12 4 26 8 16 7 27 20 13 2 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 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个子密钥。 2．对64位数据块的处理： 2．1 把数据分成64位的数据块，不够64位的以适当的方式填补。 2．2对数据块作变换。 bit goes to bit bit goes to bit 58 1 57 33 50 2 49 34
实验一DES算法 实验目的： 1.深入了解DES算法的原理、特点、密钥及输入输出 2.通过编程来模拟DES算法的加密及解密过程 实验内容： 一．D ES算法概述 ①DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。 ②DES算法的特点：分组比较短、密钥太短、密码生命周期短、运算速度较慢。 ③DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，整个算法的主流程图如下：
二．D ES算法的编程实现 #include
通达学院课程设计Ⅱ报告（ 2016/ 2017学年第 1 学期） 题目： DES算法实现 专业计算机科学与技术（信息安全） 学生姓名 班级学号 指导教师王波 指导单位计算机学院信息安全系 日期
DES算法的实现 一、课题内容和要求 对称加密就是加密和解密所用的密钥是一样的，加密的强度很大程度上在于密钥的强度以及加密算法的保密，最常见的对称加密算法有DES、IDEA、RC4、RC5等。本设计题要求实现DES加密和解密算法，能对文件实现加解密。 二、对设计要求的理解 DES是一个分组密码算法，使用64位密钥（除去8位奇偶校验，实际密钥长度为56位）对64比特的数据分组（二进制数据）加密，产生64位密文数据。DES是一个对称密码体制，加密和解密使用同意密钥，解密和加密使用同一算法（这样，在硬件与软件设计时有利于加密单元的重用）。DES的所有的保密性均依赖于密钥。 程序主要采取对数据的位操作的形式，把明密文文件中的内容以字节为单位读取，每次读取8个byte共65bits，然后使用标准DES的算法依次对读取的64bits明密文进出加解密处理。文件的路径的输入有比较严格的格式约束。如：盘符名：\\文件名.txt 格式错误则会导致文件打开失败，不能进行加解密操作。 三、概要设计 这个程序主要是 DES算法部分的加密和解密，还有后面对文件的操作。 程序主要流程图如下： 图-1 程序流程图
这个程序的关键在DES算法的操作，主要有下的主要步骤： 1.初始置换 IP； 2.子密钥 Ki 的获取； 3.密码函数 f ； 4.尾置换 IP-1 ； 下面是具体的几个过程： 1）初始置换IP 这一部分很简单，IP（initial permutation）是一个 8x8 的置换表： int 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 位明文重新进行排序，即将第 58 位放到第 1 位，第 50 位放到第 2 位……以此类推。初始置换以后得到的是一个 64 位的输出。 2）子密钥 Ki 的获取 用户输出的密钥是 64 位的，根据密钥置换表PC-1，将 64 位变成 56 位密钥。（去掉了奇偶校验位）将 PC-1 置换得到的 56 位密钥，分为前28位 C0 和后28位 D0，分别对它们进行循环左移，C0左移得到 C1，D0 左移得到 D1。将 C1 和 D1 合并成 56 位，然后通过PC-2表进行压缩置换，得到当前这一轮的 48 位子密钥 K1 。然后对 C1 和 D1 进行左移和压缩置换，获取下一轮的子密钥……一共进行16轮，得到 16 个 48 位的子密钥。 3）密码函数 f ●密码函数f(R, K)接受两个输入：32 位的数据和 48 位的子密钥。然后： ●通过表 E 进行扩展置换，将输入的 32 位数据扩展为 48 位； ●将扩展后的 48 位数据与 48 位的子密钥进行异或运算； ●将异或得到的 48 位数据分成 8 个 6 位的块，每一个块通过对应的一个 S 表产 生一个 4 位的输出。 其中，每个 S 表都是 4 行 16 列。具体的置换过程如下：把 6 位输入中的第 1 位和第 6 位取出来行成一个两位的二进制数 x ，作为 Si 表中的行数（0~3）；把 6 位
北京工业大学 网络与信息安全概论 学院： 专业： 指导老师： 姓名： 学号：
目录 目录 (2) 一、DES算法的基本原理 (3) 1.1背景介绍 (3) 1.2加密原理 (3) 二、DES算法的详细步骤 (4) 2.1加密详细步骤 (4) 2.2压缩置换到56位 (5) 2.3 C0和D0的分类 (6) 2.4循环左移 (6) 2.5压缩置换 (7) 三、DES算法的实现 (7) 3.1详细设计 (8) 3.1.2加密/解密文件的预览 (8) 3.2文件的加密/解密 (9) 3.3系统测试 (11) 3.4总结 (14)
一、DES算法的基本原理 1.1背景介绍 1977年1月，美国政府颁布：采纳IBM公司设计的方案作为非机密数据的正式数据加密标准（DES-Data Encryption Standard）。 DES (Data Encryption Standard)，是IBM在上个世纪70年代开发的单密钥对称加解密算法。该算法利用一个56+8奇偶校验位(第8, 16, 24, 32, 40, 48, 56, 64位)=64位的密钥对以64位为单位的块数据进行加解密。 1.2加密原理 DES算法是这样工作的：如Mode为加密，则用Key 去把数据Data进行加密，生成Data的密码形式（64位）作为DES的输出结果；如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式（64位）作为DES的输出结果。 在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据（如PIN、MAC等）在公共通信网中传输的安全性和可靠性。 通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性，这正是现在金融交易网络的流行做法。
v 3DES加密算法的实现毕业论文 一、DES加密及解密算法程序源代码： #include
基于DES算法的数据加密解密的软件实现 摘要 随着信息社会的到来，人们在享受信息资源所带来的巨大的利益的同时，也面临着信息安全的严峻考验。信息安全已经成为世界性的现实问题，信息安全问题已威胁到国家的政治、经济、军事、文化、意识形态等领域，同时，信息安全问题也是人们能否护自己的个人隐私的关键。信息安全是社会稳定安全的必要前提条件。本文是一篇讨论关于常用文件加密解密算法的技术调研论文，它详细的讲述了文件加密解密算法实现的过程中所用到的方法、技术。对公钥密码体制和私钥密码体制进行了分析和研究，并对公钥密码体制和私钥密码体制的代表DES算法进行了研究。 关键字：文件解密，文件加密，密码体制，DES。 第一章 DES算法的技术背景介绍 1.1 背景与意义 DES是由美国IBM公司于20世纪70年代中期的密码算法发展而来的，在1977年1月15日，美国国家标准局正式公布实施，并得到了ISO的认可。在过去近20年的时间里，DES被广泛应用于美国联邦和各种商业信息的安全保密工作中，经受信了各种密码分析和攻击，体现出了令人满意的字全性。但随着密码分析技术和计算能力的提高，1994年，美国决定不再使用DES算法，目前DES算法已被更为安全的加解密算法取代。虽然这样，但是目前还无法将DES加密算法彻底破解掉，而且DES算法的加解密算法非常快，仍是目前使用最为普遍的对称密码算法。在国内，随着三金工程尤其是金卡工程的启动，DES算法在POS、A TM、磁卡及智能卡、加汕站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡人的PIN码加密伟输，IC卡与POS机之间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。 1.2 系统设计 1.2.1 系统主要目标 基本要求部分： 1．能够对一个明文分组进行加密，加密后能够正确解密。 2．程序运行时可以输出任一组密钥。因为实现了对任意长度明加密，所以没输出每一轮加密后的结果。因为当明文长度过长时，每一轮加密结果会很多。 3．程序有良好的人机交互操作。 较高要求部分： 1．如果明文不止一个分组，程序能完成分组，然后加密；最后一个分组长度不足时要求完成填充。 2．密钥采用ASCII码，明文输入信息可以是文字（可以是汉字或英文，要求不止一个加密分组长度），任意字符。进行加密后，能够进行正确的解密。
DES算法的C语言代码及实现 首先新建头文件des_encode.H 内容如下： void EncodeMain(); //EncodeMain function void DecodeMain(); //Sorry ,it has not used void Decode(int *str,int *keychar); //decode :input 8 chars,8 keychars void Encode(int *str,int *keychar); //encode: input 8 chars,8 keychars void keyBuild(int *keychar); //create key array void StrtoBin(int *midkey,int *keychar); //change into binary void keyCreate(int *midkey2,int movebit,int i); //call by keyBuild void EncodeData(int *lData,int *rData,int *srt); //encodedata function void F(int *rData,int *key); //F function void Expand(int *rData,int *rDataP); //Expand function void ExchangeS(int *rDataP,int *rData); //S-diagram change void ExchangeP(int *rData); //P change void FillBin(int *rData,int n,int s); // data to binary;call by S-Diagram change function void DecodeData(int *str,int *lData,int *rData); //DecodeData from binary int IP1[]={58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, //initial change 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,
DES算法用C++实现的源代码 用C++实现的源代码 #include "memory.h" #include "stdio.h" enum {encrypt,decrypt};//ENCRYPT:加密，DECRYPT：解密 void des_run(char out[8],char in[8],bool type=encrypt); //设置密钥 void des_setkey(const char key[8]); static void f_func(bool in[32],const bool ki[48]);//f函数 static void s_func(bool out[32],const bool in[48]);//s盒代替 //变换 static void transform(bool *out, bool *in, const char *table, int len); static void xor(bool *ina, const bool *inb, int len);//异或 static void rotatel(bool *in, int len, int loop);//循环左移 //字节组转换成位组 static void bytetobit(bool *out,const char *in, int bits); //位组转换成字节组 static void bittobyte(char *out, const bool *in, int bits); //置换IP表 conststatic char ip_table[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,2 3,15,7}; //逆置换IP-1表 const static char ipr_table[64]={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,1 7,57,25}; //E 位选择表 static const char e_table[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,3 1,32,1}; //P换位表 const static char p_table[32]={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}; //pc1选位表 const static char pc1_table[56]={ 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
DES算法提供CBC, OFB, CFB, ECB四种模式，MAC是基于ECB实现的。 一、数据补位 DES数据加解密就是将数据按照8个字节一段进行DES加密或解密得到一段8个字节的密文或者明文，最后一段不足8个字节，按照需求补足8个字节（通常补00或者FF，根据实际要求不同）进行计算，之后按照顺序将计算所得的数据连在一起即可。 这里有个问题就是为什么要进行数据补位？主要原因是DES算法加解密时要求数据必须为8个字节。 二、ECB模式 DES ECB（电子密本方式）其实非常简单，就是将数据按照8个字节一段进行DES加密或解密得到一段8个字节的密文或者明文，最后一段不足8个字节，按照需求补足8个字节进行计算，之后按照顺序将计算所得的数据连在一起即可，各段数据之间互不影响。 三、CBC模式 DES CBC（密文分组链接方式）有点麻烦，它的实现机制使加密的各段数据之间有了联系。其实现的机理如下： 加密步骤如下： 1）首先将数据按照8个字节一组进行分组得到D1D2......Dn（若数据不是8的整数倍，用指定的PADDING数据补位） 2）第一组数据D1与初始化向量I异或后的结果进行DES加密得到第一组密文C1（初始化向量I为全零） 3）第二组数据D2与第一组的加密结果C1异或以后的结果进行DES加密，得到第二组密文C2 4）之后的数据以此类推，得到Cn 5）按顺序连为https://www.doczj.com/doc/ac7075203.html,即为加密结果。 解密是加密的逆过程，步骤如下： ）首先将数据按照8个字节一组进行分组得到https://www.doczj.com/doc/ac7075203.html, 2）将第一组数据进行解密后与初始化向量I进行异或得到第一组明文D1（注意：一定是先解密再异或） 3）将第二组数据C2进行解密后与第一组密文数据进行异或得到第二组数据D2
EDA试验报告 一、实验项目名称 DES算法 二、实验目的与要求 1.掌握DES的原理和设计方法。 2.了解QuartusII硬件电路设计流程,学会利用Modelsim进行仿真。 3.加深对自顶向下设计和分模块化的了解，学会模块化的设计方法。 三、实验步骤 （一）.DES算法原理 DES算法为密码体制中的对称密码体制，又被称为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。
其入口参数有三个:key、data、mode。key为加密解密使用的密钥，data为加密解密的数据，mode为其工作模式。当模式为加密模式时，明文按照64位进行分组，形成明文组，key用于对数据加密，当模式为解密模式时，key用于 对数据解密。实际运用中，密钥只用到了64位中的56位，这样才具有高的安全性。DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，整个算法的主流程图如下: （二）、VerilogHDL实现原理 拟采用模块化设计思想，根据DES算法的流程分模
块设计实现各模块，自顶向下最终实现DES加密算法。 各模块功能及实现如下所示： 1.整体结构框架搭建，实现总体功能 module DES(input clk, input des_enable, input reset, input des_mode, input [1:64] data_i, input [1:64] key_i, output wire [1:64] data_o, output ready_o); wire [3:0] inter_num_curr; wire [1:32] R_i_var, L_i_var; wire [1:56] Key_i_var_out; wire [1:64] data_o_var_t; wire [1:32] R_i, L_i; wire [1:32] R_o, L_o; wire [1:56] Key_o; wire [1:28] C0, D0; IP IP1(.in(data_i), .L_i_var(L_i_var), .R_i_var(R_i_var)); IP_ni IP_ni(.in(data_o_var_t), .out(data_o)); pc_1 pc_1(.key_i(key_i), .C0(C0), .D0(D0)); //F(R,K) des_f des_f1(.clk(clk), .reset(reset), .des_mode(des_mode), .inter_num_i(inter_num_curr), .R_i(R_i), .L_i(L_i), .Key_i(Key_i_var_out), .R_o(R_o), .L_o(L_o), .Key_o(Key_o));
苏州科技学院电子与信息工程学院 实验报告 实验一 （实验）课程名称信息安全技术 实验名称DES加密算法的简单实现
实验报告 一、实验室名称：电子学院213机房 二、实验项目名称：DES加密算法的简单实现 三、实验学时：2学时 四、实验原理： DES的描述 DES是一种分组加密算法，他以64位为分组对数据加密。64位一组的明文从算法的一端输入，64位的密文从另一端输出。DES是一个对称算法：加密和解密用的是同一个算法（除密钥编排不同以外）。 密钥的长度为56位(密钥通常表示为64位的数，但每个第8位都用作奇偶检验，可以忽略)。密钥可以是任意的56位数，且可以在任意的时候改变。 DES算法的入口参数有3个：Key，Data，Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或解密的数据：Mode为DES的工作方式，有两种：加密或解密。 DES算法的工作过程：若Mode为加密，则用Key对数据Data进行加密，生成Data的密码形式（64位）作为DES的输出结果；若Mode为解密，则用Key 对密码形式的数据Data解密，还原为Data的明码形式（64位）作为DES的输出结果。 DES算法详述 DES算法把64位的明文输入块变为64位的密文输出块，他所使用的密钥也是64位，DES对64 位的明文分组进行操作。通过一个初始置换，将明文分组分成左半部分和右半部分，各32位长。然后进行16轮相同的运算，这些相同的运算被称为函数f，在运算过程中数据和密钥相结合。经过16轮运算后左、右部分在一起经过一个置换（初始置换的逆置换），这样算法就完成了。 （1）初始置换 其功能是把输入的64位数据块按位重新组合，并把输出分为L0，R0两部分，每部分各长32位， 即将输入的第58位换到第1位，第50位换到第2位，…，依次类推，最后一位是原来的第7位，L0，R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位。。 （2）逆置换
项目报告：DES 算法的实现与分析 组员：柴彦廷 121041302 李雨潇 121041316 唐均 121041328 王森 121041333 王钰 121041334 熊枫 121041337
目录 1. 引言.......................................... 错误！未定义书签。 2. 项目研究...................................... 错误！未定义书签。 2.1 框架设计、模块划分........................ 错误！未定义书签。 2.2. DES加密技术简介.......................... 错误！未定义书签。 3. 方案设计...................................... 错误！未定义书签。 3.1 明文的输入与转化.......................... 错误！未定义书签。 3.2 S盒及P盒原理简介........................ 错误！未定义书签。 3.3 子密钥的产生.............................. 错误！未定义书签。 3.4 16轮循环加密............................. 错误！未定义书签。 4. 仿真结果输出.................................. 错误！未定义书签。 5. DES算法特点总结............................... 错误！未定义书签。 6. 参考文献...................................... 错误！未定义书签。 7. 程序代码...................................... 错误！未定义书签。 一、引言 项目的选题目的和意义：