DES加密算原理简述与C++代码实现

最新推荐文章于 2024-05-13 11:40:25 发布
最新推荐文章于 2024-05-13 11:40:25 发布
阅读量2.6k 收藏 14
点赞数
分类专栏： 密码学 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45031509/article/details/124402721
版权

1.加密流程

（1）64bit的明文经过一个P盒的初始置换，然后分成左右两个部分

（2）进行十六轮的加密操作，其中上一轮的右部分复制下一轮的左部分，上一轮的右部分经F轮函数操作的结果与该轮左部分进行异或，得出的结果复制给下一轮的右部分。注意，在第16轮时，R16=R15，L16=L15⊕F(R15,K16)

（3）把最后的一轮得出得左右部分结合在一起，在进行一个P盒得置换，得到密文

F轮函数

（1）进入的32bit的右部分，经过扩展P盒的扩展变成48bit

（2）扩展P盒得出的48bit结果与48bit的密钥进行异或

（3）上一步异或的48bit结果在进行8个S盒压缩成32bit

（4）经S盒压缩后的32bit信息再经过一个P盒的置换，得出F轮函数的操作结果

密钥的产生

（1）64bit的密钥信息，经过P盒压缩，变成56bit，并分成左右28bit两个部分

（2）左右了两个部分分别根据每轮移动的值进行循环左移

（3）把循环左移后的两部分密钥重新按左右顺序结合成58bit

（4）58bit的信息在进行一个P盒的压缩变成48bit的该轮密钥K

2.算法框图

在这里插入图片描述

3.详详细解释原理参考

DES加密算法_樱木之的博客-CSDN博客_csdn des算法

4.C++代码实现

（1）说明

本算法实现了对一个64bit的十六进制信息的加密，主要是把二进制信息储存在字符串中，通过操作字符串下标来进行替换，异或等操作

（2）所用函数

string BinaryToHex(string binary)//二进制转十六进制，输入二进制的字符串，输出十六进制的字符串
string BinaryToHex(string binary)//二进制转十六进制，输入十六进制的字符串，输出二进制的字符串
string DeciTo4Bin(int n)//十进制转4位二进制，在F轮函数中S盒压缩时用到
string InitialReplace(string binmessage)//初始置换函数，64bit明文的初始置换
string EndInReplace(string binary64)//输出密文前的置换，逆初始置换
string ExtendTrans(string binary32)//扩展变换，F轮函数中的扩展变换
string XOR(string str1, string str2)//两个字符串的异或
string FSboxPress(string binary48)//输出F轮函数中，S盒的压缩，以及压缩后的P盒置换的结果
string KPremuSel1(string keybinary64)//密钥的置换选择1，把64bit的密钥变成54bit
string KeyRoundCreate(string & C0, string& D0, int n)//轮密钥的生成，输入：左28密钥二进制，右28密钥二进制，左移位数。
                                                  //输出：48位的二进制密钥,注意C0，D0是引用的传递
void Encryption()//加密函数

（3）代码

#pragma once
#include<iostream>
#include<string>
using namespace std;
/*
//开始
static const int IP[64];//初始时的IP置换盒64bit->32bit+32bit
//最后
static const int IPI[64];//最后输出时的逆初始置换IP:32bit+32bit->64bit
//F论函数
static const int FEP[48];//F轮函数中的EP扩展变换盒，32bit-48bit
static const int FS8[32][16];//F轮函数中的8个S压缩盒；48bit->32bit
static const int FP[32];//F轮函数中的置换运算P盒32bit->32bit
//密钥的产生
static const int CP1[56];//密钥生产过程中的置换选择压缩P1盒64bit->28bit+28bit
static const int CP2[48];//密钥生产过程中的置换选择压缩P2盒28bit+28bit->48bit
static const int CEnRotateLeft[16];//密钥生产过程中每轮的循环左移的数
*/
//初始时的IP置换盒64bit->32bit+32bit
static const int P[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 };
//最后输出时的逆初始置换IP:32bit+32bit->64bit
static const int IPI[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 };
//F轮函数中的EP扩展变换盒，32bit-48bit
static const int FEP[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 };
//F轮函数中的8个S压缩盒；48bit->32bit
static const int FS8[32][16]= {
			 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7, //S1
			 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, //S2
			 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, //S3
			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, //S4
			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,//S5
			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,//S6
			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,//S7
			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,//S8
			 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  
};
//F轮函数中的置换运算P盒32bit->32bit
static const int FP[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 };
//密钥生产过程中的置换选择压缩P1盒64bit->28bit+28bit
static const int CP1[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 };
//密钥生产过程中的置换选择压缩P2盒28bit+28bit->48bit
static const int CP2[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 const int CEnRotateLeft[16]= { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };

//各种辅助函数
string HexToBinary(string hex)//十六进制变二进制
{
	string binnum = "";
	int n = hex.size();
	for (int j = 0; j < hex.length(); j++)
	{
		switch (hex[j])
		{
		case '0':binnum += "0000"; break;
		case '1':binnum += "0001"; break;
		case '2':binnum += "0010"; break;
		case '3':binnum += "0011"; break;
		case '4':binnum += "0100"; break;
		case '5':binnum += "0101"; break;
		case '6':binnum += "0110"; break;
		case '7':binnum += "0111"; break;
		case '8':binnum += "1000"; break;
		case '9':binnum += "1001"; break;
		case 'A':binnum += "1010"; break;
		case 'B':binnum += "1011"; break;
		case 'C':binnum += "1100"; break;
		case 'D':binnum += "1101"; break;
		case 'E':binnum += "1110"; break;
		case 'F':binnum += "1111"; break;
		default:
			break;
		}

	}
	return binnum;
}
string BinaryToHex(string binary)//二进制转十六进制
{
	string hex = "";
	int temp;
	for (int i = 0; i < binary.size(); i+=4)
	{
		//转化为int型
		temp = ((int)binary[i]-(int)'0') * 8 + ((int)binary[i+1] - (int)'0') * 4 
			+ ((int)binary[i+2] - (int)'0') * 2 + ((int)binary[i+3] - (int)'0') * 1;
		//cout << temp;
		if (temp >= 10)
		{
			switch (temp)
			{
			case 10:hex += "A"; break;
			case 11:hex += "B"; break;
			case 12:hex += "C"; break;
			case 13:hex += "D"; break;
			case 14:hex += "E"; break;
			case 15:hex += "F"; break;
			}
		}
		else
		{
			hex += to_string(temp);
		}
	}
	return hex;
}
string DeciTo4Bin(int n)//十进制转4位二进制
{
	string decimal = "";
	while (n)
	{
		decimal += to_string(n % 2);
		n = n / 2;
	}
    //反转一下
	for (int i = 0; i < decimal.size() / 2; i++)
	{
		char temp;
		temp = decimal[i];
		decimal[i] = decimal[decimal.size() - 1 - i];
		decimal[decimal.size() - 1 - i] = temp;
	}
	switch (4-decimal.size())
	{
	case 1:decimal = "0"+ decimal; break;
	case 2:decimal = "00" + decimal; break;
	case 3:decimal = "000" + decimal; break;
	case 4:decimal = "0000" + decimal; break;
	default:
		break;
	}
	return decimal;
}
//开始
string InitialReplace(string binmessage)//初始置换函数
{
	string binary = "";
	for (int i = 0; i < 64; i++)
	{
		binary += binmessage[P[i] - 1];

	}
	return binary;
}
//最后
string EndInReplace(string binary64)
{
	string out64 = "";
	for (int i = 0; i < 64; i++)
	{
		out64 += binary64[IPI[i] - 1];
	}
	return out64;
}
//F论函数
string ExtendTrans(string binary32)//扩展变换
{
	string out48 = "";
	for (int i = 0; i < 48; i++)
	{
		out48 += binary32[FEP[i] - 1];
	}
	return out48;
}
string XOR(string str1, string str2)//两个字符串的异或
{
	string outcome = "";
	for (int i = 0; i < str1.size(); i++)
	{
		if (str1[i] == str2[i])
			outcome += "0";
		else
		{
			outcome += "1";
		}
	}
	return outcome;
}
string FSboxPress(string binary48)
{
	int n = 1;//从第一个S盒开始
	string binary32 = "";
	for (int i = 0; i < binary48.size(); i+=6)
	{
		int y = ((int)binary48[i] - (int)'0') * 2 + ((int)binary48[i + 5] - (int)'0') * 1;//获取S盒第几行
		int x = ((int)binary48[i + 1] - (int)'0') * 8 + ((int)binary48[i + 2] - (int)'0') * 4//获取S盒的第几列
			+ ((int)binary48[i + 3] - (int)'0') * 2 + ((int)binary48[i + 4] - (int)'0') * 1;
		int tem = FS8[y + (n - 1) * 4][x];//获取该S盒行列位置下的十进制
		binary32 += DeciTo4Bin(tem);//把十进制转化位二进制，并复制给要输出的字符串
		n++;//调用下一个S盒
	}
    
	string premutation = "";
	for (int i = 0; i < 32; i++)
	{
		premutation += binary32[FP[i] - 1];
	}
	return premutation;
}

//K密钥
string KPremuSel1(string keybinary64)//密钥的置换选择1
{
	string out56 = "";
	for (int i = 0; i < 56; i++)
	{
		out56 += keybinary64[CP1[i] - 1];
	}
	return out56;
}
string KeyRoundCreate(string & C0, string& D0, int n)//轮密钥的生成，输入：左28密钥二进制，右28密钥二进制，左移位数。
                                                  //输出：48位的二进制密钥,注意C0，D0是引用的传递
{
	string Cnext = "", Dnext = "";//临时储存左移的结果
	string out48;//把左移的结果拼接
	for (int i = n; i < C0.size(); i++)//对C0循环左移
	{
		Cnext += C0[i];
		Dnext += D0[i];
	}
	for (int i = 0; i < n; i++)//对D0循环左移
	{
		Cnext += C0[i];
		Dnext += D0[i];
	}
	//cout << "C0循环左移：" << Cnext << endl;
	//cout << "D0循环左移：" << Dnext << endl;
	//把传进来的左右两个密钥改为下一轮的新左右两密钥，提供给下一轮使用
	C0 = Cnext;
	D0 = Dnext;
	string temp = Cnext + Dnext;
	//拼接的结果，进行置换选择2（压缩P盒）
	for (int i = 0; i < 48; i++)
	{
		out48 += temp[CP2[i] - 1];
	}
	return out48;
}

//加密
void Encryption()
{
	string key = HexToBinary("AABB09182736CCDD");//密钥二进制
	string message = HexToBinary("123456ABCD132536");//明文二进制
	//密钥
	string keypresel1 = KPremuSel1(key);//密钥压缩
	string keyleft28 = keypresel1.substr(0, 28);
	string keyright28 = keypresel1.substr(28, 28);
	string premessage = InitialReplace(message);//初始置换IP，64bit-64bit
	//把初始的message分为左右两个部分
	string messleft = premessage.substr(0, 32);
	string messright = premessage.substr(32, 32);
	cout << "轮序0    " << "左：" << BinaryToHex(messleft) << "    右：" << BinaryToHex(messright) << endl;
	//获取第一轮密钥
	for (int i = 0; i < 16; i++)
	{
		string kdynextbinary = KeyRoundCreate(keyleft28, keyright28, CEnRotateLeft[i]);//获取轮密钥
		string Fextendres = ExtendTrans(messright);//F论函数对右边明文进行扩展，32bit-48bit
		string firstxor = XOR(Fextendres, kdynextbinary);//扩展的结果与轮密钥异或
		string sboxpress = FSboxPress(firstxor);//异或的结果进行8个S盒的压缩，以及一个P盒的置换
		string newright = XOR(messleft, sboxpress);//上步得到的结果在与左边的明文进行异或
		if (i < 15)
		{
			cout << "轮序" << i + 1 << "    左：" << BinaryToHex(messright) << "    右：" << BinaryToHex(newright)
				<< "    密钥" << BinaryToHex(kdynextbinary) << endl << endl;
		}
		else
		{
			cout << "轮序" << i + 1 << "    左：" << BinaryToHex(newright) << "    右：" << BinaryToHex(messright)
				<< "    密钥" << BinaryToHex(kdynextbinary) << endl << endl;
		}
		//下一轮的新参数；
		if (i < 15)
		{
			messleft = messright;//下一轮的左message
			messright = newright;//下一轮的右message	
		}
		else
		{
			messleft = newright;
		}	
	}
	string F16res = messleft + messright;
	cout << "左右部分拼接在一起：" << BinaryToHex(F16res) << endl;
	string endoutcom = InitialReplace(F16res);
	cout << "密文：" << BinaryToHex(endoutcom) << endl;
}
remandancy.h
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
OpenSSL之API编程 - C/C++实现AES、DES、3DES、SM4对称加密算法
new9232的博客
05-23 330
本文章介绍了OpenSSL计算对称加解密算法(AES、DES、3DES、SM4等)的相关接口，并使用C语言实现了AES和SM4加解密。
关于DES加密算法的C++实现
holymoonshine的专栏
01-17 1853
 数据加密算法　　数据加密标准DES　　数据加密算法（Data Encryption Algorithm，DEA）的数据加密标准（Data Encryption Standard，DES）是规范的描述，它出自IBM 的研究工作，并在 1977 年被美国政府正式采纳。它很可能是使用最广泛的密钥系统，特别是在保护金融数据的安全中，最初开发的 DES 是嵌入硬 件中的。通常，自动取款机（Auto
des代码实现对任意长度明文加密_DES对称加密算法详解和c++代码实现（带样例和详细的中间数据）...
weixin_39580564的博客
12-20 1208
特点：1.DES是对称性加密算法，即加密和解密是对称的，用的是同一个密钥2.DES只处理二进制数据，所以需要将明文转换成为2进制数据3.DES每次处理64位的数据，所以应该将明文切割成64位的分组，当最后一组数据不足64位的时候，高位补04.DES使用64位的密钥，但因为密钥中的每8位会被忽略，所以有效的密钥长度是56位，从而产生16个48位的子密钥(变换过程后面会说明)5.每64位数据一个块，是...
2024年DES加密解密算法（简单、易懂、超级详细）_des算法(1)，C C++界面开发基础
最新发布
2401_84975622的博客
05-13 597
（1）先建立一个#include "DES.h"的头文件，放入需要的函数。（4）最后在进行IP的逆序置换，将左右两个分支再次合并为。(3) 相同的操作进行16次的运算循环，算出相应的，（2）在建立DES.cpp，写出头文件中对应的函数操作。（5）将上述的说法，汇聚成流程图，方便大家理解。（1）明文的加密的整体过程。（3）密钥的形成过程。
密码学算法——DES密码算法 c++实现
suixiang的博客
04-01 1997
DES算法作为比较经典的对称密钥算法，还是有深入学习的必要。
des加密算法的c++ 实现
专注java二开部署
11-30 1809
总的来说，实现一个安全的加密系统需要综合考虑多个因素，并采取适当的措施来确保其安全性、性能和合规性。此外，还需要不断关注最新的安全研究和最佳实践，并及时更新和改进现有的系统。需要注意的是，DES 加密算法已经被认为是不安全的，不建议在现代应用程序中使用。总的来说，实现一个安全的加密系统需要考虑许多因素，并且需要遵循最佳实践来确保其安全性和性能。实现一个安全的加密系统需要综合考虑多个因素，并采取适当的措施来确保其安全性、性能和合规性。除了上述基本的DES加密过程，还有一些其他的步骤和注意事项可以考虑。
DES加密算法实现（加解密代码C++）
热门推荐
CH_whale的博客
03-06 1万+
参考博客：加密算法------DES加密算法详解_柯南的博客-CSDN博客_des加密算法 一、算法流程 二、数据定义 数据名称 数据类型 数据描述 ExchangeRules Int[56] 交换规则表 ShiftTable Int[16] 移位表 PC_2 Int[48] .
密码学习总结|DES算法超详解 含代码
weixin_43340821的博客
09-06 3664
DESDES简介一些初步的DES的例子DES的具体工作步骤第一步：创建16个子秘钥，每个长48比特 DES简介 DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。 一些初步的DES的例子 DES处理比特，或者说二进制数字。我们知道，每四个比特构成一个十六进制数。DES加密一组64位的信息，也就是16个16进制数。为了完成
DES加解密算法 — python和C++实现
CTFwp笔记1-rsa基本知识+共模攻击
03-19 2647
DES加解密
DES加密
m0_74422124的博客
03-10 1560
DES是一种将64比特的明文加密成64比特密文的对称密码算法，密钥长度56比特。64比特的单位称为分组，DES是分组密码的一种。DES，又称Feistel密码，在Feistel网络中，加密的各个步骤称为轮，整个加密过程就是进行若干次轮的循环。（R0和K1,经过轮运算，再与L0异或。一）IP置换，按照初始置换表，将原来的64位二进制重新排序。（将原始数据第58位的数转化为第一个，将原始数据50的数转化为第二个......)二）16轮的轮函数F变换。
数据加密标准（DES）的C++语言描述实现
夜悊的博客
10-24 2748
网络安全中数据加密标准（DES）的C++语言描述实现。
实现数字签名算法（DSA），Hash算法的实现C语言
04-15
1）利用C\C++语言实现DSA算法。 2）DSA中的Hash函数采用SHA算法。 （1）消息填充：因为我们存储的时候是以字节为单位存储的，所以消息的长度（单位：位）一定是 8 的倍数。而我们填充的时候也一定是 8 位、8 位地来填充。也即不可能只填充一个二进制位，至少是 8 个二进制位（一个字节）。因此最少填充 1 个字节，最多填充 64 个字节（64*8=512）。 在SHA1中，为了HASH小于2^64长度的输入消息，先对消息m的长度进行处理，判断补0后是512位的多少倍。 （2）大整数：因为涉及到几百位的大整数运算，如这里规定p是512位，先封装一个大整数类BigNumber，BigNumber的成员变量有sign, length, uint32_t number[MAXLENGTH], MAXLENGTH规定为128，也就是说这个BigNumber最多可以由128个uint32_t型的数拼起来。
DES加密解密（c++实现）
10-06
DES加密解密（c++实现）
C++ 代码实现DES加密解密源代码类
10-30
在C++中实现DES加密解密，可以创建一个类来封装相关的操作，这样有利于代码的复用和维护。 描述中提到的"单倍双倍加密算法的实现"，可能是指使用DES算法进行一次或两次加密的过程。单次DES加密使用同一个密钥对数据...
C++实现DES加密算法实例解析
12-26
本文所述实例是一个实现DES加密算法的程序代码，在C++中，DES加密是比较常用的加密算法了，且应用非常广泛。本CPP类文件可满足你的DES加密需要，代码中附带了丰富的注释，相信对于大家理解DES可以起到很大的帮助。 ...
DES加密算法C++实现
06-05
DES（Data Encryption Standard）是一种经典的对称加密算法，1976年由美国国家标准局发布，广泛应用于数据加密领域。在C++中实现DES加密算法，...阅读和理解这些代码，可以帮助深入理解DES加密算法以及C++的实现细节。
DES加密算法的C++实现程序
12-26
在C++中实现DES加密算法需要理解其工作原理，并掌握必要的数据结构和位操作技巧。下面我们将深入探讨DES加密算法以及如何用C++来实现。 首先，DES加密过程分为以下步骤： 1. **初始置换（IP）**：原始的64位明文...
DES加密&解密字符串
a64887911的博客
07-10 249
using System.Security.Cryptography;using System.IO;using System.Text; //默认密钥向量 private static byte[] DyncKeys = { 0x12, 0x14, 0x14, 0x15, 0xA0, 0xA1, 0xB0, 0xB1 }; //默认加密密钥 private ...
DES算法实现（C++版）
无知亦乐
01-10 1万+
一、DES算法原理 系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、DES算法原理系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。
DES数据加密算法-用C++设计编写符合DES算法思想的加、解密程序.doc
03-15
DES数据加密算法-用C++设计编写符合DES算法思想的加、解密程序，根据DES加密标准，用C++设计编写符合DES算法思想的加、解密程序，能够实现对字符串和数组的加密和解密。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

remandancy.h

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值