des算法实现课程设计大学毕设论文
通达学院课程设计Ⅱ报告（ 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 位
输入的中间 4 位构成另外一个二进制数 y，作为 Si 表的列数（0~15）；查出 Si 表中 x 行 y 列所对应的整数，将该整数转换为一个 4 位的二进制数。
把通过 S 表置换得到的 8 个 4 位连在一起，形成一个 32 位的数据。然后将该
32 位数据通过表 P 进行置换（称为P-置换），置换后得到一个仍然是 32 位的结果数
据，这就是f(R, K)函数的输出。
4）尾置换IP-1
合并 L16 和 R16 得到一个 64 位的数据，再经过尾置换后得到的就是 64 位的密文。注意：要将 L16和 R16 合并成 R16L16（即左右互换）。尾置换表IP-1如下：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};
四、关键技术难点分析
在 DES 算法的实现中，我用 C++ STL 中的bitset来操作二进制位。下面是对一个 64 位数据进行加密解密的源代码：
bitset<64> key; // 64位密钥
bitset<48> subKey[16]; // 存放16轮子密钥
// 初始置换表
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 };
// 结尾置换表
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位密钥变成56位
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位密钥压缩成48位子密钥
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 };
// 每轮左移的位数
int shiftBits[] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
/*------------------下面是密码函数f 所用表-----------------*/
// 扩展置换表，将32位扩展至48位
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 };
// S盒，每个S盒是4x16的置换表，6位-> 4位
int S_BOX[8][4][16] = {
{
{ 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位
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 };
/**********************************************************************/
/* */
/* 下面是DES算法实现*/
/* */
/**********************************************************************/
/**
* 密码函数f，接收32位数据和48位子密钥，产生一个32位的输出
*/
bitset<32> f(bitset<32> R, bitset<48> k)
{
bitset<48> expandR;
// 第一步：扩展置换，32 -> 48
for (int i = 0; i<48; ++i)
expandR[47 - i] = R[32 - E[i]];
// 第二步：异或
expandR = expandR ^ k;
// 第三步：查找S_BOX置换表
bitset<32> output;
int x = 0;
for (int i = 0; i<48; i = i + 6)
{
int row = expandR[47 - i] * 2 + expandR[47 - i - 5];
int col = expandR[47 - i - 1] * 8 + expandR[47 - i - 2] * 4 + expandR[47 - i - 3] * 2 + expandR[47 - i - 4];
int num = S_BOX[i / 6][row][col];
bitset<4> binary(num);
output[31 - x] = binary[3];
output[31 - x - 1] = binary[2];
output[31 - x - 2] = binary[1];
output[31 - x - 3] = binary[0];
x += 4;
}
// 第四步：P-置换，32 -> 32
bitset<32> tmp = output;
for (int i = 0; i<32; ++i)
output[31 - i] = tmp[32 - P[i]];
return output;
}
/**
* 对56位密钥的前后部分进行左移
*/
bitset<28> leftShift(bitset<28> k, int shift)
{
bitset<28> tmp = k;
for (int i = 27; i >= 0; --i)
{
if (i - shift<0)
k[i] = tmp[i - shift + 28];
else
k[i] = tmp[i - shift];
}
return k;
}
/**
* 生成16个48位的子密钥
*/
void generateKeys()
{
bitset<56> realKey;
bitset<28> left;
bitset<28> right;
bitset<48> compressKey;
// 去掉奇偶标记位，将64位密钥变成56位
for (int i = 0; i<56; ++i)
realKey[55 - i] = key[64 - PC_1[i]];
// 生成子密钥，保存在subKeys[16] 中
for (int round = 0; round<16; ++round)
{
// 前28位与后28位
for (int i = 28; i<56; ++i)
left[i - 28] = realKey[i];
for (int i = 0; i<28; ++i)
right[i] = realKey[i];
// 左移
left = leftShift(left, shiftBits[round]);
right = leftShift(right, shiftBits[round]);
// 压缩置换，由56位得到48位子密钥
for (int i = 28; i<56; ++i)
realKey[i] = left[i - 28];
for (int i = 0; i<28; ++i)
realKey[i] = right[i];
for (int i = 0; i<48; ++i)
compressKey[47 - i] = realKey[56 - PC_2[i]];
subKey[round] = compressKey;
}
}
/**
* 工具函数：将char字符数组转为二进制
*/
bitset<64> charToBitset(const char s[8])
{
bitset<64> bits;
for (int i = 0; i<8; ++i)
for (int j = 0; j<8; ++j)
bits[i * 8 + j] = ((s[i] >> j) & 1);
return bits;
}
/**
* DES加密
*/
bitset<64> encrypt(bitset<64>& plain)
{
bitset<64> cipher;
bitset<64> currentBits;
bitset<32> left;
bitset<32> right;
bitset<32> newLeft;
// 第一步：初始置换IP
for (int i = 0; i<64; ++i)
currentBits[63 - i] = plain[64 - IP[i]];
// 第二步：获取Li 和Ri
for (int i = 32; i<64; ++i)
left[i - 32] = currentBits[i];
for (int i = 0; i<32; ++i)
right[i] = currentBits[i];
// 第三步：共16轮迭代
for (int round = 0; round<16; ++round)
{
newLeft = right;
right = left ^ f(right, subKey[round]);
left = newLeft;
}
// 第四步：合并L16和R16，注意合并为R16L16
for (int i = 0; i<32; ++i)
cipher[i] = left[i];
for (int i = 32; i<64; ++i)
cipher[i] = right[i - 32];
// 第五步：结尾置换IP-1
currentBits = cipher;
for (int i = 0; i<64; ++i)
cipher[63 - i] = currentBits[64 - IP_1[i]];
// 返回密文
return cipher;
}
/**
* DES解密
*/
bitset<64> decrypt(bitset<64>& cipher)
{
bitset<64> plain;
bitset<64> currentBits;
bitset<32> left;
bitset<32> right;
bitset<32> newLeft;
// 第一步：初始置换IP
for (int i = 0; i<64; ++i)
currentBits[63 - i] = cipher[64 - IP[i]];
// 第二步：获取Li 和Ri
for (int i = 32; i<64; ++i)
left[i - 32] = currentBits[i];
for (int i = 0; i<32; ++i)
right[i] = currentBits[i];
// 第三步：共16轮迭代（子密钥逆序应用）
for (int round = 0; round<16; ++round)
{
newLeft = right;
right = left ^ f(right, subKey[15 - round]);
left = newLeft;
}
// 第四步：合并L16和R16，注意合并为R16L16
for (int i = 0; i<32; ++i)
plain[i] = left[i];
for (int i = 32; i<64; ++i)
plain[i] = right[i - 32];
// 第五步：结尾置换IP-1
currentBits = plain;
for (int i = 0; i<64; ++i)
plain[63 - i] = currentBits[64 - IP_1[i]];
// 返回明文
return plain;
}
下面是对于文件的函数实现：
void encryptfile()
{
string a, b, k;
cout << "请输入待加密文件名（完整路径）：" << endl;
cin >> a;
cout << "请输入密钥：" << endl;
cin >> k;
cout << "请输入密文文件名（完整路径）：" << endl;
cin >> b;
key = charToBitset(k.c_str());
generateKeys(); // 生成16个子密钥
ifstream in;
ofstream out;
in.open(a, ios::binary);
out.open(b, ios::binary);
bitset<64> plain;
while (in.read((char*)&plain, sizeof(plain)))
{
bitset<64> cipher = encrypt(plain);
out.write((char*)&cipher, sizeof(cipher));
plain.reset(); // 置0
}
in.close();
out.close();
cout << "加密成功，密文文件在" << b << endl;
}
void decodefile()
{
string a, b, k;
cout << "请输入密文文件名（完整路径）：" << endl;
cin >> a;
cout << "请输入密钥：" << endl;
cin >> k;
cout << "请输入解密后文件名（完整路径）：" << endl;
cin >> b;
key = charToBitset(k.c_str());
generateKeys(); // 生成16个子密钥
ifstream in;
ofstream out;
in.open(a, ios::binary);
out.open(b, ios::binary);
bitset<64> plain;
while (in.read((char*)&plain, sizeof(plain)))
{
bitset<64> temp = decrypt(plain);
out.write((char*)&temp, sizeof(temp));
plain.reset(); // 置0
}
in.close();
out.close();
cout << "解密成功，明文文件在" << b << endl;
}
五、测试数据及其结果分析
设计结果和性能分析
这个程序通过循环来对文件加密，每64位进行加密，直到文件结束，不足64位补足加密。
现在对一个文本文件13001528.txt进行加密文件内容为
图-2 待加密明文文件13001528.txt
进行加密操作：
图-3 加密操作界面显示加密成功。密文文件为：
图-4 密文文件
再通过解密:
图-5 解密界面
打开明文文件：
图-6 解密后明文文件
通过以上的结果可以看出解密后的明文和原文件是相同的，这个程序满足的设计的需求。
六、课程设计总结
这次的课程设计是我不太熟悉的关于加密DES算法的相关的程序，这一次通过查阅之前的书本，和在网上看一些大牛写的文章，写出了这个程序，通过这次的学习对于密码学的DES算法的部分算是有了一些的掌握，但是这个程序没有对时间和空间进行优化，对于加密数据大的文件，加密解密速度很慢。这也需要在以后的学习中解决。总之这次的程序设计收获很多。
DES算法Java实现源代码
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,
密码学基础课程设计指导书
《现代密码学基础》课程设计指导书 杨柳编 湖南科技大学计算机科学与工程学院 2014年12月
一、概述 本课程在简要复习数学基础知识之后，探讨了密码学研究的基本问题：通过不安全的通信媒介如何进行安全通信。也可以理解为关心任何希望限制不诚实者达到目的的问题，把度量和评价一个密码体制（协议）的安全性作为一个重点。就目前来说，密码学的研究领域已从消息加密扩大到了数字签名、消息认证、身份识别、抗欺骗协议等。无疑，在整个教学过程中非常重视密码学的基础，当然包括数学基础。并针对实际的密码体制（协议）强调设计与分析（攻击），对现代密码学的主要研究问题都进行了介绍。 对于密码学这样的课程，同学们一定要从理论、技术、应用三个方面进行学习与思考。密码体制（协议）无疑是我们的学习重点，密码体制（协议）也可以单纯地理解为计算机算法，从而有设计、分析、证明、实现的问题。实现密码体制（协议）就是我们经常讲的八个字：模型、算法、程序、测试。 二、课程设计步骤 课程设计步骤要求如下： 1.模型 从数学的角度看，解决任何问题都要建立一个数学模型，对于密码学来说更是如此。我们还可以认为，数据结构中的存储结构也是模型。于是这一部分的任务就是建立起问题的逻辑结构和存储结构，为算法设计和编码实现打下基础。 2.算法 这一部分对同学们的要求是能看懂书上的常用算法，并对其中的参数可以进行调整和设置，能实现和应用它们。 3.程序 编码实现得到程序。 4. 测试 5. 提交课程设计报告
三、课程设计报告编写要求 课程设计报告开头标明课程设计题目、设计者的班级、姓名、学号和完成日期，内容包括：模型、算法、程序、测试四个部分。 四、设计要求 可以只做第7题，不做第7题的要做第1题-第6题。 五、课程设计题目 大整数运算包的设计与实现 1．问题描述 大整数运算是现代密码学算法实现的基础，重要性不言而喻。大整数我们指的是二进制位512、1024和2048的数，一般的语言不支持。 2．基本要求 以类库头文件的形式实现。 3．实现提示 在选择了大整数的存储结构之后，主要实现以下运算： ①模加； ②模减； ③模乘； ④模整除； ⑤模取余。这五种运算模拟手算实现。 ⑥幂模：利用“平方-乘法”算法实现。 ⑦GCD：利用欧几里得算法实现。 ⑧乘法逆: 利用扩展的欧几里得算法实现。 ⑨素数判定与生成：概率性素数产生方法产生的数仅仅是伪素数，其缺点在于，
文件加密与解密—Java课程设计报告
JAVA课程设计题目：文件的加密与解密 姓名： 学号： 班级: 日期：
目录 一、设计思路 (3) 二、具体实现 (3) 三、运行调试与分析讨论 (8) 四、设计体会与小结 (11) 五、参考文献 (12) 六、附录 (12)
一、设计思路 自从Java技术出现以业，有关Java平台的安全性用由Java技术发展所引发的安全性问题，引起了越来越多的关注。目前，Java已经大量应用于各个领域，研究Java的安全性对于更好地利用Java具有深远的意义。使用Java的安全机制设计和实现安全系统更具有重要的应用价值。 本课程设计，主要实践Java安全中的JCE模块，包括密钥生成，Cipher对象初始化、加密模式、填充模式、底层算法参数传递，也涉及文件读写与对象输入输出流。 二、具体实现 本系统通过用户界面接收三个参数：明文文件、密文文件、口令。采用DES加密算法，密码分组链（Cipher Block Chaining，CBC）加密模式，PKCS#5-Padding的分组填充算法。因为CBC涉及到底层算法参数的解密密钥的传递，所以将明文文件中的字节块以密封对象（Sealed Object）的方式加密后，用对象流输出到密文文件，这样就将密文、算法参数、解密密钥三都密封到一个对象中了。口令的hash值作为产生密钥的参数。设计流程图如下所示： 文件加密与解密设计流程图
本系统中，包含Default,Shares,SecretKey,EncAndDec四个包共6个类组成。定义的几个参数：MAX_BUF_SIZE为每次从文件中读取的字节数，也是内存缓冲区的大小；加密算法为DES；加密模式是密码分组链（CBC）模式；分组填充方式是PKCS#5Padding。包和类结构图如下所示： 本课程设计，包和类结构图： 以下为包中的类的方法实现说明 Package Shares类结构图
DES算法实验报告
DES算法实验报告 姓名：学号：班级： 一、实验环境 1．硬件配置：处理器（英特尔Pentium双核E5400 @ 2.70GHZ 内存：2G） 2．使用软件： ⑴操作系统：Windows XP 专业版32位SP3(DirectX 9.0C) ⑵软件工具：Microsoft Visual C++ 6.0 二、实验涉及的相关概念或基本原理 1、加密原理 DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行“异或”运算；接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用 16 个循环，使用异或，置换，代换，移位操作四种基本运算。 三、实验内容 1、关键代码 ⑴子密钥产生
⑵F函数以及加密16轮迭代 2、DES加密算法的描述及流程图 ⑴子密钥产生 在DES算法中，每一轮迭代都要使用一个子密钥，子密钥是从用户输入的初始密钥产生的。K是长度为64位的比特串，其中56位是密钥，8位是奇偶校验位，分布在8，16，24，32，40，48，56，64比特位上，可在8位中检查单个错误。在密钥编排计算中只用56位，不包括这8位。子密钥生成大致分为：置换选择1（PC-1）、循环左移、置换选择2（PC-2）等变换，分别产生16个子密钥。 DES解密算法与加密算法是相同的，只是子密钥的使用次序相反。 ⑵DES加密算法 DES密码算法采用Feistel密码的S-P网络结构，其特点是：加密和解密使用同一算法、
AES密码学课程设计(C语言实现)
成都信息工程学院课程设计报告 AES加密解密软件的实现 课程名称：应用密码算法程序设计 学生姓名：樊培 学生学号：2010121058 专业班级：信息对抗技术101 任课教师：陈俊 2012 年6月7日
课程设计成绩评价表
目录 1、选题背景 (4) 2、设计的目标 (4) 2.1基本目标： (4) 2.2较高目标： (5) 3、功能需求分析 (5) 4、模块划分 (6) 4.1、密钥调度 (6) 4.2、加密 (8) 4.2.1、字节代替（SubBytes） (8) 4.2.2、行移位（ShiftRows） (10) 4.2.3、列混合（MixColumn） (11) 4.2.4、轮密钥加（AddRoundKey） (13) 4.2.5、加密主函数 (14) 4.3、解密 (16) 4.3.1、逆字节替代（InvSubBytes） (16) 4.3.2、逆行移位（InvShiftRows） (17) 4.3.3、逆列混合（InvMixCloumns） (17) 4.3.4、轮密钥加（AddRoundKey） (18) 4.3.5、解密主函数 (18) 5.测试报告 (20) 5.1主界面 (20) 5.2测试键盘输入明文和密钥加密 (20) 5.3测试键盘输入密文和密钥加密 (21) 5.3测试文件输入明文和密钥加密 (22) 5.4测试文件输入密文和密钥加密 (22) 5.5软件说明 (23) 6.课程设计报告总结 (23) 7.参考文献 (24)
1、选题背景 高级加密标准（Advanced Encryption Standard，AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael 之命名之，投稿高级加密标准的甄选流程。（Rijndael的发音近于 "Rhine doll"） 严格地说，AES和Rijndael加密法并不完全一样（虽然在实际应用中二者可以互换），因为Rijndael加密法可以支援更大范围的区块和密钥长度：AES的区块长度固定为128 位元，密钥长度则可以是128，192或256位元；而Rijndael使用的密钥和区块长度可以是32位元的整数倍，以128位元为下限，256位元为上限。加密过程中使用的密钥是由Rijndael 密钥生成方案产生。大多数AES计算是在一个特别的有限域完成的。 截至2006年，针对AES唯一的成功攻击是旁道攻击 旁道攻击不攻击密码本身，而是攻击那些实作于不安全系统（会在不经意间泄漏资讯）上的加密系统。2005年4月，D.J. Bernstein公布了一种缓存时序攻击法，他以此破解了一个装载OpenSSL AES加密系统的客户服务器[6]。为了设计使该服务器公布所有的时序资讯，攻击算法使用了2亿多条筛选过的明码。有人认为[谁？]，对于需要多个跳跃的国际互联网而言，这样的攻击方法并不实用[7]。 Bruce Schneier称此攻击为“好的时序攻击法”[8]。2005年10月，Eran Tromer和另外两个研究员发表了一篇论文，展示了数种针对AES的缓存时序攻击法。其中一种攻击法只需要800个写入动作，费时65毫秒，就能得到一把完整的AES密钥。但攻击者必须在执行加密的系统上拥有执行程式的权限，方能以此法破解该密码系统。 虽然高级加密标准也有不足的一面，但是，它仍是一个相对新的协议。因此，安全研究人员还没有那么多的时间对这种加密方法进行破解试验。我们可能会随时发现一种全新的攻击手段会攻破这种高级加密标准。至少在理论上存在这种可能性。 2、设计的目标 2.1基本目标： （1）在深入理解AES加密/解密算法理论的基础上，能够设计一个AES加密/解密软件系统，采用控制台模式，使用VS2010进行开发，所用语言为C语言进行编程，实现加密解密； （2）能够完成只有一个明文分组的加解密，明文和密钥是ASCII码，长度都为16个字符(也就是固定明文和密钥为128比特)，输入明文和密钥，输出密文，进行加密后，能够进
RSA加密解密的设计与实现
RSA加密解密的设计与实现
上海电力学院 《应用密码学》课程设计 题目： RSA加密解密的设计与实现 院系：计算机科学与技术学院 专业年级：级 学生姓名：李正熹学号： 3273 指导教师：田秀霞 1月 8日 目录
目录 1.设计要求 2.开发环境与工具 3.设计原理（算法工作原理） 4.系统功能描述与软件模块划分 5.设计核心代码 6.参考文献 7. 设计结果及验证 8. 软件使用说明 9. 设计体会 附录 1.设计要求
1 随机搜索大素数，随机生成公钥和私钥 2 用公钥对任意长度的明文加密 3 用私钥对密文解密 4 界面简洁、交互操作性强 2.开发环境与工具 Windows XP操作系统 Microsoft Visual C++ 6.0 1.创立rsa工程
2.在rsa工程中创立 3273 李正熹cpp文件 3.设计原理 RSA算法简介 公开密码算法与其它密码学完全不同，它是基于数学函数而不是基于替换或置换。与使用一个密钥的对称算法不同，公开密钥算法是非对称的，而且它使用的是两个密钥，包括用于加密的公钥和用于解密的私钥。公开密钥算法有RSA、Elgamal等。 RSA公钥密码算法是由美国麻省理工学院(MIT)的Rivest，Shamir和Adleman在1978年提出来的，并以她们的名字的有字母命名的。RSA是第一个安全、实用的公钥密码算法，已经成为公钥密码的国际标准，是当前应用广泛的公钥密码体制。
RSA的基础是数论的Euler定理，其安全性基于二大整数因子分解问题的困难性，公私钥是一对大素数的函数。而且该算法已经经受住了多年深入的密码分析，虽然密码分析者既不能证明也不能否定RSA的安全性，但这不恰恰说明该算法有其一定的可信度。 4.系统功能描述与软件模块划分 功能：
DES算法及其程序实现
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,
1密码学-DES实验报告
南京信息工程大学实验（实习）报告实验（实习）名称对称密码实验（实习）日期得分指导教师 系计软院专业网络工程年2011 班次 1 姓名学号20111346026 一．实验目的 1.理解对称加密算法的原理和特点 2.理解DES算法的加密原理 二．实验内容 第一阶段：初始置换IP。在第一轮迭代之前，需要加密的64位明文首先通过初始置换IP 的作用，对输入分组实施置换。最后，按照置换顺序，DES将64位的置换结果分为左右两部分，第1位到第32位记为L0，第33位到第64位记为R0。 第二阶段：16次迭代变换。DES采用了典型的Feistel结构，是一个乘积结构的迭代密码算法。其算法的核心是算法所规定的16次迭代变换。DES算法的16才迭代变换具有相同的结构，每一次迭代变换都以前一次迭代变换的结果和用户密钥扩展得到的子密钥Ki作为输入；每一次迭代变换只变换了一半数据，它们将输入数据的右半部分经过函数f后将其输出，与输入数据的左半部分进行异或运算，并将得到的结果作为新的有半部分，原来的有半部分变成了新的左半部分。用下面的规则来表示这一过程（假设第i次迭代所得到的结果为LiRi）: Li = Ri-1; Ri = Li-1⊕f(Ri-1,Ki);在最后一轮左与右半部分并未变换，而是直接将R16 L16并在一起作为未置换的输入。 第三阶段：逆（初始）置换。他是初始置换IP的逆置换，记为IP-1。在对16次迭代的结果（R16 L16）再使用逆置换IP-1后，得到的结果即可作为DES加密的密文Y输出，即Y = IP-1 （R16 L16） 三．流程图&原理图
流程图
DES原理图
微机原理课程设计加密解密算法
加密解密程序设计 1设计算法概述 本设计主要采用对密码符号的ASCII码进行变换和反变换来实现加密和解密。将ASCII码从33到126（除控制字符外）的字符分成2部分：ASCII码从33到63的字符为第一部分，ASCII码在64到128之间的字符为第二部分。每个字符加密后均变为2个字符。 第一部分通过查表法加密和解密，先建立62字节的密码表。加密时，因为一个字符加密后变为两个字符，所以ASCII码从33到63的31个字符密码对应62个字符，即62个字节的数据，计算待加密字符ASCII码对33的偏移量，在密码表中，以这个偏移量乘以2为偏移量的字节数据和下一字节数据就是对应密码；解密时，在表中找到相同字型数据时，计算它对表首的偏移，再加33，就是解密后的字符的ASCII码。 第二部分通过判断字符ASCII码的特性来加密和解密。先判断输入字符的ASCII码是否为3的倍数，若是则对应密码的高位字节为35 ('#')，低位字节为本身ASCII码减一；再判断输入字符的ASCII码是否为5的倍数，若是则对应密码的高位字节为37（‘%’），低位字节为本身ASCII码减3；最后判断输入字符的ASCII码是偶数还是寄数，偶数的密码高字节为38（‘&’），低字节为本身ASCII码加1，奇数的密码高字节为39（‘'’），低字节为本身ASCII码加3 。解密的时候先判断高字节数据，若高字节数据位35、37、38、39则舍去高位字节，低位字节分别进行相应的解密，就得到原码。 2主程序设计 2.1主程序的功能 主程序主要是人机交互部分，提示输入信息和功能选择。程序开始，提示用
户选择相应的功能：按E、e调用加密子程序，进入加密状态，按R、r调用解密子程序，进入解密状态，按Esc退出程序，若输入错误则再次提示输入功能选择。 2.2主程序流程图 主程序流程图如图1所示。 图1 主程序流程图
DES算法源代码
#include
华科大密码学课程设计实验报告
密码学课程设计实验报告 专业：信息安全 班级：0903 姓名：付晓帆 学号：U200915328
一、 DES 的编程实现 1.实验目的 通过实际编程掌握DES 的加、脱密及密钥生成过程，加深对DES 算法的认识。 2.实验原理 a.加密过程 DES 是一个分组密码，使用长度为56比特的密钥加密长度为64比特的明文，获得长度为64比特的密文，其加密过程： (1) 给定一个明文X ，通过一个固定的初始置换IP 置换X 的比特，获得X0，X0=IP(X)=L0R0，L0R0分别是X0的前32比特和后32比特。 (2) 然后进行16轮完全相同的运算，有如下规则，其中0 兰州商学院陇桥学院工学系课程设计报告 课程名称： Java 设计题目：加密与解密 系别：工学系 专业 (方向)：信息管理与信息系统 年级、班：2012级（2）班 学生姓名：费亚芬 学生学号： 208 指导教师：张鑫 2014年7 月 1日 目录 一、系统开发的背景................................. 错误!未定义书签。 二、系统分析与设计................................. 错误!未定义书签。（一）............................................. 系统功能要求错误!未定义书签。（二）......................................... 系统模块结构设计错误!未定义书签。 三、系统的设计与实现............................... 错误!未定义书签。（一）图形用户界面模块 ........................... 错误!未定义书签。（二）加密操作模块 ............................... 错误!未定义书签。 (三)解密操作模块................................ 错误!未定义书签。（四）文件保存模块 ............................... 错误!未定义书签。 （五）文件选择模块 ............................... 错误!未定义书签。 四、系统测试....................................... 错误!未定义书签。（一）测试加密..................................... 错误!未定义书签。（二）测试选择加密文件............................. 错误!未定义书签。（三）测试生成加密文件............................. 错误!未定义书签。（四）测试浏览加密文件............................. 错误!未定义书签。（五）测试解密文件................................. 错误!未定义书签。 五、总结........................................... 错误!未定义书签。 六、附件（代码、部分图表） ......................... 错误!未定义书签。 DES加解密算法的实现 一、DES算法的概述 DES（Data Encryption Standard）是由美国IBM公司于20世纪70年代中期的一个密码算（LUCIFER）发展而来，在1977年1月15日，美国国家标准局正式公布实施，并得到了ISO的认可，在过去的20多年时间里，DES被广泛应用于美国联邦和各种商业信息的保密工作中，经受住了各种密码分析和攻击，有很好的安全性。然而，目前DES算法已经被更为安全的Rijndael算法取代，但是DES 加密算法还没有被彻底的破解掉，仍是目前使用最为普遍的对称密码算法。所以对DES的研究还有很大价值，在国内DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键的数据保密，如信用卡持卡人的PIN码加密传输，IC卡与POS机之间的双向认证、金融交易数据包的MAC 校验等，均用到DES算法。 DES算法是一种采用传统的代替和置换操作加密的分组密码，明文以64比特为分组，密钥长度为64比特，有效密钥长度是56比特，其中加密密钥有8比特是奇偶校验，DES的加密和解密用的是同一算法，它的安全性依赖于所用的密钥。它首先把需要加密的明文划分为每64比特的二进制的数据块，用56比特有效密钥对64比特二进制数据块进行加密，每次加密可对64比特的明文输入进行16 轮的替换和移位后，输出完全不同的64比特密文数据。由于DES 算法仅使用最大为64比特的标准算法和逻辑运算，运算速度快，密 钥容易产生，适合于在大多数计算机上用软件快速实现，同样也适合于在专用芯片上实现。 二、DES算法描述 DES算法的加密过程首先对明文分组进行操作，需要加密的明文分组固定为64比特的块。图2-1是DES加密算法的加密流程。图2-2是密钥扩展处理过程。 一、设计题目 随机数产生器应用系统 二、课题要求 系统功能要求： 1）模拟线性移位寄存器、线性同余发生器等产生伪随机数，并比较算法性能以及伪随机数的随机性； 2）利用该模拟随机数，应用到口令认证系统中，完成口令的生产、口令的加密保护、登陆验证等功能； 3）利用该模拟随机数，应用到密钥生成系统中，可以利用该密钥完成对称密钥的加密和解密功能。 三、系统设计和模块设计 1.总体设计思路 利用线性同余发生器(LCG)和线性反馈移位寄存器（LFSR)生成伪随机数M序列，并通过口令认证系统完成口令生成加密工作，同时完成对随机数的加密和解密功能。 2.模块设计思路 2.1原理 通过一定的算法对事先选定的随机种子(seed)做一定的运算可以得到一组人工生成的周期序列，在这组序列中以相同的概率选取其中一个数字，该数字称作伪随机数，由于所选数字并不具有完全的随机性，但是从实用的角度而言，其随机程度已足够了。这里的“伪”的含义是，由于该随机数是按照一定算法模拟产生的， 其结果是确定的，是可见的，因此并不是真正的随机数。伪随机数的选择是从随机种子开始的，所以为了保证每次得到的伪随机数都足够地“随机”，随机种子的选择就显得非常重要，如果随机种子一样，那么同一个随机数发生器产生的随机数也会一样。 2.2线性同余算法生成随机数 到目前为止，使用最为广泛的随机数产生技术是由Lehmer首先提出的称为线性同余算法，即使用下面的线性递推关系产生一个伪随机数列x1，x2，x3，… 这个算法有四个参数，分别是： a 乘数 0 ≤ a < m c 增量 0 ≤ c< m m 模数 m > 0 ≤ x0 < m x0 初始种子（秘密） 0 伪随机数序列{ xn}通过下列迭代方程得到： xn+1=(axn+c)modm 如果m、a、c和x0都是整数，那么通过这个迭代方程将产生一系列的整数，其中每个数都在0 ≤ xn < m的范围内。数值m、a和c的选择对于建立一个好的伪随机数产生器十分关键。为了形成一个很长的伪随机数序列，需要将m设置为一个很大的数。一个常用准则是将m选为几乎等于一个给定计算机所能表示的最大非负整数。因而，在一个32位计算机上，通常选择的m值是一个接近或等于231的整数。此外，为了使得随机数列不易被重现，可以使用当前时间的毫秒数作为初始种子的位置。 2.2 线性反馈移位寄存器生成随机数 LFSR是指给定前一状态的输出，将该输出的线性函数再用作输入的线性寄存器。异或运算是最常见的单比特线性函数：对寄存器的某些位进行异或操作后作为输入，再对寄存器中的各比特进行整体移位。赋给寄存器的初始值叫做“种子”，因为线性反馈移位寄存器的运算是确定性的，所以，由寄存器所生成的数据流完全决定于寄存器当时或者之前的状态。而且，由于寄存器的状态是有 软件学院 课程设计报告书 课程名称面向对象程序设计 设计题目文本文档的加密与解密 专业班级财升本12-1班 学号 1220970120 姓名王微微 指导教师徐娇月 2013年 1 月 1 设计时间 2013年1月14日-2013年1月18日 2 设计目的 面向对象程序设计是一门实践性很强的计算机专业基础课程。通过实践加深学生对面向对象程序设计的理论、方法和基础知识的理解，掌握使用Java语言进行面向对象设计的基本方法，提高运用面向对象知识分析实际问题、解决实际问题的能力，提高学生的应用能力。 3 设计任务 对文件进行加密解密 4 设计内容 4.1 需求分析 (1)给定任意一个文本文件，进行加密，生成另一个文件。 (2)对加密后的文件还原。 4.2 总体设计 4.2.1 包的描述 导入了java.awt; java.awt.event; java.io; javax.swing等包。 4.2.2 类的描述 Myframe类；E1类。其中Myframe类继承Frame类；可以扩展Frame的功能并且可以实例化的多种功能，这个类也实现了ActionListener这个接口，它是Java中关于事件处理的一个接口，ActionListener用于接收操作事件的侦听器接口。对处理操作事件感兴趣的类可以实现此接口，而使用该类创建的对象可使用组件的addActionListener 方法向该组件注册。在发生操作事件时，调用该对象的actionPerformed 方法。 4.3 页面设计 图4.3-1 显示页面 代码实现： addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); D E S加密解密课程设计报 告 Prepared on 22 November 2020 成都信息工程学院课程设计报告 DES算法加密与解密的设计与实现课程名称：密码算法程序设计 学生姓名： 学生学号： 专业班级： 任课教师： XX年 XX 月 XX 日 目录 1背景 DES算法概述 DES（Data Encryption Standard）是由美国IBM公司于20世纪70年代中期的一个密码算（LUCIFER）发展而来，在1977年1月15日，美国国家标准局正式公布实施，并得到了ISO的认可，在过去的20多年时间里，DES被广泛应用于美国联邦和各种商业信息的保密工作中，经受住了各种密码分析和攻击，有很好的安全性。然而，目前DES算法已经被更为安全的Rijndael算法取代，但是DES加密算法还没有被彻底的破解掉，仍是目前使用最为普遍的对称密码算法。所以对DES的研究还有很大价值，在国内DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键的数据保密，如信用卡持卡人的PIN 码加密传输，IC卡与POS机之间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。 DES算法是一种采用传统的代替和置换操作加密的分组密码，明文以64比特为分组，密钥长度为64比特，有效密钥长度是56比特，其中加密密钥有8比特是奇偶校验，DES的加密和解密用的是同一算法，它的安全性依赖于所用的密钥。它首先把需要加密的明文划分为每64比特的二进制的数据块，用56比特有效密钥对64比特二进制数据块进行加密，每次加密可对64比特的明文输入进行16轮的替换和移位后，输出完全不同的64比特密文数据。由于DES算法仅使用最大为64比特的标准算法和逻辑运算，运算速 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]; 课程实验报告 课程密码学实验 学院通信工程学院 专业信息安全 班级14083611 学号14084125 学生姓名刘博 实验名称DES密码实验 授课教师胡丽琴 DES密码实验 一、实验要求： 1、了解分组密码的起源与涵义。 2、掌握DES密码的加解密原理。 3、用Visual C++实现DES密码程序并输出结果。 二、实验内容： 1、1949年，Shannon发表了《保密系统的通信理论》，奠定了现代密码学的基础。他还指出混淆和扩散是设计密码体制的两种基本方法。扩散指的是让明文中的每一位影响密文中的许多位，混淆指的是将密文与密钥之间的统计关系变得尽可能复杂。而分组密码的设计基础正是扩散和混淆。在分组密码中，明文序列被分成长度为n的元组，每组分别在密钥的控制下经过一系列复杂的变换，生成长度也是n的密文元组，再通过一定的方式连接成密文序列。 2、DES是美国联邦信息处理标准(FIPS)于1977年公开的分组密码算法，它的设计基于Feistel对称网络以及精心设计的S盒，在提出前已经进行了大量的密码分析，足以保证在当时计算条件下的安全性。不过，随着计算能力的飞速发展，现如今DES已经能用密钥穷举方式破解。虽然现在主流的分组密码是AES，但DES的设计原理仍有重要参考价值。在本实验中，为简便起见，就限定DES 密码的明文、密文、密钥均为64bit，具体描述如下： 明文m是64bit序列。 初始密钥K是64 bit序列(含8个奇偶校验bit)。 子密钥K1, K2…K16均是48 bit序列。 轮变换函数f(A,J)：输入A(32 bit序列), J(48 bit序列)，输出32 bit序列。 密文c是64 bit序列。 1)子密钥生成： 输入初始密钥，生成16轮子密钥K1, K2 (16) 初始密钥(64bit)经过置换PC-1，去掉了8个奇偶校验位，留下56 bit，接着分成两个28 bit的分组C0与D0，再分别经过一个循环左移函数LS1，得到C1与D1，连成56 bit数据，然后经过置换PC-2，输出子密钥K1，以此类推产生K2至K16。 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课程设计
密码学课程设计
java文件加密解密课程设计
DES加密解密课程设计报告
DES算法源代码
杭电密码学DES密码实验报告
DES算法实现过程分析