实验报告.2密码破解实验

时间：2024.4.9

《电子证据》实验报告

实验二

指导教师：

学院：

班级：

学号：

姓名：

考号：

实验日期：

小组成员：

实验一密码破解实验

一、实验目的

1、学会用Archpr软件对压缩文件简单密码的破解

2、学会用aopr软件对文件密码的破解

二、实验内容

1、用Archpr软件对压缩文件简单密码的破解

2、用aopr软件对文件密码的破解

三、实验步骤

1、用Archpr软件对压缩文件简单密码的破解

1）、打开Archpr软件；

2）、点击open，选择需要破解密码的压缩文件；

3）、设置参数例如密码的长度范围、密码的组成……

4）、点击start，开始密码破解。

2、用aopr软件对文件密码的破解

1）、打开Aopr软件

2）、进行的参数设置，例如密码的长度范围、密码的组成……

3）、打开将要破解密码的文件的路径

4）、开始破解密码

四、实验结果

1、用Archpr软件对压缩文件简单密码的破解

实验报告2密码破解实验

2、用aopr软件对文件密码的破解

实验报告2密码破解实验

五、写出本次实验的实验心得

1、学会用Archpr软件对压缩文件简单密码的破解；

2、学会用aopr软件对文件密码的破解；

3、不用担密码丢失了。

第二篇：DES 加密解密算法的C++实现--实验报告

网络与信息安全

Introduction to Network and Security

——DES 加密解密算法的C++实现

姓名：

学号：

学院：

20##年10月

一、 DES算法的实现

1．DES简介

本世纪五十年代以来，密码学研究领域出现了最具代表性的两大成就。其中之一就是1971年美国学者塔奇曼（Tuchman）和麦耶（Meyer）根据信息论创始人香农（Shannon）提出的“多重加密有效性理论”创立的，后于1977年由美国国家标准局颁布的数据加密标准。

DES密码实际上是Lucifer密码的进一步发展。它是一种采用传统加密方法的区组密码。它的算法是对称的，既可用于加密又可用于解密。

美国国家标准局1973年开始研究除国防部外的其它部门的计算机系统的数据加密标准，于1973年5月15日和1974年8月27日先后两次向公众发出了征求加密算法的公告。加密算法要达到的目的通常称为DES密码算法要求主要为以下四点：

提供高质量的数据保护，防止数据未经授权的泄露和未被察觉的修改；具有相当高的复杂性，使得破译的开销超过可能获得的利益，同时又要便于理解和掌握DES密码体制的安全性应该不依赖于算法的保密，其安全性仅以加密密钥的保密为基础实现经济，运行有效，并且适用于多种完全不同的应用。

1977年1月，美国政府颁布：采纳IBM公司设计的方案作为非机密数据的正式数据加密标准（DES枣Data Encryption Standard）。

目前在这里，随着三金工程尤其是金卡工程的启动，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡持卡人的PIN的加密传输，IC卡与POS间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。

DES算法的入口参数有三个：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的输出结果。在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据（如PIN、MAC等）在公共通信网中传输的安全性和可靠性。

通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性，这正是现在金融交易网络的流行做法。

2．DES算法详述

DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位,其功能是把输入的64位数据块按位重新组合，并把输出分为L0 、R0两部分，每部分各长32位，其置换规则见下表：

58,50,12,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,

即将输入的第58位换到第一位，第50位换到第2位，……，依此类推，最后一位是原来的第7位。 L0、R0则是换位输出后的两部分，L0是输出的左32位，R0 是右32位，例：设置换前的输入值为D1D2D3……D64，则经过初始置换后的结果为：L0=D550……D8；R0=D57D49...D7。

经过26次迭代运算后，得到L16、R16，将此作为输入，进行逆置换，即得到密文输出。逆置换正好是初始置的逆运算，例如，第1位经过初始置换后，处于第40位，而通过逆置换，又将第40位换回到第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,

放大换位表

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,

单纯换位表

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,

在f(Ri,Ki)算法描述图中，S1,S2...S8为选择函数，其功能是把6bit数据变为4bit数据。下面给出选择函数Si(i=1,2......8)的功能表：

选择函数Si

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,

S5:

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:

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:

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:

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,

3．子密钥Ki(48bit)的生成算法

初始Key值为64位，但DES算法规定，其中第8、16、......64位是奇偶校验位，不参与DES运算。故Key 实际可用位数便只有56位。即：经过缩小选择换位表1的变换后，Key 的位数由64 位变成了56位，此56位分为C0、D0两部分，各28位，然后分别进行第1次循环左移，得到C1、D1，将C1（28位）、D1（28位）合并得到56位，再经过缩小选择换位2，从而便得到了密钥K0（48位）。依此类推，便可得到K1、K2、......、K15，不过需要注意的是，16次循环左移对应的左移位数要依据下述规则进行：

循环左移位数1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1

以上介绍了DES算法的加密过程。 DES算法的解密过程是一样的，区别仅仅在于第一次迭代时用子密钥K15，第二次K14、……，最后一次用K0，算法本身并没有任何变化。

二、加/解密执行过程及结果

1．运行程序

2．加密过程（同时生成密文文档）

3．解密过程（同时生成明文外部文档）

三、源代码

#include "stdafx.h"

#include "DESTest.h"

#include "DESTestDlg.h"

#include "Encrypt.h"

void CDES::deskey(unsigned char key[8], Mode md)

{

unsigned char pc1m[56], pcr[56];

unsigned long kn[32];

for (j = 0; j < 56; j++)

{

l = pc1[j];

m = l & 07;

pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1:0;

}

for (ii = 0; ii < 16; ii++)

{

if (md == DECRYPT)

m = (15 - ii) << 1;

else

m = ii << 1;

n = m + 1;

kn[m] = kn[n] = 0L;

for (j = 0; j < 28; j++)

{

l = j + totrot[ii];

if (l < 28)

pcr[j] = pc1m[l];

else

pcr[j] = pc1m[l - 28];

}

for (j = 28; j < 56; j++)

{

l = j + totrot[ii];

if (l < 56)

pcr[j] = pc1m[l];

else

pcr[j] = pc1m[l - 28];

}

for (j = 0; j < 24; j++)

{

if (pcr[ pc2[j] ])

kn[m] |= bigbyte[j];

if (pcr[ pc2[j+24] ])

kn[n] |= bigbyte[j];

}

cookey(kn);

return;

}

void CDES::cookey(register unsigned long *raw1)

{

unsigned long dough[32];

cook = dough;

for (i = 0; i < 16; i++, raw1++)

{

raw0 = raw1++;

*cook = (*raw0 & 0x00fc0000L) << 6;

*cook |= (*raw0 & 0x00000fc0L) << 10;

*cook |= (*raw1 & 0x00fc0000L) >> 10;

*cook++ |= (*raw1 & 0x00000fc0L) >> 6;

*cook = (*raw0 & 0x0003f000L) << 12;

*cook |= (*raw0 & 0x0000003fL) << 16;

*cook |= (*raw1 & 0x0003f000L) >> 4;

*cook++ |= (*raw1 & 0x0000003fL);

}

usekey(dough);

return;

}

void CDES::usekey(register unsigned long *from)

{

to = KnL, endp = &KnL[32];

while (to < endp)

{

*to++ = *from++;

}

return;

}

void CDES::scrunch(register unsigned char *outof, register unsigned long *into )

{

*into = (*outof++ & 0xffL) << 24;

*into |= (*outof++ & 0xffL) << 16;

*into |= (*outof++ & 0xffL) << 8;

*into++ |= (*outof++ & 0xffL);

*into = (*outof++ & 0xffL) << 24;

*into |= (*outof++ & 0xffL) << 16;

*into |= (*outof++ & 0xffL) << 8;

*into |= (*outof & 0xffL);

return;

}

void CDES::unscrun(register unsigned long *outof, register unsigned char *into)

{

*into++ = (*outof >> 24) & 0xffL;

*into++ = (*outof >> 16) & 0xffL;

*into++ = (*outof >> 8) & 0xffL;

*into++ = *outof++ & 0xffL;

*into++ = (*outof >> 24) & 0xffL;

*into++ = (*outof >> 16) & 0xffL;

*into++ = (*outof >> 8) & 0xffL;

*into = *outof & 0xffL;

return;

}

void CDES::desfunc(register unsigned long *block, register unsigned long *keys)

{

leftt = block[0];

right = block[1];

work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;

right ^= work;

leftt ^= (work << 4);

work = ((leftt >> 16) ^ right) & 0x0000ffffL;

right ^= work;

leftt ^= (work << 16);

work = ((right >> 2) ^ leftt) & 0x33333333L;

leftt ^= work;

right ^= (work << 2);

work = ((right >> 8) ^ leftt) & 0x00ff00ffL;

leftt ^= work;

right ^= (work << 8);

right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;

work = (leftt ^ right) & 0xaaaaaaaaL;

leftt ^= work;

right ^= work;

leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;

for (round = 0; round < 8; round++)

{

work = (right << 28) | (right >> 4);

work ^= *keys++;

fval = SP7[work & 0x3fL];

fval |= SP5[(work >> 8) & 0x3fL];

fval |= SP3[(work >> 16) & 0x3fL];

fval |= SP1[(work >> 24) & 0x3fL];

work = right ^ *keys++;

fval |= SP8[work & 0x3fL];

fval |= SP6[(work >> 8) & 0x3fL];

fval |= SP4[(work >> 16) & 0x3fL];

fval |= SP2[(work >> 24) & 0x3fL];

leftt ^= fval;

work = (leftt << 28) | (leftt >> 4);

work ^= *keys++;

fval = SP7[work & 0x3fL];

fval |= SP5[(work >> 8) & 0x3fL];

fval |= SP3[(work >> 16) & 0x3fL];

fval |= SP1[(work >> 24) & 0x3fL];

work = leftt ^ *keys++;

fval |= SP8[work & 0x3fL];

fval |= SP6[(work >> 8) & 0x3fL];

fval |= SP4[(work >> 16) & 0x3fL];

fval |= SP2[(work >> 24) & 0x3fL];

right ^= fval;

}

right = (right << 31) | (right >> 1);

work = (leftt ^ right) & 0xaaaaaaaaL;

leftt ^= work;

right ^= work;

leftt = (leftt << 31) | ( leftt >> 1);

work = ((leftt >> 8) ^ right) & 0x00ff00ffL;

right ^= work;

leftt ^= (work << 8);

work = ((leftt >> 2) ^ right) & 0x33333333L;

right ^= work;

leftt ^= (work << 2);

work = ((right >> 16) ^ leftt) & 0x0000ffffL;

leftt ^= work;

right ^= (work << 16);

work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;

leftt ^= work;

right ^= (work << 4);

*block++ = right;

*block = leftt;

return;

};

unsigned char CDES::Df_Key[24] =

{

0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,

0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,

0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67

};

unsigned short CDES::bytebit[8] =

{

0200, 0100, 040, 020, 010, 04, 02, 01

};

unsigned long CDES::bigbyte[24] =

{

0x800000L, 0x400000L, 0x200000L, 0x100000L,

0x80000L, 0x40000L, 0x20000L, 0x10000L,

0x8000L, 0x4000L, 0x2000L, 0x1000L,

0x800L, 0x400L, 0x200L, 0x100L,

0x80L, 0x40L, 0x20L, 0x10L,

0x8L, 0x4L, 0x2L, 0x1L

};

unsigned char CDES::pc1[56] =

{

56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17,

9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35,

62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21,

13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3

};

unsigned char CDES::totrot[16] =

{

1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28

};

unsigned char CDES::pc2[48] =

{

13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9,

22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1,

40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,

43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31

};

unsigned long CDES::SP1[64] =

{

0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,

0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,

0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,

0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,

0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,

0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,

0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,

0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,

0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,

0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,

0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,

0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,

0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,

0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,

0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,

0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L

};

更多相关推荐：

实验报告_密码学: 信息安全实验报告学号学生姓名班级实验三密码学实验一古典密码算法实验一实验目的通过编程实现替代密码算法和置换密码算法加深对古典密码体制的了解为深入学习密码学奠定基础二编译环境运行windows或linux操作系统...
实验报告_密码学: 密码学与网络安全技术课程上机报告学号119xx4339姓名许海龙班级网112班教师卫琳娜安徽工业大学密码学实验一古典密码算法实验一实验目的通过编程实现替代密码算法和置换密码算法加深对古典密码体制的了解为深入学习...
密码学实验报告: 密码学实验报告学院计算机科学与技术班级学号姓名指导老师实验日志实验题目DES或AES分组密码实验目的熟悉分组密码加解密算法的基本原理加深对所提供的部分源程序的理解分组密码将明文分成一组一组在密钥的控制下经过加密...
密码学实验报告: 密码学实验报告实验一DES加密算法实验一实验目的理解对称加解密算法的原理和特点理解DES算法的加解密原理二实验背景DES算法为密码体制中的对称密码体制又被称为美国数据加密标准是19xx年美国IBM公司研制的对称...
密码学实验报告: 江苏大学学院专业姓名学号计算机学院信息安全09023090604035小组成员AES对称加密算法实现一AES对称加密算法实现原理AESTheAdvancedEncryptionStandard接受一个128位的...
密码学实验报告3: 哈尔滨工程大学实验报告实验名称DES加密班级学号姓名实验时间20xx615成绩指导教师实验室名称哈尔滨工程大学实验室与资产管理处制一实验名称MD5加密二实验目的通过编程实现MD5加密的算法设计并加深对其的了解三...
密码学实验报告四: 现代密码学实验报告报告创建时间

密码学实验-Feistel网络: 实验报告实验五Feistel网络实验目的1熟练掌握Feistel网络结构原理及实现2掌握Feistel网络结构的应用实验内容1写出平衡Feistel网络结构加密运算的算法程序设计在此假定1明文的长度为2mbit...
实验一、密码学基本算法的实现(一): 上机实验报告（一）实验课程：应用密码学实验时间:20XX年9月26日任课教师:***班级：11级信息与计算科学专业1班姓名：刘静**学号：***一、实验名称:密码学基本算法的实现（一）二、实验目的学习常见的古典…
密码学实验一古典密码算法 C语言: 信息安全实验报告课程名称:_专业:计算机科学与技术_20xx级_02班实验编号：实验项目_指导教师姓名：**学号：***实验成绩：实验一古典密码算法实验名称：古典密码算法实验类型:设计性实验学时：4适用对象:信…
密码学课程设计报告: 密码学课程设计班级成员姓名指导教师20xx7中国矿业大学计算机学院密码学课程设计目录密码学课程设计11实验一实现一个多表古典加密和解密程序111实验目的112实验要求113实验内容114古典加密方法115程序代...
密码学课程设计报告: 沈阳工程学院课程设计设计题目院系信息学院班级信安本111学生姓名学号指导教师祝世东王素芬职称工程师副教授起止日期20xx年1月6日起至20xx年1月10日止沈阳工程学院课程设计任务书课程设计题目简单的保密通信系...

热门关注