精华内容
下载资源
问答
  • 未指定书签 3.AES 加密解密算法的组成部分 错误 !未指定书签 3.1 密钥部分 错误 !未指定书签 3.1.1AES 的 S 盒 错误 !未指定书签 3.1.2AES 的逆 S 盒 错误 !未指定书签 3.1.3 轮常量 错误 !未指定书签 3.1.4 密钥...
  • 用java写的des算法加密及解密过程
  • 目录 TOC \o "1-3" \h \u 517 第一章 DES算法 3 8216 1.1 DES概述 3 26280 1.2 DES的加密标准 3 12623 1.2.1 DES算法的迭代过程 4 13381 1.2.2 子密钥的生成 5 2256 1.3 DES算法的解密过程 7 8281 第二章 AES算法 7...
  • 证明:DES解密算法是DES加密算法的

    千次阅读 2020-05-08 18:44:13
    根据书本得Feistel解密算法和加密算法的关系,解密过程第一轮的输入等于加密过程第16轮输出左右部分交换的值。最后一轮迭代后密文是LE16||RE16,首先对于加密过程有LE16= LE15,RE16= LE15⊕F(R

    证明:

    由于DES算法是在Feistel网络结构的输入和输出阶段分别初始置换IP和初始逆置换IP-1而构成的,其余DES和Feistel相同,IP和IP–1互逆。所以只需证明Feistel解密算法和加密算法可逆,然后再证IP和IP–1置换后即可证明DES解密算法的确是DES加密算法的逆。

    根据书本得Feistel解密算法和加密算法的关系,解密过程第一轮的输入等于加密过程第16轮输出左右部分交换的值。最后一轮迭代后密文是LE16||RE16,首先对于加密过程有LE16= LE15,RE16= LE15⊕F(RE15,K16)

    对于解密则有LD1= RD0= LE16= RE15,RD1= LD0⊕F(RD0,K16)=RE16⊕F(RE0,K16)= [LE15⊕F(RE15,K16)]⊕F(RE15,K16)

    XOR运算有以下性质:(A⊕B)⊕C=A⊕(B⊕C),D⊕D=0,E⊕0=E

    因此有LD1= RE15和RD1= LE15所以解密过程的第一轮输出为LE15|| RE15正是加密过程第16轮输入左右部分互换的值,对于其他轮亦是如此。

    DES加密过程说明:64位明文经过初始值换IP重新排列,然后进行16轮函数作用,对于第i轮加密算法有:LEi= LEi-1,REi= LEi-1⊕F(REi-1,Ki)

    因此描述了第i轮的输入是输出的函数。最后一轮的输出是LE0||RE0,左右交换的结果正是原始明文。证明Feistel解密算法和加密算法可逆。而16轮迭代后结果即是LE16||RE16 =LE0||RE0,左右交换得到明文RE0||LE0。所以DES解密算法是DES加密算法的逆。

    作者:L_jun
    链接:https://www.jianshu.com/p/d8b4a4f22aa1
    来源:简书

    展开全文
  • 线 JIANGSU JIANGSU 网络安全课程设计报告 网络安全课程设计报告 学 院 计算机工程学院 专 业 计算机科学与技术 班 级 09计3W 学 号 09141307 姓 名 张 赛 指导老师 古春生 一DES算法的简介 DES算法的加密解密过程是...
  • _(1)实现3DES算法的加密和解密,完成DES加密过程,输入明文,能加密得到正确密文(密文以十六进制显示)。完成DES解密过程,输入密文(十六进制),能解密得到正确明文(字符形式)。 (2)明文加密之后密文,必须...
  • 证明DES解密算法实际上是DES加密算法的DES加密算法和解密算法如图: 如图,首先明文输入,进行第一轮的加密。RE0直接作为LE1,RE0与K1作用于轮函数F然后再与LE0疑惑作为RE1,这是第一轮,之后密钥变换了,不断得...

    证明DES解密算法实际上是DES加密算法的逆

    DES加密算法和解密算法如图:
    这里写图片描述

    如图,首先明文输入,进行第一轮的加密。RE0直接作为LE1,RE0与K1作用于轮函数F然后再与LE0疑惑作为RE1,这是第一轮,之后密钥变换了,不断得做这样的操作,做16轮,最后LE16与RE16交换得到LE17||RE17密文。
    而解密过程如图则是自下而上RD0直接作为LD1,RD0与K16用于轮函数结果与LD1异或得到RD1,不断重复变换密钥,进行16轮。为了抵消最后一轮迭代增加的交换,则最后就要进行一次交换换回来。

    公式证明
    
    加密过程:
    LEi表示第i轮加密得到的左16位数,REi是第i轮加密得到的右16位数。
    LEi=REi-1
    REi=LEi-1⊕F(REi-1,Ki)
    
    经过变换可得:
    REi-1=LEi
    LEi-1=REi⊕F(REi-1,Ki)=REi⊕F(LEi,Ki)
    令LDi是解密的第i轮得到的左16位数,RDi则是右16位数。
    LDi=RDi=LE17-i=RE16-i
    RDi=LDi⊕F(RDi-1,K17-i)
       =REi-1⊕F(REi-1,K17-i)
       =[LEi-1⊕F(REi-1,K17-i)]⊕F(REi-1,K17-i)
       =LEi-1;
     可见经过解密运算之后LDi=RE16-i
    RDi=LEi-1
    
    则此解密过程成立,且是加密过程的逆过程
    
    展开全文
  • DES算法实现过程分析

    2011-06-02 13:51:31
    DES算法原理详细加密解密过程,超细化、标准化解密过程
  • 由于明文长度不确定,用一个确定的算法直接加密全部明文是不现实,所以我们将一个任意明文分为若干个长度为b个比特明文块,这样就可以用一个确定标准化算法对各个明文块进行加密进而实现对全部明文加密。...

    一、简介

    1、密码分类:

    目前的密码算法按有无密钥可分为无密钥密码和有密钥密码,无密钥密码主要是hash函数和消息摘要等,而有密钥密码又分为对称密码和非对称密码,也称私钥密码和公钥密码,像RSA算法就属于公钥密码体制,而私钥密码中最重要的一个部分就是分组密码。

    2、分组密码:

    由于明文长度不确定,用一个确定的算法直接加密全部明文是不现实的,所以我们将一个任意的明文分为若干个长度为b个比特的明文块,这样就可以用一个确定的标准化算法对各个明文块进行加密进而实现对全部明文的加密。

    3、分组密码设计原则:

    1)扩散:使明文中的每一位影响密文中的许多位,即密文中的一位受明文的多位影响,也使密钥中的每一位影响密文的多位。基本操作是排列permutation。
    2)混淆:消除统计特性,使明文密钥与密文的依赖关系变得尽可能的复杂,复杂的非线性代替变换会产生较好的混淆效果。基本操作是替换substitution。

    4、DES加密算法:

    为密码体制中的对称密码体制,明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位, 使得每个密钥都有奇数个1,分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

    二、算法流程图

    下图是算法整体框架图,明文采取读文件方式读入,密钥是自定义。
    DES加密算法使用的是feistel结构,分组长度是64比特。
    对于一个64比特的明文,首先将其进行一个IP置换,比如表中第一位58的意思是将明文的第58位挪到第1位。
    这仅仅起到了一个打乱明文的作用,几乎没有提高安全性。
    在这里插入图片描述
    下图是16轮循环加密算法流程,首先要被加密的明文首先被分成左右两块,右边的块直接作为下一轮的左边输入,同时我们将右边的块使用一个有轮密钥的轮函数进行处理,将得到的结果与上一轮(若是第一轮则是明文)左边的输入进行一个异或操作,得到的结果作为下一轮的右边输入。
    在这里插入图片描述

    三、源代码

    注:算法是可以调用OpenSSL库来完成,不过下载配置麻烦,所以des.h相当于把库文件自己写出来
    本项目分为3个文件:main.cpp、des.h、des.cpp

    //des.h
    #ifndef DES_H_INCLUDED
    #define DES_H_INCLUDED
    #include <iostream>
    #include <string>
    using namespace std;
    typedef const unsigned char TABLE;
    
    // 初始置换IP表
    static TABLE 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, 23, 15, 7
    };
    
    // 逆初始置换IP1表
    static TABLE IP1_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, 17, 57, 25
    };
    
    // 扩展置换E表
    static TABLE EXTENSION_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, 31, 32,  1
    };
    
    // S盒设计
    static TABLE S_Box[8][4][16] =
    {
    	// S盒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盒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盒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盒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盒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盒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盒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盒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
    };
    
    // P盒置换表
    static TABLE 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
    };
    
    // 密钥置换表
    static TABLE 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
    };
    
    // 压缩置换表
    static TABLE PC2_Table[48] =
    {
    	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
    };
    
    // 每轮移动的位数
    static TABLE SHIFT_Table[16] =
    {
    	1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
    };
    
    string byte2bit(string byte);
    string bit2byte(string bit);
    void get_roundkey(string* roundkey, string key);
    string transform(string bit, TABLE* table, int length);
    string B2C(string B, int i);
    
    #endif // DES_H_INCLUDED
    
    //des.cpp
    #include "des.h"
    
    string byte2bit(string byte)
    {//字符串转比特串
    	int length = byte.length();
    	string bit(length * 8, 0);
    	for (int i = 0; i < length; i++) {
    		for (int j = 0; j < 8; j++) {
    			bit[i * 8 + j] = (byte[i] >> (7 - j)) & 1;
    		}
    	}
    	return bit;
    }
    
    string bit2byte(string bit)
    {//比特串转字符串
    	int length = bit.length() / 8;
    	string byte(length, 0);
    	for (int i = 0; i < length; i++)
    	{
    		byte[i] = 0;
    		for (int j = 0; j < 8; j++)
    			byte[i] = (byte[i] << 1) + bit[i * 8 + j];
    	}
    	return byte;
    }
    
    string transform(string bit, TABLE* table, int length)
    {	//矩阵置换
    	string tmp(length, 0);
    	for (int i = 0; i < length; i++)
    		tmp[i] = bit[table[i] - 1];
    	return tmp;
    }
    
    void get_roundkey(string* roundkey, string key)
    {//获取子密钥
    	string bit_key = byte2bit(key);
    	string transformed_key = transform(bit_key, PC1_Table, 56);//PC1是一个将64比特数据进行挑选并重新排列的过程
    	string C(transformed_key, 0, 28);
    	string D(transformed_key, 28, 28);
    
    	for (int i = 0; i < 16; i++)//将数据进行循环左移位,具体移位的多少与加密轮数有关
    	{
    		C = C.substr(SHIFT_Table[i]) + C.substr(0, SHIFT_Table[i]);
    		D = D.substr(SHIFT_Table[i]) + D.substr(0, SHIFT_Table[i]);
    		roundkey[i] = transform(C + D, PC2_Table, 48);//在进行左移之后将两部分数据混合起来,使用PC2的表进行一个置换,即得到了48比特的轮密钥
    	}
    }
    
    string B2C(string B,int i)//使用S盒
    {
    	int row=B[0]*2+B[5];
    	int col=B[1]*8+B[2]*4+B[3]*2+B[4];
    	int s=S_Box[i][row - 1][col - 1];
    	string C;
    	for(i=3;i>=0;i--)
    		C+=(int(s>>i)&1);//6进4出的S盒
    	return C;
    }
    
    //main.cpp
    #include <iostream>
    #include <fstream>
    #include <sstream>
    #include <string>
    #include "des.h"
    #include "des.cpp"
    enum MODE{encrypt,decrypt}mode;//标识是加密还是解密
    using namespace std;
    
    string enfunction(string R,string K);
    string encryption(string L,string R,string* K);
    string des(string data,string key);
    string CBC(string data,string key,string init_vector);
    string stringxor(string a,string b);
    string hex_to_bit(string hex);
    string bit_to_hex(string bit);
    void output(string s);
    string roundkey[16];//轮密钥
    
    string hex_to_bit(string hex)//十六进制字符串转比特串
    {
    	int length=hex.length();
    	string bit(length*4,0);
    	for (int i=0;i<length;i++)
    	{
    		hex[i]-=48;
    		if (hex[i]>9)
    			hex[i]-=7;
    		for (int j=0;j<4;j++)
    			bit[i*4+j]=(hex[i]>>(3-j))&1;
    	}
    	return bit;
    }
    
    string bit_to_hex(string bit)//比特串转十六进制字符串
    {
    	int length=bit.length()/4;
    	string hex(length,0);
    	for(int i=0;i<length;i++)
    	{
    		hex[i]=0;
    		for(int j=0;j<4;j++)
    			hex[i]=(hex[i]<<1)+bit[i*4+j];
    		hex[i]+=48;
    		if (hex[i]>57)
    			hex[i]+=7;
    	}
    	return hex;
    }
    
    void output(string s)//输出二进制字符串
    {
    	cout<<s.length()<<"\t";
    	for(int i=0;i<(int)s.length();i++)
    	{
    		if(s[i]==1)
    			cout<<1;
    		else
    			cout<<0;
    	}
    	cout<<endl;
    }
    
    string stringxor(string a,string b)//字符串异或,将每个字符的二进制异或后再组合
    {
    	for (int i=0;i<(int)a.length();i++)
    		a[i]^=b[i];
    	return a;
    }
    
    string enfunction(string R,string K)//f函数
    {
    	string ER=transform(R,EXTENSION_Table,48);//E扩展,将一个32比特的数据扩展成48比特
    	string BS=stringxor(ER,K);//与轮密钥异或
    	string f;
    	for(int i=0;i<8;i++)
    	{
    		string B(BS.substr(i*6,6));//取6个比特位
    		string C=B2C(B,i);//C是4位,S盒把6位数据转换位4位了
    		f+=C;
    	}
    	return f;//F循环8轮,变为32位数据
    }
    
    string encryption(string L,string R,string* K)//16轮迭代
    {
    	if(mode==encrypt)
    	{
    		for(int i=0;i<16;i++)
    		{
    			string tmp(L);//保存左边
    			L=R;//将右边赋值给左边
    			R=stringxor(tmp,enfunction(R,K[i]));//右边通过S盒加密后与左边异或
    
    //			cout << "L" << i + 1 << ":\t";
    //			output(L);
    //			cout << "R" << i + 1 << ":\t";
    //			output(R);
    		}
    	}
    	else
    	{
    		for(int i=15;i>=0;i--)
    		{
    			string tmp(R);
    			R=L;
    			L=stringxor(tmp,enfunction(L,K[i]));
    
    //			cout << "L" << 16 - i << ":\t";
    //			output(L);
    //			cout << "R" << 16 - i << ":\t";
    //			output(R);
    		}
    	}
    	return transform(L+R,IP1_Table,64);//IP1置换是IP置换的逆过程
    	cout<<endl;
    }
    
    string des(string data,string key)//DES实现单块加解密
    {
    	string bit_data;
    	if (mode==encrypt)//将信息转换为二进制字符串
    		bit_data=byte2bit(data);
    	else
    		bit_data=hex_to_bit(data);
    //	cout<<"信息-二进制:";
    //	output(bit_data);
    
    	bit_data =transform(bit_data,IP_Table,64);//对于一个64比特的明文,首先我们将其进行一个IP置换
    //	cout << "置换-二进制:";
    //	output(bit_data);
    
    	string L(bit_data,0,32);
    	string R(bit_data,32,32);
    	string result=encryption(L,R,roundkey);
    	if (mode==encrypt)
    		return bit_to_hex(result);
    	else
    		return bit2byte(result);
    }
    
    string CBC(string data,string key,string init_vector)//分组链接模式
    {
    	string result;
    	string block;
    	string tmp;
    	string initvector(init_vector);
    
    	if(mode==encrypt)
    	{
    		for(int i=0;i<int(data.length()>>3);i++)//右移3位即除以8
    		{
    			block=data.substr(i*8,8);//获得字符串中从第i * 8位开始的长度为8的字符串
    			cout<<"第"<<i+1<<"块明文:"<<block<<"\t                    ";
    			tmp=des(stringxor(block,initvector),key);//将字符串和密钥异或
    			cout<<"第"<<i+1<<"块密文:"<<tmp<<endl;
    			initvector = bit2byte(hex_to_bit(tmp));//修改向量
    			result+=tmp;
    		}
    		cout<<"完整密文:";
    	}
    	else
    	{
    		for(int i=0;i<int(data.length()>>4);i++)//16个为一组
    		{
    			tmp=data.substr(i*16,16);
    			cout<<"第"<<i+1<<"块密文:"<<tmp<<"\t            ";
    			block=stringxor(des(tmp,key),initvector);
    			cout<<"第"<<i+1<<"块明文:"<<block<<endl;
    			initvector=bit2byte(hex_to_bit(tmp));
    			result+=block;
    		}
    		cout<<"完整明文:"<<endl;
    	}
    	cout<<result<<endl<<endl;
    	return result;
    }
    
    int main()
    {
    	ifstream datafile("text.txt");//创建个文件流对象
    	ostringstream buf;//将文件读入到ostringstream字符串流对象buf中
    	buf<<datafile.rdbuf();// 把文件流中的字符输入到字符串流中
    	string plaintext=buf.str();//返回与流对象buf关联的字符串
    	cout<<"明文:";
    	cout<<plaintext<<endl;
    	string key("abc10101");//设定密钥
    	get_roundkey(roundkey, key);//轮密钥,16个轮密钥由原始密钥生成,每个单块加密时16个轮密钥是一样的。
    //    for(int y=0;y<16;y++)
    //    {
    //        cout<<"roundkey "<<y+1<<": ";
    //        output(roundkey[y]);
    //    }
    	char c=0;
    	while(plaintext.length()%8!=0)//明文不足8位自动补0
    		plaintext+=c;
    	string ciphertext;
    	string init_vector=key;	//设定分组链接的初始向量
    	mode=encrypt;//开始加密
    	ciphertext=CBC(plaintext,key,init_vector);
    	mode=decrypt;//表示开始解密
    	plaintext=CBC(ciphertext,key,init_vector);
    
    	return 0;
    }
    

    四、实验结果测试

    在这里插入图片描述

    展开全文
  • 通过编码实现DES算法或MD5算法深入掌握算法的加密原理理解其实际应用? 价值同时要求用C/C++语言实现该算法让我们从底层开始熟悉该算法的实现过程? 3实验环境? 操作系统WIN7旗舰版? 开发工具Visual?St
  • //获取已经加密数据流 byte[] getStream = Encryption_Decryption.... //获取已经解密的数据流 byte[] finalPlainTextArray = Encryption_Decryption.DecryptTextFromMemory(getStream, keyArray, IVArray);
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Security.Cryptography;
    using System.IO;
    
    namespace 加密解密
    {
        class Encryption_Decryption
        {
            //<3、 加密操作 >
    
            //加密的原料是明文字节流,TripleDES算法对字节流进行加密,返回的是加密后的字节流。同时要给定加密使用的key和IV。
    
            // 把字符串明文转换成utf-8编码的字节流
    
            /// <summary>
            /// 将一个明文的二进制流转换成一个加密的二进制流
            /// </summary>
            /// <param name="strArray">一个明文的二进制数据流,其实也就是你要加密的字符串的二进制形式的数据流</param>
            /// <param name="Key"></param>
            /// <param name="IV"></param>
            /// <returns>返回一个加密后是二进制数据流</returns>
            public static byte[] EncryptString(byte[] strArray, byte[] Key, byte[] IV)
            { 
                //建立一个MemoryStream,这里面存放加密后的数据流
                MemoryStream mStream = new MemoryStream();
    
                //使用MemoryStream和key,IV新建一个CryptoStream对象  
                CryptoStream cStream = new CryptoStream(mStream, new TripleDESCryptoServiceProvider().CreateEncryptor(Key, IV), CryptoStreamMode.Write);
    
                //将加密后的字节流写入到MemoryStream
                cStream.Write(strArray, 0, strArray.Length);
    
                //把缓冲区中的最后状态更新到MemoryStream,并清除cStream的缓存区
                cStream.FlushFinalBlock();
    
                // 把解密后的数据流转成字节流
                byte[] ret = mStream.ToArray();
    
                //关闭两个streams
    
                cStream.Close();
                mStream.Close();
                return ret;
            }
    
            
    
            //<4、 解密操作 >
            //解密操作解密上面步骤生成的密文byte[],需要使用到加密步骤使用的同一组Key和IV。
            
    
            /// <summary>
            /// 将一个加密后的二进制数据流进行解密,产生一个明文的二进制数据流
            /// </summary>
            /// <param name="EncryptedDataArray">加密后的数据流</param>
            /// <param name="Key"></param>
            /// <param name="IV"></param>
            /// <returns>一个已经解密的二进制流</returns>
            public static byte[] DecryptTextFromMemory(byte[] EncryptedDataArray, byte[] Key, byte[] IV)
            {
    
                // 建立一个MemoryStream,这里面存放加密后的数据流
    
                MemoryStream msDecrypt = new MemoryStream(EncryptedDataArray);
    
                // 使用MemoryStream 和key、IV新建一个CryptoStream 对象
                CryptoStream csDecrypt = new CryptoStream(msDecrypt, new TripleDESCryptoServiceProvider().CreateDecryptor(Key, IV), CryptoStreamMode.Read);
    
                // 根据密文byte[]的长度(可能比加密前的明文长),新建一个存放解密后明文的byte[]
                byte[] DecryptDataArray = new byte[EncryptedDataArray.Length];
    
                // 把解密后的数据读入到DecryptDataArray
                csDecrypt.Read(DecryptDataArray, 0, DecryptDataArray.Length);
    
                msDecrypt.Close();
    
                csDecrypt.Close();
    
                return DecryptDataArray;
    
            }
        
        }
        class Program
        {
            static void Main(string[] args)
            {
    
                //<1、 生成key和IV>
    
    
                //System.Security.Cryptography. TripleDESCryptoServiceProvider类是dotnet中实现TripleDES算法的主要的类。
                //TripleDESCryptoServiceProvider类只有一个构造方法TripleDESCryptoServiceProvider(),这个方法把一些属性初始化:
                //KeySize(加密密钥长度,以位为单位)= 192(24字节)
    
                //BlockSize(加密处理的数据块大小,以位为单位)= 64(8字节)
    
                //FeedbackSize(加密数据块后返回的数据大小,以位为单位)= 64(8字节)
    
    
                //TripleDESCryptoServiceProvider构造方法同时会初始化一组随机的key和IV。
                //默认的TripleDESCryptoServiceProvider的key为24字节,IV为8字节,加密数据块为8字节。
                //生成key和IV的代码很简单:
    
                TripleDESCryptoServiceProvider tDESalg = new TripleDESCryptoServiceProvider();
    
                byte[] keyArray = tDESalg.Key;
    
                byte[] IVArray = tDESalg.IV;
    
    
                //<2、 字符串明文转成某一代码页对应的编码字节流 >
    
                //待加密的数据可能有两种形式,一种是二进制的数据,本身就是一组字节流,这样的数据可以跳过这一步,直接进入加密步骤。还有一种情况是字符串数据,字符串中同样的字符使用不同的代码页会生成不同的字节码,所以从字符串到字节流的转换是需要指定使用何种编码的。在解密之后,要从字节流转换到字符串就要使用相同的代码页解码,否则就会出现乱码。
    
                // 待加密的字符串
                string str = "你好中国";
    
                // 使用utf-8编码(也可以使用其它的编码)
    
                Encoding sEncoding = Encoding.GetEncoding("utf-8");
    
                // 把字符串明文转换成utf-8编码的字节流
    
                byte[] strArray = sEncoding.GetBytes(str);
    
    
    
    
    
                //<4,调用第四步方法// 调用解密方法,返回已解密数据的byte[]>
    
                //获取已经加密的数据流
                byte[] getStream = Encryption_Decryption.EncryptString(strArray, keyArray, IVArray);
    
                //获取已经解密的数据流
                byte[] finalPlainTextArray = Encryption_Decryption.DecryptTextFromMemory(getStream, keyArray, IVArray);
    
                // 使用前面定义的Encoding,utf-8的编码把byte[]转成字符串
                string s = sEncoding.GetString(finalPlainTextArray);
    
                Console.WriteLine(s);
    
    
    
                Console.ReadKey();
               
                
    
            }
        }
    }
    

    展开全文
  • DES加密与解密算法的实现

    千次阅读 2008-10-17 14:01:00
    (1)DES算法简介数据加密...DES算法以64位(8 byte)为分组对数据加密,其中有8位(第8,16,24,32,48,56和64位)用作奇偶校验位,另外56位为真正密钥,保密性依赖于密钥,加密和解密过程使用同一个密钥。(2)
  • 3DES解密算法

    2017-07-28 16:05:43
    3DES(即Triple DES)是DES向AES过渡的加密算法(1999年,NIST将3-DES指定为过渡的加密标准),加密算法,其具体实现如下:设Ek()和Dk()代表DES算法的加密和解密过程,K代表DES算法使用的密钥,M代表明文,C代表密文...
  • 本文首先对GSM系统现有安全机制做了介绍, 指出了其存在问题, 提出了将DES算法用在GSM系统安全机制中, 并对其实现过程做了详细介绍, 该方法可以对移动通信构造新安全机制提供一定参考.
  • 1)算法和数据结构就是编程的一个重要部分,你若失掉了算法和数据结构,你就把一切都失掉了。...对称密码算法的加密密钥和解密密钥相同,对于大多数对称密码算法,加解密过程互逆。 很多人都是用...
  • DES加密解密算法实现

    2019-01-24 17:28:11
    其分组长度为64比特,使用密钥长度为56比特(实际上函数要求一个64位密钥作为输入,但其中用到有效长度只有56位,剩余8位可作为奇偶校验位或完全随意设置),DES解密过程类似,加解密使用同样的算法,唯一不同...
  • 1 实验一 1实验题目 利用C/C++编程实现DES加密算法或MD5加密算法我选择的是用 C++语言实现 DES的加密算法 2 实验目的 通过编码实现DES算法或MD5算法深入掌握算法的加密原理理解其 实际应用 价值同时要求用C/C++语言...
  • MD5 加密算法我选择的是用 C++语言实现 DES的加密算法 2实验目的 通过编码实现 DES算法或 MD5 算法深入掌握算法的加密原理理解其实际应用价值同时要求用 C/C++语言实现该算法让我们从底层开始熟悉该算法的实现过程3...
  • DES 算法的使用

    2017-04-06 16:23:31
    加密和解密过程中所使用密钥相同,就是对称密码,而且大多数对称密码算法,加密解密过程都是互逆DES 算法是一种数据加密算法,明文按照 64 位进行分组,分组后明文与密钥按位替代或交换方法形成密文组。...
  • 数据加密基本过程就是对原来为明文文件或数据按某种算法进行处理,使其成为不可读一段代码,通常称为密文,使其只能在输入相应密钥之后才能显示出本来内容,通过这样途径来达到保护数据不被非法人窃取、...
  • 在linux/unix平台上实现的des,3des加密解密算法。在main.c中提供了实例程序,你可以运行他来知道如何使用该加密解密过程
  • DES算法全解 一、什么是DES算法 DES是(Data Encryption Standard)缩写,为密码体制中对称密码体制,又被称为美国数据加密标准。 DES是一种分组密码。明文,密文,密钥分组长度都是64位。 DES是面向二进制...
  • DES算法的实现

    2017-10-02 13:52:59
    DES算法的实现 DES 算法概述 DES 是一种典型的块加密方法:它以64位为分组长度,64 位一组的明文作为算法的输入,通过一系列复杂的操作, 输出同样64位长度的密文。 DES 使用加密密钥定义变换过程,因此算法认为...
  • DES算法

    2017-10-07 14:21:47
    一、DES算法原理概述DES算法是这样一个算法:它使用密钥和明文作为参数,经过一系列复杂运算过程,输出明文对应密文。首先要指出是,明文是按照每64位一个分组来进行输入。输出对应密文也是64位。而密钥...
  • DES算法实现过程分析】 1. 处理密钥: 1.1 从用户处获得64位密钥.(每第8位为校验位,为使密钥有正确奇偶校验,每个密钥要有奇数个”1”位.(本文如未特指,均指二进制位) 1.2 具体过程: 1.2.1 对密钥实施变换,使得...
  • DES算法为密码体制中对称密码体制,又被称为美国数据加密标准,是1972年美国IBM公司研制对称密码体制加密算法。明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64...
  • 3des的加、解密过程

    2013-08-29 23:28:36
    3DES(或称为Triple DES)是三重数据加密算法(TDEA,Triple Data Encryption ...3DES即是设计用来提供一种相对简单方法,即通过增加DES的密钥长度来避免类似攻击,而不是设计一种全新块密码算法。 3DES又称T...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 640
精华内容 256
关键字:

des算法的解密过程