中北大学大学软件学院《网络攻击与防御》
实验报告
计算机科学与技术学院
计算机系网络教研室制
一、实验目的
通过用DES算法对实际数据进行加密和解密来深刻了解DＥS的运行原理,进而加深对对称加密算法的理解与认识、
预备知识:
1)数据加密标准(DES,Data Encrｙption Staｎdaｒd)是一种使用密钥加密的块密码,1976年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIＰＳ),随后在国际上广泛流传开来、它基于使用56位密钥的对称算法。这个算法因为包含一些机密设计元素,相对短的密钥长度以及怀疑内含美国国家安全局(NＳA)的后门而在开始时有争议,因此DＥS因此受到了强烈的学院派式的审查,并以此推动了现代的块密码及其密码分析的发展。
2)ＤEＳ算法的入口参数有三个:Key、Dａta、Mｏｄe。其中Ｋｅy为8个字节共64位,是ＤＥＳ算法的工作密钥;Data也为８个字节6４位,是要被加密或被解密的数据;Mｏde为DＥS的工作方式,有两种:加密或解密、
3)DES算法的安全性,DEＳ现在差不多不是一种安全的加密方法,主要因为它使用的５6位密钥过短。1999年1月,ｄisｔribｕted。ｎｅｔ与电子前哨基金会合作,在22小时1５分钟内即公开破解了一个DＥＳ密钥。也有一些分析报告提出了该算法的理论上的弱点,尽管在实际中难以应用。为了提供实用所需的安全性,能够使用ＤEＳ的派生算法3DEＳ来进行加密,尽管３DＥＳ也存在理论上的攻击方法。在２001年,DＥS作为一个标准差不多被高级加密标准(ＡES)所取代、
4)对称密码算法(Sｙｍｍetric ｃipher):加密密钥和解密密钥相同,或实质上等同,即从一个易于推出另一个。又称传统密码算法(Cｏnvｅntｉoｎal ｃiｐher)、秘密密钥算法或单密钥算法、
5)分组密码(Ｂloｃｋｃiｐhｅｒ):将明文分成固定长度的组,用同一密钥和算法对每一块加密,输出也是固定长度的密文。——ＤES、ＩＤEＡ、RC2、ＲC４、RC5
分组密码是将明文消息编码表示后的数字(简称明文数字)序列,划分成长度为n 的组(可看成长度为n的矢量),每组分别在密钥的控制下变换成等长的输出数字(简称密文数字)序列。
6)ＣAP(CrｙpｔｏgraｐｈiｃAｎalyｓｉsＰｒｏgram)是由DR、Ｒｉｃｈa ｒd Spillmaｎ专门为教学而研制的密码制作与分析工具,差不多在美国的特别多高校得到了广泛地使用,受到了密码学习者的普遍欢迎。
二、实验环境
操作系统:运行Windowｓ ,ＶS2010编译环境。
三、实验内容与实验要求
对学号姓名加解密
任务一:ＤES加解密算法的原理
DES算法的加密流程图及参数:
DＥS的参数:密钥长度:56比特
输入:６４比特
输出:64比特
运算轮数:16
DＥS解密过程与加密过程完全相似,只只是将1６次迭代的子密钥顺序倒过来,即: m ＝DES—1(c) = IP—1 • T１•Ｔ２•、。、。。Ｔ15 • T16 • IＰ(ｃ)
能够证明 DES—1 (DＥS (ｍ) )=m
任务二: ＤES算法的实现
依照对ＤES算法的介绍,自己创建明文信息,并选择一个密钥,编写ＤＥS密码算法的实现程序,实现加密和解密操作,并算结果将CAＰ４的运进行比较。四、实验过程与分析
在虚拟机ＳQＬSeｒvｅr ２008中用Microｓoft Ｖｉsｕal Ｓtudio
软件新建一个项目命名为DEＳ。导入加解密代码,编译运行。在该项目所在的文件夹下新建如下四个。ｔｘt文件:1、ｔxt key、txt 2。txt 3。ｔｘt 在1。txｔ中写入要加密的学号和密码,ｋｅy。txt中写入加密的密码,点击ＤES、ｅxe运行,运行结果的加密密文在2。ｔxｔ,解密后的内容在3、ｔxt中、加解密代码如下:
#include "ｓtｄiｏ。ｈ”
#incｌuｄe ＂ｍemｏrｙ。h"
＃inclｕｄｅ"tiｍｅ。h”
＃iｎｃlｕｄe "sｔdｌｉb、ｈ”
＃define ＰLＡＩN＿ -1
＃define KEY_ －2
＃define CIPＨＥＲ_ -3
#defｉne OＫ１
tyｐeｄef cｈaｒElemＴype;
/／初始置换表IＰ
ｉｎｔ IＰ＿Tａｂle[6４］ = ｛ 57,４9,４1,３3,２5,17,9,1,
59,51,43,35,27,1９,11,３,
6１,5３,45,３7,２９,21,1３,5,
６3,５5,４7,３9,31,２3,１5,７,
5６,4８,４0,32,2４,16,8,0,
58,50,4２,34,２6,1８,10,２,
６０,52,44,3６,２8,２0,１2,４,
６2,5４,４６,３８,３
0,22,14,6｝;
／/逆初始置换表ＩＰ^－1
inｔＩP_1＿Ｔable［６４] = ｛3９,7,47,15,５5,23,６３,３1,
３8,6,４6,1４,5４,22,６２,３０,
３7,５,4５,13,５3,２１,6１,29,
36,４,４4,1２,52,2０,60,2８,
３5,3,４３,11,５1,19,５９,２7,
34,２,42,10,50,18,5８,26,
３3,１,４１,9,49,17,５7,２５,
32,0,40,8,48,16,56,2４｝;
//扩充置换表E
ｉnt E_Tａble［４８] = ｛31, 0, 1, 2, ３, ４,
3, ４, ５, 6, 7, 8,
7, 8,９,1０,１1,１２,
１1,12,１3,14,１5,1６,
1５,16,1７,18,1９,２0,
1９,20,２1,22,２３,２4,
２3,24,２５,２6,2７,２8,
27,28,29,３0,３1, 0｝;
//置换函数Ｐ
int P＿Ｔable[32] = ｛15,６,19,２0,２8,１1,27,1６,
0,14,22,25,4,１7,３０,９,
１,7,23,13,3１,26,2,８,
１8,1２,29,5,21,10,3,24｝;
/／Ｓ盒
inｔ S［8][４］[16] =//Ｓ1
{｛{14,４,13,１,2,15,11,8,３,1０,6,1２,5,9,０,７},
｛0,15,７,4,14,2,13,1,10,６,12,１1,９,５,3,8｝,
｛４,１,14,8,1３,6,２,11,１５,1２,9,7,3,１０,５,０},
｛１5,12,8,2,4,9,1,7,5,１１,3,14,10,0,6,13｝｝,
/／S2
{{15,１,8,14,6,11,３,4,９,7,２,13,12,０,5,
１0｝,
｛3,13,４,７,15,2,8,14,１2,0,1,1０,6,9,１1,５},
{0,14,７,１１,１0,４,13,1,５,8,12,6,９,3,2,15},
｛1３,8,1０,1,3,１5,4,2,11,６,7,12,0,５,14,9｝｝, //Ｓ3
｛{10,0,9,14,6,3,15,5,１,13,1２,7,11,4,２,8},
｛13,7,０,9,３,4,6,10,２,８,5,14,12,1１,１5,1},
{１3,６,４,9,8,１5,3,０,11,１,２,１２,５,
１0,１4,7},
｛1,10,13,０,6,9,8,7,4,15,14,3,１1,5,2,12}｝,
/／S４
｛{7,１3,14,３,０,6,９,１０,1,2,8,5,11,１2,4,15},
｛13,８,１１,５,6,15,0,3,４,７,2,1２,1,10,14,9｝,
｛１０,6,9,0,１２,11,7,13,1５,1,３,14,５,2,8,4},
｛3,１5,０,6,１0,1,1３,8,9,4,5,11,12,7,2,14｝},
//Ｓ5
{｛2,12,4,１,7,１０,11,6,8,5,３,１５,13,0,
１4,９},
｛1４,1１,2,12,4,7,13,1,5,0,1５,１0,3,9,8,6},
｛4,2,1,１1,10,13,7,8,15,9,12,5,６,3,0,１４｝,
{11,８,1２,7,1,14,２,１3,6,1５,0,９,１０,４,5,３}},
//S6
{{12,１,10,15,９,２,６,8,0,１3,3,4,１4,7,５,
１１},
｛10,1５,４,2,７,１2,9,5,6,1,１３,１4,0,１1,３,8},
｛９,14,１5,5,2,8,1２,３,7,０,4,10,1,１3,11,6｝,
｛4,3,２,12,9,5,1５,10,１1,14,1,７,6,０,８,1３}｝,
//S7
｛{４,11,2,14,15,０,８,13,３,1２,９,7,5,10,6,1｝,
{1３,０,11,７,４,９,1,10,１4,3,5,１2,2,１５,８,６｝,
｛1,４,11,１３,12,３,7,１４,１0,1５,６,8,０,5,9,2｝,
{6,11,13,８,1,4,10,7,9,5,0,１5,14,2,3,12｝｝,
//S8
{｛１3,2,8,4,6,1５,１1,１,10,９,3,14,５,０,12,7｝,
｛１,15,1３,8,1０,3,7,4,12,5,６,1１,0,14,９,2｝,
｛7,1１,4,1,9,12,14,2,０,6,１0,13,15,3,5,8｝,
{2,1,１4,7,4,１0,８,13,１5,１2,9,０,3,５,6,11｝}｝;
／/置换选择1
iｎt ＰＣ＿1[56］ = {56,4８,4０,３２,2４,16,8,
0,57,4９,4１,33,25,１７,
9,１,58,50,4２,34,２6,
18,10,2,５９,5１,４3,35,
62,５４,４6,38,３0,2２,14,
6,6１,53,45,37,2９,2１,
13,5,６０,52,４4,36,28,
20,12,4,27,１9,１1,3｝;
//置换选择2
ｉnt PＣ_2［48］ = ｛13,16,１0,23,０,4,2,２７,
１4,5,20,9,２2,18,１1,３,
2５,７,15,６,2６,１9,１２,1,
40,５1,30,36,46,54,29,３９,
50,44,32,４６,43,48,38,5５,
3３,５2,45,41,49,35,２8,３1};
//对左移次数的规定
int ＭOＶE＿TIMＥS［16］ = {１,１,２,２,2,2,２,2,1,2,２,2,２,２,2,1};
//字节转换成二进制
int ByteTｏBit(EｌeｍTｙｐe ch, ElｅmType bit[8]){
int ｃnｔ;
fｏr(cｎｔ＝０;cnt < 8; cｎt+＋){
*(bit+cnｔ) = (ch＞＞cnt)＆1;
｝
retｕrn 0;
}
//二进制转换成字节
inｔBｉｔＴoByte(EｌemTｙpe biｔ［8］,EleｍＴｙｐｅ＊ch)｛ inｔ cｎt;
for(cnｔ＝０;cnｔ＜ 8; cnt＋+){
＊ch ｜= ＊(bit ＋ cｎt)〈 ｝ returｎ０; } //将长度为8的字符串转为二进制位串 ｉnｔＣhaｒ8ＴｏBｉｔ64(EleｍType ch［８],EｌｅmType biｔ[64］) ｛ iｎｔ cnｔ; ｆor(cnt = 0; cnt < 8; cnt+＋)｛ ＢyｔeTｏBit(*(ｃh+cnt),bｉｔ+(cnt＜<3)); ｝ retｕrn 0; ｝ //将二进制位串转为长度为8的字符串 int Biｔ64ToCｈar８(EｌeｍＴypｅｂit[64］,ＥlemTyｐe ｃh[８］){ ｉnt cｎt; memsｅt(ｃh,0,8); foｒ(ｃnｔ＝ 0; cnt 〈 8; cｎt++){ BitToByte(ｂit+(cnｔ＜<３),ｃｈ+cnt); } retｕrｎ０; ｝ //密钥置换１ ｉnt ＤES_PC1＿Tｒansfoｒｍ(ElemType ｋｅy［6４］, ＥlｅmＴypｅ t ｅmｐbｔs[５6])｛ inｔ cnt; fｏｒ(cｎｔ = 0; cnt ＜ 5６; cｎt++){ teｍｐbts［ｃnt] ＝ key[PＣ＿1［cnt］]; } ｒeｔuｒn ０; } //密钥置换２ inｔＤＥS_ＰC２＿Ｔraｎsfoｒｍ(ElemTyｐe kｅy［56］, ＥleｍTy ｐｅ tｅｍpbｔｓ［4８]){ ｉnt ｃnt; for(ｃｎt = 0; ｃnt ＜ 48; cｎt++)｛ ｔeｍpbｔs[ｃｎｔ］＝ kｅy［PC_2［cnt]］; ｝ retｕｒｎ 0; } ／/循环左移 int ＤＥS_ＲＯL(ElemTｙpｅ data[５6］, iｎt time)｛ EleｍTｙｐe ｔemp［56]; //保存将要循环移动到右边的位 ｍｅｍcpy(ｔemｐ,ｄatａ,ｔimｅ); mｅmcpy(temp+timｅ,data+28,ｔime); //前28位移动 mｅｍcpy(data,datａ＋time,2８—tiｍe); mｅmｃｐy(dａｔa＋28—timｅ,teｍp,ｔｉｍｅ); //后28位移动 memcｐy(datａ+２8,daｔa+28＋ｔime,２8—ｔime); mｅmcpy(daｔa+5６—ｔiｍe,tｅmp+time,ｔime); ｒeturn 0; ｝ ／/生成子密钥 iｎt DEＳ_MakeSubKeys(EｌemTyｐｅ kｅy[６4］,ElemTｙpe subKeys ［１6]［48]){ ElemＴypｅｔｅmｐ[5６]; int cnt; DES_PC1＿Tranｓforｍ(key,teｍｐ);／/ＰC１置换 for(ｃnt = 0; cｎt < 16; cnt+＋)｛／／1６轮跌代,产生１６ 个子密钥 DES_ＲＯL(temp,MOＶE_ＴIMＥＳ［ｃnt]);／／循环左移 DＥＳ_ＰＣ2_Ｔｒaｎsform(tｅmp,ｓubＫeys[cnｔ］);//ＰC2置换,产生子密钥 } retuｒｎ0; } //ＩＰ置换 inｔ DEＳ＿IP_Tｒａnsfｏrｍ(ElemTypｅ data［64］)｛ inｔｃｎt; ＥleｍType ｔemｐ［64］; ｆor(cnt ＝０; cnt < 64; cnt＋＋){ tｅmｐ[ｃnt］ = data[IP＿Taｂle[ｃnt］］; } memcpy(daｔａ,tｅmp,64); reｔｕrn 0; } ／/ＩＰ逆置换 iｎt ＤES_IP_1_Ｔrａnsfoｒm(ＥlemType daｔａ[64］)｛ int cnt; ＥlemTｙｐe ｔeｍp[６４］; ｆoｒ(cｎt = 0; cnｔ〈６4; ｃｎt＋+){ tｅmp［ｃnt] = data[IＰ＿１＿Tａblｅ[ｃnｔ]]; ｝ meｍｃpｙ(dａtａ,ｔeｍp,６4); rｅｔuｒn 0; } ／／扩展置换 ｉnt ＤＥS_E＿Ｔrａnsform(ElemＴｙpｅｄatａ［48］){ iｎt cnt; ElemＴype ｔｅｍp［48]; for(ｃnｔ = ０; cｎt 〈48; cnt++)｛ ｔｅｍp［cnt］ = dａｔa［Ｅ_Ｔａble［cｎt］]; ｝ ｍemcpy(datａ,tｅmp,4８); ｒｅｔurn 0; ｝ //Ｐ置换 inｔ DES＿P_Transｆorm(EｌeｍType dａｔａ［３2］){ int cnt; ElｅｍType temp［3２］; for(cｎｔ = 0; cnt ＜３2; ｃnｔ＋+)｛ ｔｅmp[ｃnｔ] = dａta［P_Table［cnｔ］］; } ｍemｃｐy(datａ,ｔeｍp,３２); rｅtｕrn 0; } ／/异或 inｔ DＥＳ＿ＸOR(EｌemType Ｒ［48］, EleｍTyｐe Ｌ［48] ,int coun ｔ){ int cnt; ｆor(cnt = 0; cnｔ < ｃount; cｎt++)｛ Ｒ［cnｔ] ^= Ｌ[cnt］; ｝ ｒetｕrn ０; ｝ ／/Ｓ盒置换 ｉｎt DEＳ＿SBOX(ＥlemＴype data[４８］)｛ int cnt; inｔ liｎe,rｏｗ,oｕtpuｔ; inｔ cuｒ1,cｕr２; ｆor(cnt = 0; cnt 〈８; cnt+＋){ cuｒ1 = cnt*6; cur2 = cnt〈〈2; /／计算在Ｓ盒中的行与列 ｌiｎｅ= (data［ｃｕｒ1]<<１) + ｄａtａ［cuｒ１＋５］; rｏw ＝ (dａta［cuｒ１+１]〈＜3) + (datａ［cur1+2]〈〈２) ＋ (dａtａ[ｃuｒ1+3］〈〈１) + data[cur1+4］; outpｕｔ＝Ｓ［cnｔ］［linｅ][rｏw］; //化为2进制 data［ｃur２] ＝ (ouｔｐut＆0Ｘ08)〉〉3; daｔa［ｃuｒ２+1] = (oｕtput&０Ｘ０4)＞>2; ｄaｔa［ｃuｒ２+2] ＝ (outｐuｔ＆0Ｘ0２)〉＞１; data［cur2+３] ＝ outpｕt＆０x01; ｝ ｒetｕｒn 0; } ／/交换 int DES_S lｅft［32］, ElｅｍTｙpe ｒight[32]){ EｌemＴyｐe ｔｅmp[32]; ｍeｍｃpy(ｔｅmp,ｌeft,32); meｍcpy(leｆｔ,ｒiｇht,３２); ｍemcpy(riｇht,temp,32); rｅｔｕrn ０; } //加密单个分组 int DES_EncｒyptＢｌock(ElemTypｅpｌａｉnBlｏｃｋ［8], ElemType subKｅys[16］［48], ElｅｍType ciｐhｅrBlock［8])｛ ElｅmType plaiｎＢits[64]; ElemTypｅ copｙRiｇhｔ[４8］; int cnt; Ｃhaｒ８TｏBｉt64(pｌaｉnBlｏck,pｌainBits); /／初始置换(IP置换) DES＿ＩＰ_Ｔraｎｓforｍ(pｌainＢits); //１6轮迭代 for(ｃnt = ０; cnt < 1６; cnt+＋){ mｅｍcpy(ｃｏｐyRｉｇht,plaｉnBitｓ＋32,３2); /／将右半部分进行扩展置换,从３2位扩展到48位 DES＿E_Ｔrａnｓfｏｒｍ(cｏｐyRighｔ); ／/将右半部分与子密钥进行异或操作 DES_XOR(ｃoｐyRiｇhｔ,ｓubKeys［cnt],４８); //异或结果进入S盒,输出３2位结果 ＤES_SBＯX(cｏpｙＲｉghｔ); ／/P置换 ＤＥS_P_Ｔransfｏrm(cｏpyRigｈt); //将明文左半部分与右半部分进行异或 DES_XＯR(plainＢits,copｙＲigｈt,3２); if(ｃnt != １5)｛ ／／最终完成左右部的交换 DES_S); } } /／逆初始置换(IP＾1置换) ＤES_IＰ_１_Ｔｒansｆoｒm(plaiｎＢits); Bit64ToChar8(plainBitｓ,cipherBlock); retｕｒn 0; } ／/解密单个分组 int DES＿ＤｅｃryｐtBlock(EｌemTyｐe ciｐｈerBｌoｃｋ[8], EｌemTypｅ subＫｅyｓ［16］［48],ElｅmTypｅpｌａiｎＢｌｏcｋ［8]){ ElemType cipheｒＢits[６4］; ElemTyｐe ｃｏpyＲight［48]; iｎt cnｔ; Char8ＴoBit6４(ｃipheｒBｌocｋ,cｉpherＢits); /／初始置换(IＰ置换) DEＳ_IP＿Ｔraｎsｆorm(ｃipｈｅrBｉts); //1６轮迭代 for(cnｔ= 1５; ｃnt ＞= 0; cnｔ--){ mｅｍｃpy(ｃopｙRight,cｉpｈｅrBiｔs＋３2,32); ／/将右半部分进行扩展置换,从3２位扩展到48位 DEＳ＿E＿Trａnsforｍ(cｏpｙRigｈt); //将右半部分与子密钥进行异或操作 DＥS_XOR(copｙRiｇｈt,subＫｅｙｓ[cnｔ］,48); //异或结果进入Ｓ盒,输出３2位结果 ＤES＿SBOX(ｃopyRighｔ); //P置换 DES_Ｐ＿Transｆｏｒm(coｐyＲiｇhｔ); //将明文左半部分与右半部分进行异或 ＤＥS_ＸOR(cipherＢiｔs,ｃopyRｉghｔ,32); if(cnt !＝０){ /／最终完成左右部的交换 DES_S); } } //逆初始置换(IP^1置换) DES_IP_1_Tranｓｆoｒｍ(cｉphｅrBｉｔs); Ｂiｔ６4ＴｏChａｒ8(cｉｐherBiｔs,plaｉｎＢloｃｋ); ｒｅtuｒn ０; ｝ /／加密文件 int DＥS_Ｅncryｐt(ｃｈａｒ*ｐlａiｎFｉｌe, char *kｅｙStｒ,cha ｒ *ciｐｈerＦｉｌｅ)｛ FILE *pｌaiｎ,*ｃiｐher; iｎt counｔ; ＥlemTｙpe pｌaｉnBｌｏck［８］,cｉpｈｅrBlock［8],ｋeyBｌoc ｋ［8］; ElemＴｙpｅ bＫey[64]; EｌｅmＴype suｂKeys[16][４8]; iｆ((ｐlａｉn = ｆoｐｅn(plａinFile,"rb”)) == ＮULＬ){ retuｒn PＬAIN＿; ｝ ｉf((cipｈer = fｏpen(ｃipheｒFｉｌe,"wb")) =＝NULL)｛ reｔｕrn ＣIＰＨEＲ_; } ／/设置密钥 memｃpy(keｙBlock,ｋｅyＳtr,8); //将密钥转换为二进制流 Cｈar8TｏBit6４(keｙBlock,bKey); //生成子密钥 DＥS_ＭａkｅSuｂKｅys(ｂＫey,suｂKeys); whｉｌｅ(！feof(plaｉn)){ /／每次读8个字节,并返回成功读取的字节数 if((coｕnt = frｅａd(ｐｌａinBlocｋ,sｉzｅｏｆ(char),8,plain)) ＝= ８){ DEＳ＿EncｒypｔBlｏck(plainBlｏck,subＫeｙs,cip ｈerBlｏｃk); ｆwrｉｔｅ(ｃipherBlock,sizｅof(chａr),８,ｃipheｒ); ｝ ｝ if(cｏuｎt)｛ /／填充 memｓｅt(pｌａinＢｌｏcｋ + cｏｕnｔ,'＼0＇,7 —count); /／最后一个字符保存包括最后一个字符在内的所填充的字符数量 ｐlainBlock［7］＝8 - cｏunt; ＤＥS＿ＥncryptＢlocｋ(pｌａiｎBloｃk,ｓubKｅyｓ,cｉpherＢlock); fwriｔｅ(ｃｉpｈerＢlock,ｓｉzｅｏf(ｃhar),8,cipｈer); } ｆｃlose(pｌaiｎ); ｆｃlose(ciｐher); rｅtｕrn ＯK; ｝ ／/解密文件 int DES_Dｅcｒypt(ｃｈar ＊ｃipｈerFile, cｈar *keyStr,ｃhaｒ＊plainFｉle)｛ FIＬE ＊plａin, ＊ciｐher; int count,ｔｉmes = ０; ｌoｎg ; ElｅmTｙｐe plａiｎBlock［8],cipｈｅrBlｏｃk[8],keyBｌoｃｋ［8]; ElemTyｐe bKｅy［64］; ElｅｍType sｕｂKeｙｓ[１6］［４8]; ｉf((ｃｉpｈer ＝fopen(ｃiｐherＦｉｌe,"ｒｂ")) =＝NULL)｛ rｅｔuｒn ＣIPHER_; } if((plａin = fopeｎ(plaiｎFiｌe,＂wb")) == NULL){ rｅｔurn PLAＩN_; ｝ /／设置密钥 mｅｍｃpy(keyBlocｋ,ｋeｙStｒ,８); //将密钥转换为二进制流 Chａr８ToBiｔ64(keyＢlock,bＫｅy); ／/生成子密钥 DEＳ＿MａkｅSｕｂKeys(bＫeｙ,subKeyｓ); ／/取文件长度 ｆseｅk(ｃipｈeｒ,０,ＳＥEK_EＮD); ／/将文件指针置尾＝fｔell(ciｐher); /／取文件指针当前位置 ｒｅwind(cipher); /／将文件指针重指向文件头 ｗｈile(1){ ／/密文的字节数一定是8的整数倍 fread(ｃｉpherＢlock,sizeｏｆ(cｈａr),8,ｃipheｒ); DEＳ_ＤecryptBｌock(cipｈeｒBｌｏｃk,subKｅys,plainＢｌｏck); ｔimes ＋= ８; if(times < )｛ fwrｉte(ｐlainＢloｃｋ,sizeof(ｃhａｒ),8,pｌain); ｝ ｅlse｛ bｒｅak; ｝ } //判断末尾是否被填充 iｆ(plainBlock［７］＜ 8)｛ ｆｏr(cｏｕnｔ= ８- pｌａｉnBｌoｃk［7]; cｏun ｔ＜ 7; cｏｕｎt＋+){ if(ｐlainBlocｋ［count] != '＼0＇){ breaｋ; } ｝ ｝ ｉf(couｎｔ＝= 7)｛//有填充 fｗriｔe(ｐlainBlｏck,sｉｚｅof(cｈar),8 － plａinBlock[7］,ｐlaｉn); ｝ else{//无填充 fwriｔｅ(plainＢｌｏcｋ,sｉzeｏｆ(cｈar),８,pｌain); ｝ fcｌosｅ(pｌaｉn); fｃlose(cipｈｅr); retuｒｎ OK; ｝ ｉnt maiｎ() ｛ DES_Ｅncｒｙｐｔ("1、txt＂,”key。ｔxｔ”,＂２。ｔxt＂); ／/1。ｔｘt是明文源文件,2、txt是加密之后的文件 ,key。txｔs是密钥 syｓｔｅm("pａuse"); DES_Ｄeｃrypｔ("2、ｔxt＂,"ｋey、txt”,＂3、txt”); gｅtcｈaｒ(); rｅｔuｒｎ０; } 五、实验结果总结 运行结果如下: 心得: (1) 通过本次实验我学会了用DEＳ加密算法加密和解密。对一连串的代码 有了一定的了解与认识,能够通过代码认识加解密的过程、通过用DES算法对实际数据进行加密和解密深刻了解了ＤＥS的运行原理,进而加深了对对称加密算法的理解与认识。 (２)通过这次结合实际解决加解密的过程,认识特别深刻,感受到了DES的重要性、 DES算法实验报告 一、程序总体框架 二、程序实现流程 DES加密算法是分组加密算法，明文以64位为单位分成块。64位数据在64位密钥的控制下，经过初始变换后，进行16轮加密迭代：64位数据被分成左右两半部分，每部分32位，密钥与右半部分相结合，然后再与左半部分相结合，结果作为新的右半部分；结合前的右半部分作为新的左半部分。这一系列步骤组成一轮，这种轮换要重复16次。最后一轮之后，再进行初始置换的逆置换，就得到了64位的密文。 具体流程如下图所示： DES的加密过程可分为加密处理,加密变换和子密钥生成几个部分组成。 1.加密处理过程 (1)初始置换IP。加密处理首先要对64位的明文按表1所示的初始换位表IP 进行变换。表中的数值表示输入位被置换后的新位置。 (2)加密处理。上述换位处理的输出，中间要经过16轮加密变换。初始置换的64位的输出作为下一次的输入，将64位分为左、右两个32位，分别记为L0和R0，从L0、R0到L16、R16，共进行16轮加密变换。其中，经过i轮处理后的点左右32位分别为L i和R i则可做如下定义: L i=R i-1 R i=L i-1⊕F(R i-1，K) 其中，F为F变换 (3)最后换位。进行16轮的加密变换之后，将L16和R16合成64位的数据，再按照表2所示的最后换位表进行IP-1的换位，得到64位的密文，这就是DES算法加密的结果。 2.加密变换过程 64位的密钥先由置换选择1减少至56六位，进行循环左移，然后通过置换选择2减少至48位。而通过扩展运算将32位按表3扩展换位表扩展为48位的右半部分通过异或操作和48位的密钥结合，并分成6位的8个分组，通过8个S-盒将这48位替代成新的32位数据。 按此进行,输出32位,再按照表4 换位表P进行变换,这样就完成了F(R,K)的变换。 3.子密钥生成过程 密钥通常表示为64位的自然数，首先通过压缩换位Key_Exchange去掉每个字节的第8位,用作奇偶校验。因此，密钥去掉第8、16、24……64位减至56位，所以实际密钥长度为56位。而每轮要生成48位的子密钥。输入的64位密钥， 《信息安全技术》 实验报告 学院计算机科学与工程学院 学号 姓名 实验一、DES加解密算法 一、实验目的 1. 学会并实现DES算法 2. 理解对称密码体制的基本思想 3. 掌握数据加密和解密的基本过程 二、实验内容 根据DES加密标准，用C++设计编写符合DES算法思想的加、解密程序，能够实现对字符串和数组的加密和解密。 三、实验的原理 美国IBM公司W. Tuchman 和 C. Meyer 1971-1972年研制成功。1967年美国Horst Feistel提出的理论。 美国国家标准局（NBS)1973年5月到1974年8月两次发布通告，公开征求用于电子计算机的加密算法。经评选从一大批算法中采纳了IBM的LUCIFER方案。 DES算法1975年3月公开发表，1977年1月15日由美国国家标准局颁布为联邦数据加密标准（Data Encryption Standard），于1977年7月15日生效。 为二进制编码数据设计的，可以对计算机数据进行密码保护的数学运算。DES 的保密性仅取决于对密钥的保密，而算法是公开的。 64位明文变换到64位密文，密钥64位，实际可用密钥长度为56位。 运行结果: 四、思考题 1．分析影响DES密码体制安全的因素？ 答: 影响DES密码体制安全的因素主要是密钥的健壮性。 2．公钥算法中加密算法和解密算法有何步骤？ 答:DES密码体制中加密算法和解密算法流程相同，区别在于解密使用的 子密钥和加密的子密钥相反 实验二、操作系统安全配置 一、实验目的 1．熟悉Windows NT/XP/2000系统的安全配置 2. 理解可信计算机评价准则 二、实验内容 1.Windows系统注册表的配置 点击“开始\运行”选项，键入“regedit”命令打开注册表编辑器，学习并修改有关网络及安全的一些表项 2．Windows系统的安全服务 a．打开“控制面板\管理工具\本地安全策略”，查阅并修改有效项目的设置。b．打开“控制面板\管理工具\事件查看器”，查阅并理解系统日志，选几例，分析并说明不同类型的事件含义。 3. IE浏览器安全设置 打开Internet Explorer菜单栏上的“工具\Internet选项”，调整或修改“安全”、“隐私”、“内容”等栏目的设置，分析、观察并验证你的修改。 4. Internet 信息服务安全设置 打开“控制面板\管理工具\Internet 信息服务”，修改有关网络及安全的一些设置，并启动WWW或FTP服务器验证（最好与邻座同学配合）。 三、实验过程 1. Windows系统注册表的配置 点击“开始\运行”选项，键入“regedit”命令打开注册表编辑器，图如下：禁止修改显示属性 HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Polic ies\System 在右边的窗口中创建一个DOWRD值：“NodispCPL”，并将其值设为“1”。 网络安全作业 题目 des 学号 专业及班级 姓名 日期 2012.04.14 加密算法网络工程0902班 一．des简介： des是一个分组密码算法，使用64位密钥（除去8位奇偶校验，实际密钥长度为56 位）对64比特的数据分组（二进制数据）加密，产生64位密文数据。des是一个对 称密码体制，加密和解密使用同意密钥，解密和加密使用同一算法（这样，在硬件与软 件设计时有利于加密单元的重用）。des的所有的保密性均依赖于密钥。 二． des算法过程： 1． 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）。 2． des解密过程： des的解密算法与其加密算法使用的算法过程相同。两者的不同之处在于解密时子密钥ki的使用顺序与加密时相反，如果子密钥为k1k2…k16,那么解密时子密钥的使用 顺序为k16k15…k1,即使用des解密算法进行解密时，将以64位密文作为输入，第1 次迭代运算使用子密钥k16，第2次迭代运算使用子密钥k15，……，第16 次迭代使 用子密钥k1，其它的运算与加密算法相同。这样，最后输出的是64位明文。 三． des代码实现（程序）： 1.新建头文件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 《网络安全技术》实验 姓名系别实验地点 学号年级班实验时间 成绩评定教师签字 实验项目DES加密解密程序设计与实现 实验目的: 1、理解DES加密与解密的程序设计算法思想 2、编写DES加密与解密程序，实现对明文的加密与解密，加深对数据加密 与解密的理解，掌握DES加密算法思想，提高网络安全的编程能力。 所用软件：TC、VC等其它编程工具实现 实验内容： 掌握DES算法，编写DES算法。 1）初始置换 初始置换在第一轮运算之前执行，对输入分组实施如下表所示的变换。此表应从左向右、从上向下读。例如，初始置换把明文的第58位换到第1位的位置，把第50位换到第2位的位置，把第42位换到第3位的位置，等等。 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位数据分为左右两部分，每部分分别为32位，将左32位留下，将右32位按照下表进行排列 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 2）密钥置换 一开始，由于不考虑每个字节的第8位，DES的密钥由64位减至56位，如下表所示。每个字节第8位可作为奇偶校验位以确保密钥不发生错误。 中北大学大学软件学院"网络攻击与防御" 实验报告 计算机科学与技术学院 计算机系网络教研室制 一、实验目的 通过用DES算法对实际数据进展加密和解密来深刻了解DES的运行原理，进而加深对对称加密算法的理解与认识。 预备知识： 1〕数据加密标准〔DES，Data Encryption Standard〕是一种使用密钥加密的块密码，1976年被美国联邦政府的国家标准局确定为联邦资料处理标准〔FIPS〕，随后在国际上广泛流传开来。它基于使用56位密钥的对称算法。这个算法因为包含一些设计元素，相对短的密钥长度以及疑心含美国国家平安局〔NSA〕的后门而在开场时有争议，因此DES因此受到了强烈的学院派式的审查，并以此推动了现代的块密码及其密码分析的开展。 2) DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种：加密或解密。 3〕DES算法的平安性，DES现在已经不是一种平安的加密方法，主要因为它使用的56位密钥过短。1999年1月，https://www.doczj.com/doc/3919210740.html,与电子前哨基金会合作，在22小时15分钟即公开破解了一个DES密钥。也有一些分析报告提出了该算法的理论上的弱点，虽然在实际中难以应用。为了提供实用所需的平安性，可以使用DES的派生算法3DES来进展加密，虽然3DES也存在理论上的攻击方法。在2001年，DES作为一个标准已经被高级加密标准〔AES〕所取代。 4〕对称密码算法〔Symmetric cipher〕：加密密钥和解密密钥一样，或实质上等同，即从一个易于推出另一个。又称传统密码算法〔Conventional cipher)、秘密密钥算法或单密钥算法。 des算法的实验报告 DES算法实验报告 DES（Data Encryption Standard）算法是一种对称密钥加密算法，广泛应用于 信息安全领域。本实验旨在通过实验DES算法的加密和解密过程，以及密钥长 度对加密效果的影响，来深入了解DES算法的原理和应用。 实验一：加密和解密过程 首先，我们使用一个明文进行加密实验。选择一个64位的明文作为输入，同时使用一个64位的密钥进行加密。经过DES算法加密后，得到的密文长度也为 64位。然后，我们使用相同的密钥对密文进行解密，得到原始的明文。 实验结果表明，DES算法能够对明文进行有效的加密，并且使用相同的密钥能 够对密文进行解密，得到原始的明文。这说明DES算法是一种可靠的加密算法，能够保护数据的安全性。 实验二：密钥长度对加密效果的影响 在第二个实验中，我们对不同长度的密钥进行加密实验，观察加密效果的变化。我们分别使用56位、64位和128位的密钥进行加密，然后比较不同长度密钥 的加密效果。 实验结果显示，密钥长度对加密效果有显著影响。使用128位的密钥进行加密，能够得到更加安全的密文，而使用56位的密钥进行加密，则容易受到攻击。这表明密钥长度是影响DES算法加密效果的重要因素。 结论 通过本实验，我们深入了解了DES算法的加密和解密过程，以及密钥长度对加 密效果的影响。DES算法是一种可靠的加密算法，能够有效保护数据的安全性。 同时，密钥长度对加密效果有显著影响，因此在实际应用中需要选择足够长度的密钥来保障数据的安全。 总之，DES算法在信息安全领域有着重要的应用价值，通过本实验的学习，我们对DES算法有了更深入的了解，为进一步研究和应用提供了重要的参考。 DES算法实验报告 DES (Data Encryption Standard)算法是一种对称密钥加密算法，由IBM于1970s年代开发。它是加密领域的经典算法之一，被广泛应用于安全通信和数据保护领域。本实验报告将介绍DES算法的原理、实现和安全性分析。 一、DES算法原理 1.初始置换（IP置换）：将输入的64位明文进行初始置换，得到一个新的64位数据块。 2.加密轮函数：DES算法共有16轮加密，每轮加密包括3个步骤：扩展置换、密钥混合、S盒置换。 扩展置换：将32位数据扩展为48位，并与轮密钥进行异或运算。 密钥混合：将异或运算结果分为8组，每组6位，并根据S盒表进行置换。 S盒置换：将6位数据分为两部分，分别代表行和列，通过查表得到一个4位结果，并合并为32位数据。 3. Feistel网络：DES算法采用了Feistel网络结构，将32位数据块分为左右两部分，并对右半部分进行加密处理。 4.置换：将加密后的左右两部分置换位置。 5.逆初始置换：将置换后的数据进行逆初始置换，得到加密后的64位密文。 二、DES算法实现 本实验使用Python编程语言实现了DES算法的加密和解密功能。以下是加密和解密的具体实现过程： 加密过程： 1.初始化密钥：使用一个64位的密钥，通过PC-1表进行置换，生成56位的初始密钥。 2.生成子密钥：根据初始密钥，通过16次的循环左移和PC-2表进行置换，生成16个48位的子密钥。 3.初始置换：对输入的明文进行初始置换，生成64位的数据块。 4.加密轮函数：对初始置换的数据块进行16轮的加密操作，包括扩展置换、密钥混合和S盒置换。 5.逆初始置换：对加密后的数据块进行逆初始置换，生成加密后的64位密文。 解密过程： 1.初始化密钥：使用相同的密钥，通过PC-1表进行置换，生成56位的初始密钥。 2.生成子密钥：根据初始密钥，通过16次的循环左移和PC-2表进行置换，生成16个48位的子密钥。 3.初始置换：对输入的密文进行初始置换，生成64位的数据块。 4.解密轮函数：对初始置换的数据块进行16轮的解密操作，与加密轮函数相反。 DES加密解密实验报告 实验报告题目：DES加密解密实验 一、实验目的 1.了解DES加密算法的工作原理。 2. 学习使用Python编程语言实现DES加密算法。 3.掌握DES加密算法的应用方法。 二、实验原理 DES（Data Encryption Standard）是一种用于加密的对称密钥算法，其密钥长度为64位，分为加密过程和解密过程。 1.加密过程 (1)初始置换IP：将64位明文分成左右两部分，分别为L0和R0，进 行初始置换IP操作。 (2)子密钥生成：按照规则生成16个子密钥，每个子密钥长度为48位。 (3)迭代加密：通过16轮迭代加密运算，得到最终的密文。每轮迭代 加密包括扩展置换、异或运算、S盒替代、P置换和交换操作。 (4)逆初始置换：将最终的密文分成左右两部分，进行逆初始置换操作，得到最终加密结果。 2.解密过程 解密过程与加密过程类似，但是子密钥的使用顺序与加密过程相反。 三、实验材料与方法 材料：电脑、Python编程环境、DES加密解密算法代码。方法： 1. 在Python编程环境中导入DES加密解密算法库。 2.输入明文和密钥。 3.调用DES加密函数，得到密文。 4.调用DES解密函数，得到解密结果。 5.输出密文和解密结果。 四、实验步骤 1.导入DES加密解密算法库： ```python from Crypto.Cipher import DES ``` 2.输入明文和密钥： ```python plaintext = "Hello World" key = "ThisIsKey" ``` 3.创建DES加密对象： ```python cipher = DES.new(key.encode(, DES.MODE_ECB) ``` des加密算法实验报告 《des加密算法实验报告》 摘要：本实验旨在研究和分析数据加密标准（Data Encryption Standard，DES）算法的原理和应用。通过对DES算法的实验操作和结果分析，验证其在数据加 密和解密过程中的可靠性和安全性。 一、实验目的 1. 了解DES算法的基本原理和加密过程； 2. 掌握DES算法的密钥生成和加密解密操作； 3. 分析DES算法在数据加密中的应用和安全性。 二、实验原理 DES算法是一种对称密钥加密算法，采用64位的明文和56位的密钥进行加密 操作。其基本加密过程包括初始置换、16轮的Feistel网络运算和最终置换。在解密过程中，使用相同的密钥和逆向的Feistel网络运算来实现明文的恢复。 三、实验步骤 1. 生成64位的明文和56位的密钥； 2. 进行初始置换和16轮的Feistel网络运算； 3. 进行最终置换并得到密文； 4. 使用相同的密钥进行解密操作，恢复明文。 四、实验结果分析 1. 经过实验操作，得到了正确的密文，并成功进行了解密操作； 2. 分析了DES算法在数据加密中的安全性和可靠性，验证了其在信息安全领域 的重要性和应用价值。 五、结论 DES算法作为一种经典的对称密钥加密算法，具有较高的安全性和可靠性，在 信息安全领域有着广泛的应用。本实验通过对DES算法的实验操作和结果分析，验证了其在数据加密和解密过程中的有效性和实用性，为信息安全技术的研究 和应用提供了重要的参考和借鉴。 综上所述，本实验对DES加密算法进行了深入研究和分析，得出了相应的实验 结果和结论，为信息安全领域的相关研究和应用提供了有益的参考和借鉴。 des实验报告 DES实验报告 一、引言 数据加密标准（Data Encryption Standard，DES）是一种对称密钥加密算法， 由IBM公司于1975年研发并在1977年被美国政府采纳为联邦信息处理标准（FIPS）。DES以其高度的安全性和可靠性成为当时最广泛使用的加密算法之一。本实验旨在通过实际操作DES算法，深入了解其工作原理和加密过程。 二、实验目的 1. 了解DES算法的基本原理和加密过程； 2. 掌握使用Python编程语言实现DES算法的方法； 3. 分析DES算法的优缺点及应用场景。 三、实验步骤 1. 密钥生成 在DES算法中，密钥长度为64位，但实际上只有56位用于加密，其余8位用 于奇偶校验。首先，我们需要生成一个有效的密钥。通过随机数生成器生成一 个64位的二进制串，然后去除奇偶校验位，得到56位的密钥。 2. 初始置换 将明文分为左右两部分，每部分各32位。然后，对每部分进行初始置换。初始置换表IP将明文的每个比特位按照特定规则重新排列，得到一个新的64位二 进制串。 3. 轮函数 DES算法中的主要操作是轮函数，该函数包括扩展置换、密钥加密、S盒替换 和P盒置换等步骤。 - 扩展置换：将32位的输入扩展为48位，扩展置换表E将输入的每个比特位按照特定规则重新排列。 - 密钥加密：使用子密钥对扩展置换的结果进行异或运算。 - S盒替换：将48位输入分为8个6位的块，经过8个不同的S盒进行替换，得到32位输出。 - P盒置换：对S盒替换的结果进行P盒置换，即将32位的输入按照特定规则重新排列。 4. 轮数迭代 DES算法共有16轮迭代，每轮迭代包括轮函数和交换左右两部分的操作。迭代过程中使用不同的子密钥对轮函数的输入进行加密。 5. 逆初始置换 最后一轮迭代结束后，将左右两部分进行交换，并进行逆初始置换。逆初始置换表IP-1将交换后的结果按照特定规则重新排列，得到最终的密文。 四、实验结果 我们使用Python编程语言实现了DES算法，并对一组明文进行加密。经过实验，我们得到了对应的密文，并与其他DES算法的实现结果进行了对比。实验结果表明，我们的DES算法实现正确，并且能够得到与其他实现相同的加密结果。 五、讨论与分析 1. 优点 DES算法具有较高的安全性，经过多年的广泛应用和攻击测试，其强度仍然能 DES加密算法的简单实现实验报告 一、实验目的 本实验的主要目的是对DES加密算法进行简单的实现，并通过实际运 行案例来验证算法的正确性和可靠性。通过该实验可以让学生进一步了解DES算法的工作原理和加密过程，并培养学生对算法实现和数据处理的能力。 二、实验原理 DES（Data Encryption Standard，数据加密标准）是一种对称密钥 加密算法，它是美国联邦政府采用的一种加密标准。DES算法使用了一个 共享的对称密钥（也称为密钥），用于加密和解密数据。它采用了分组密 码的方式，在进行加密和解密操作时，需要将数据分成固定长度的数据块，并使用密钥对数据进行加密和解密。 DES算法主要由四个步骤组成：初始置换（Initial Permutation），轮函数（Round Function），轮置换（Round Permutation）和最终置换（Final Permutation）。其中初始置换和最终置换是固定的置换过程， 用于改变数据的顺序和排列方式。轮函数是DES算法的核心部分，它使用 了密钥和数据块作为输入，并生成一个与数据块长度相同的输出结果。轮 置换将轮函数的输出结果与前一轮的结果进行异或操作，从而改变数据的 排列方式。通过多轮的迭代运算，DES算法可以通过一个给定的密钥对数 据进行高强度的加密和解密操作。 三、实验步骤 2.初始置换：将输入数据按照一定的规则重新排列，生成一个新的数 据块。初始置换的规则通过查表的方式给出，我们可以根据规则生成初始 置换的代码。 3.轮函数：轮函数是DES算法的核心部分，它使用轮密钥和数据块作 为输入，并生成一个与数据块长度相同的输出结果。在实际的算法设计和 实现中，可以使用混合逻辑电路等方式来实现轮函数。 4.轮置换：轮置换将轮函数的输出结果与前一轮的结果进行异或操作，从而改变数据的排列方式。轮置换的规则也可以通过查表的方式给出。 5.最终置换：最终置换与初始置换类似，将最后一轮的结果重新排列，生成最终的加密结果。 四、实验结果和分析 加密算法实验报告 加密算法实验报告 引言 在当今信息时代，数据安全是一个非常重要的问题。随着互联网的发展和普及，人们在进行各种在线交易、通信和存储时，需要保护自己的个人隐私和敏感信息。为了实现数据的保密性和完整性，加密算法应运而生。本实验旨在通过实 际操作，了解和掌握几种常见的加密算法，包括对称加密算法和非对称加密算法。 一、对称加密算法 对称加密算法是指加密和解密使用相同的密钥的算法。在实验中，我们选择了DES算法作为对称加密算法的代表。DES算法是一种分组密码算法，将明文分 成64位的数据块，并使用56位的密钥进行加密。经过16轮的迭代运算，最 终得到密文。 实验步骤： 1. 生成随机的64位密钥。 2. 将明文分组，并进行初始置换。 3. 将初始置换后的明文分成左右两部分。 4. 进行16轮的迭代运算，每轮都包括扩展置换、异或运算、S盒代替、P盒置 换和交换左右两部分。 5. 最后进行逆初始置换，得到密文。 实验结果： 经过实验，我们成功地对明文进行了加密，并得到了相应的密文。通过解密操 作，我们可以将密文还原为明文。 二、非对称加密算法 非对称加密算法是指加密和解密使用不同的密钥的算法。在实验中，我们选择 了RSA算法作为非对称加密算法的代表。RSA算法是一种基于大素数的数论算法，其安全性基于质因数分解的难题。 实验步骤： 1. 选择两个大素数p和q，并计算它们的乘积n。 2. 计算n的欧拉函数值phi(n)。 3. 选择一个整数e，使得1 < e < phi(n)且e与phi(n)互质。 4. 计算e的模反元素d。 5. 将明文转化为整数m。 6. 计算密文c，其中c ≡ m^e (mod n)。 7. 将密文c转化为明文m'，其中m' ≡ c^d (mod n)。 实验结果： 经过实验，我们成功地对明文进行了加密，并得到了相应的密文。通过解密操作，我们可以将密文还原为明文。 三、加密算法的应用 加密算法在现代通信和存储中起着重要的作用。它可以保护个人隐私、防止信 息泄露和数据篡改。以下是加密算法在不同领域的应用示例： 1. 网络安全：加密算法可以保护网络通信的安全性，防止黑客入侵和信息窃取。例如，HTTPS协议使用SSL/TLS加密算法来确保网页传输的安全性。 2. 移动支付：加密算法可以保护移动支付的安全性，防止支付信息被窃取和篡 DES实验报告范文 实验目的： 了解DES算法的基本原理和加密过程； 掌握DES算法的加密过程； 了解DES算法的弱点并掌握略解决方法。 实验原理： DES（Data Encryption Standard）即数据加密标准，是一种对称加 密算法。它的基本原理是，通过将明文分组（64位）进行多次迭代，每 次都经过相同的置换和替代操作，最终得到密文。加密和解密都使用相同 的过程和密钥。 实验步骤： 1.密钥生成 首先，用户需要选择一个64位的密钥，但该密钥只有56位是有效的，剩余8位用作奇偶校验位。用户可以任意选择一个64位的二进制串，然 后将满足奇偶校验的8位奇偶位加到末尾。 2.初始置换 将64位的明文分成两个32位的部分，左边为L0，右边为R0。进行 一个固定的初始置换，将L0右边的32位和R0左边的32位合并，得到一 个64位的二进制串。 3.子密钥生成 通过对初始密钥进行置换等操作，生成16个子密钥（每个48位）。每个子密钥与初始密钥无关。 4.迭代加密（16轮） 迭代加密过程中，每次都涉及到对L和R的操作。具体步骤如下：-对R进行扩展置换，扩展为48位，并将扩展后的结果与子密钥进行异或； -将异或结果分成8个6位的块，每个块对应一个S盒； -将S盒输出的结果经过置换P后与L异或，得到新的R； -将新的R赋值给R（R=R'）； -将旧的R赋值给L（L=R'）； -重复以上操作16轮。 5.逆初始置换 将L16和R16按照逆初始置换的方式进行合并，得到一个64位的二进制串，即密文。 实验结果分析： 经过实验，我们成功完成了DES算法的加密过程，并获得了加密后的密文。通过解密过程，可以将密文重新转换为原始的明文。 实验总结： DES算法是一种较为经典的对称加密算法，由于其密钥长度较短，容易受到暴力破解的攻击。为了提升安全性，可以对DES算法进行改进，如 DES加密算法实验报告 DES( Data Encryption Standard)算法是一种对称加密算法，是现代 密码学的基础。DES算法将64位明文数据分为两个32位的部分，将两部 分通过一系列复杂的运算和替换操作，最终输出64位的密文。 DES算法的加密过程主要包括初始置换、16轮Feistel网络、逆初始 置换等步骤。 首先是初始置换，将明文数据进行位重排列，使得加密的效果更加均匀。然后是16轮Feistel网络的操作，每一轮都包括密钥的生成和密钥 的运算。密钥的生成过程是将64位的密钥进行重排列和选择运算，生成 每一轮所需要的子密钥。密钥的运算过程是将子密钥与32位明文数据进 行异或操作，然后再通过一系列的替换和置换运算，得到新的32位数据。最后是逆初始置换，将加密后的数据进行反向重排列，得到最终的64位 密文数据。 实验中，对于给定的明文和密钥，我们首先需要将明文和密钥转换成 二进制形式。然后根据初始置换表和选择运算表，将明文和密钥进行重排列。接下来进入16轮Feistel网络的循环中，每一轮都按照密钥的生成 和运算过程进行操作。最后通过逆初始置换表，将加密后的数据进行反向 重排列，得到最终的密文。 DES算法的优点是运算速度较快，加密强度较高，安全可靠，广泛应 用于网络通信和数据保密领域。但DES算法也存在一些缺点，主要是密钥 长度较短，为56位，容易受到暴力破解攻击；DES算法的设计和实现已 经有一定历史了，现在已经有更安全和更高效的算法可供选择。 在实验中，我使用Python语言编写了DES算法的加密程序，在给定 的明文和密钥下进行了测试。实验结果表明，DES算法可以成功加密数据，并且在解密过程中能够准确还原原始数据。 总结来说，DES加密算法是一种经典的对称加密算法，通过初始置换、Feistel网络和逆初始置换等步骤，可以将明文数据加密成密文数据。 DES算法在保证加密强度和运算速度的同时，也有一些缺点需要注意。因此，在实际应用中需要根据具体的需求和安全要求选择合适的加密算法。 苏州科技学院 学生姓名：杨刘涛学号：17指导教师：陶滔 刘学书14 实验地点：计算机学院大楼东309实验时间：2015-04-20实验室名称：软件实验室 、实验项目名称：DES加解密算法实现三、实验学时： 4 学时四、实验原理： DES算法由加密、子密钥和解密的生成三部分组成。现将DES算法介绍如下。1．加密 DES算法处理的数据对象是一组64比特的明文串。设该明文串为m=m1m2m64 （mi=O或1）。明文串经过64比特的密钥K来加密，最后生成长度为64比特的密文E。其加密过程图示如下： 图2-1 : DES算法加密过程 对DES算法加密过程图示的说明如下： 待加密的64比特明文串m经过IP置换（初始置换）后，得到的比特串的下标列表如下： 表2-1 :得到的比特串的下标列表 该比特串被分为32位的L0和32位的R0两部分。R0子密钥K1（子密钥的 生成将在后面讲）经过变换f （R0,K1） （f 变换将在下面讲）输出32位的比特串 f1,f1与L0做不进位的二进制加法运算。运算规则为： fl 与L0做不进位的二进制加法运算后的结果赋给 R1, R0则原封不动的赋 给L1。L1与R0又做与以上完全相同的运算，生成 L2, R2••… 一共经过16次 运算。最后生成R16和L16。其中R16为L15与f （R15,K16）做不进位二进制加法 运算的结果，L16是R15的直接赋值。 R16与L16合并成64位的比特串。值得注意的是R16一定要排在L16前面。 R16与L16合并后成的比特串，经过置换IP-1 （终结置换）后所得比特串的下标 列 表如下： 表2-2 :置换后所得比特串的下标列表 经过置换IP-1后生成的比特串就是密文e 变换 f(Ri-1,Ki): 它的功能是将32比特的输入再转化为32比特的输出。其过程如图2-2所示: DES_加密解密算法C++实现--实验报告des算法 实验 . . . . . 1? 实验一? 1、实验题目? 利用C/C++编程实现DES加密算法或MD5加密算法。我选择的是用C++语言实现 DES的加密算法? 2、实验目的? 通过编码实现DES算法或MD5算法，深入掌握算法的加密原理，理解其实际应用? 价值，同时要求用C/C++语言实现该算法，让我们从底层开始熟悉该算法的实现过程? 3、实验环境? 操作系统：WIN7旗舰版? 开发工具：Visual?Studio?2010旗舰版?开发语言：C++? 4、实验原理? DES加密流程 2? ?如上图所示为DES的加密流程，其中主要包含初始置换，压缩换位1，压缩换位2，扩 展置换，S盒置换，异或运算、终结置换等过程。?初始置换是按照初始置换表将64位明文重新排列次序?扩展置换是将原32为数据扩展为48位数据，它主要由三个目的：1、产生与子密钥相同的长度2、提供更长的结果，使其在加密过程中可以被压缩 3、产生雪崩效应，使得输入的一位将影响两个替换? S盒置换是DES算法中最核心的容，在DES中，只有S盒置换是非线性的，它比DES中其他任何一步都提供更好的安全性? 终结置换与初始置换相对应，它们都不影响DES的安全性，主要目的是为了更容易将明文与密文数据一字节大小放入DES的f算法中? DES解密流程与加密流程基本相同，只不过在进行16轮迭代元算时，将子密钥生成的K的次序倒过来进行迭代运算? 5、实验过程记录? 在对DES算法有了清晰的认识后，编码过程中我将其分为几个关键部分分别进行编码，最后将整个过程按顺序执行，即可完成DES的加密，代码的主要几个函数如下：? //Byte转为Bit? ByteToBit(ElemType?ch,ElemType?bit)//Bit转为Byte? DES_加密解密算法C实现--实验报告des算法实验 .. ... 1 实验一 1、实验题目 利用C/C++编程实现DES加密算法或MD5加密算法。我选择的是用 C++语言实现 DES的加密算法。 2、实验目的 通过编码实现DES算法或MD5算法，深入掌握算法的加密原理，理解其实际应用 价值，同时要求用C/C++语言实现该算法，让我们从底层开始熟悉该算法的实现过程 3、实验环境 操作系统：WIN7旗舰版 开发工具：VisualStudio2022旗舰版开发语言：C++ 4、实验原理 DES加密流程 2 如上图所示为DES的加密流程，其中主要包含初始置换，压缩换位1，压缩换位2，扩 展置换，S盒置换，异或运算、终结置换等过程。初始置换是按照初 始置换表将64位明文重新排列次序扩展置换是将原32为数据扩展为48 位数据，它主要由三个目的：1、产生与子密钥相同的长度2、提供更长 的结果，使其在加密过程中可以被压缩 3、产生雪崩效应，使得输入的一位将影响两个替换 S盒置换是DES算法中最核心的容，在DES中，只有S盒置换是非线 性的，它比DES中其他任何一步都提供更好的平安性 终结置换与初始置换相对应，它们都不影响DES的平安性，主要目的 是为了更容易将明文与密文数据一字节大小放入DES的f算法中DES解密流程与加密流程根本相同，只不过在进行16轮迭代元算时，将子密钥生成的K的次序倒过来进行迭代运算 5、实验过程记录 在对DES算法有了清晰的认识后，编码过程中我将其分为几个关键局 部分别进行编码，最后将整个过程按顺序执行，即可完成DES的加密，代 码的主要几个函数如下： //Byte转为Bit ByteToBit(ElemTypech,ElemTypebit[8])//Bit转为Byte BitToByte(ElemTypebit[8],ElemType&ch)//初始置换 DES分组密码实验报告 一、DES算法的实现 1．DES简介 DES算法工作：如Mode为加密，则用Key 去把数据Data进行加密，生成Data的密码形式（64位）作为DES的输出结果；如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式（64位）作为DES的输出结果。在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据（如PIN、MAC等）在公共通信网中传输的安全性和可靠性。 2. DES算法详述 （1）DES加密标准 DES是对二元数字分组加密的分组密码算法，分组长度为64比特。每64位明文加密成64位密文，没有数据压缩和扩展，密钥长度为56比特，若输入64比特，则第8，16，24，32，40，48，56，64为奇偶校验位，所以，实际密钥只有56位。DES算法完全公开，其保密性完全依赖密钥。 DES的加密过程可表示为： DES(m)= IP-1T16·T15…T2·T1·IP（m）. 右图面是完全16轮DES算法框图： 图1 完全16轮DES算法 1 初始置换IP 初始置换是将输入的64位明文分为8个数组，每一组包括8位，按1至64编号。 IP的置换规则如下表： 2 IP-1是IP的逆置换 由于第1位经过初始置换后，已处于第40位。逆置换就是再将第40位换回到第1位。 逆置换规则如下表所示： 初始置换IP及其逆置换IP-1并没有密码学意义，因为置换前后的一一对应关系是已知的。它们的作用在于打乱原来输入明文的ASCⅡ码字划分的关系，并将原来明文的第m8，m16，m24，m32，m40，m48，m56，m64位（校验位）变成IP的输出的一个字节。 3. DES算法的迭代过程 图中Li-1和Ri-1分别是第i-1次迭代结果的左右两部分，各32比特。即Li=Ri-1, Ri=Li-1 f(Ri-1,ki)。其中轮密钥Ki为48比特，函数F(R,K)的计算过程如图所示。轮输入的右半部分R为32比特，R首先被扩展成48比特，扩展过程由表3定义，其中将R的16个比特各重复一次。扩展后的48比特再与子密钥Ki异或，然后再通过一个S盒，产生32比特的输出。该输出再经过一个由表4定义的置换，产生的结果即为函数F(R,K)的输出。DES算法实验报告
信息安全技术实验报告
DES加密实验报告
DES加密实验报告
信息安全实验报告des加密算法
des算法的实验报告
DES算法实验报告
DES加密解密实验报告
des加密算法实验报告
des实验报告
DES加密算法的简单实现实验报告
加密算法实验报告
DES实验报告范文
DES加密算法实验报告
DES加密算法实验报告
DES_加密解密算法C++实现--实验报告des算法实验
DES_加密解密算法C实现--实验报告des算法实验
DES分组加密实验报告
相关主题
文本预览