OpenSSL中对称加密算法DES常用函数使用举例

2023-05-16

主要包括3个文件：

1. cryptotest.h:

#ifndef _CRYPTOTEST_H_
#define _CRYPTOTEST_H_

#include <string>

using namespace std;

typedef enum {
	GENERAL = 0,
	ECB,
	CBC,
	CFB,
	OFB,
	TRIPLE_ECB,
	TRIPLE_CBC
}CRYPTO_MODE;

string DES_Encrypt(const string cleartext, const string key, CRYPTO_MODE mode);
string DES_Decrypt(const string ciphertext, const string key, CRYPTO_MODE mode);

#endif //_CRYPTOTEST_H_

2. destest.cpp:

#include <iostream>
#include <string>
#include <vector>
#include <openssl/des.h>
#include "cryptotest.h"

using namespace std;

static unsigned char cbc_iv[8] = {'0', '1', 'A', 'B', 'a', 'b', '9', '8'};

string DES_Encrypt(const string cleartext, const string key, CRYPTO_MODE mode)
{
	string strCipherText;

	switch (mode) {
	case GENERAL:
	case ECB:
		{
			DES_cblock keyEncrypt;
			memset(keyEncrypt, 0, 8);

			if (key.length() <= 8) 
				memcpy(keyEncrypt, key.c_str(), key.length());
			else 
				memcpy(keyEncrypt, key.c_str(), 8);

			DES_key_schedule keySchedule;
			DES_set_key_unchecked(&keyEncrypt, &keySchedule);	

			const_DES_cblock inputText;
			DES_cblock outputText;
			vector<unsigned char> vecCiphertext;
			unsigned char tmp[8];

			for (int i = 0; i < cleartext.length() / 8; i ++) {
				memcpy(inputText, cleartext.c_str() + i * 8, 8);
				DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_ENCRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCiphertext.push_back(tmp[j]);
			}

			if (cleartext.length() % 8 != 0) {
				int tmp1 = cleartext.length() / 8 * 8;
				int tmp2 = cleartext.length() - tmp1;
				memset(inputText, 0, 8);
				memcpy(inputText, cleartext.c_str() + tmp1, tmp2);

				DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_ENCRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCiphertext.push_back(tmp[j]);
			}

			strCipherText.clear();
			strCipherText.assign(vecCiphertext.begin(), vecCiphertext.end());
		}
		break;
	case CBC:
		{
			DES_cblock keyEncrypt, ivec;
			memset(keyEncrypt, 0, 8);

			if (key.length() <= 8) 
				memcpy(keyEncrypt, key.c_str(), key.length());
			else 
				memcpy(keyEncrypt, key.c_str(), 8);

			DES_key_schedule keySchedule;
			DES_set_key_unchecked(&keyEncrypt, &keySchedule);	

			memcpy(ivec, cbc_iv, sizeof(cbc_iv));

			int iLength = cleartext.length() % 8 ? (cleartext.length() / 8 + 1) * 8 : cleartext.length();
			unsigned char* tmp = new unsigned char[iLength + 16];
			memset(tmp, 0, iLength);

			DES_ncbc_encrypt((const unsigned char*)cleartext.c_str(), tmp, cleartext.length()+1, &keySchedule, &ivec, DES_ENCRYPT);
	
			strCipherText = (char*)tmp;

			delete [] tmp;
		}
		break;
	case CFB:
		{
			DES_cblock keyEncrypt, ivec;
			memset(keyEncrypt, 0, 8);

			if (key.length() <= 8) 
				memcpy(keyEncrypt, key.c_str(), key.length());
			else 
				memcpy(keyEncrypt, key.c_str(), 8);

			DES_key_schedule keySchedule;
			DES_set_key_unchecked(&keyEncrypt, &keySchedule);	

			memcpy(ivec, cbc_iv, sizeof(cbc_iv));

			unsigned char* outputText = new unsigned char[cleartext.length()];
			memset(outputText, 0, cleartext.length());

			const unsigned char* tmp = (const unsigned char*)cleartext.c_str();

			DES_cfb_encrypt(tmp, outputText, 8, cleartext.length(), &keySchedule, &ivec, DES_ENCRYPT);

			strCipherText = (char*)outputText;
			
			delete [] outputText;
		}
		break;
	case TRIPLE_ECB:
		{
			DES_cblock ke1, ke2, ke3;
			memset(ke1, 0, 8);
			memset(ke2, 0, 8);
			memset(ke2, 0, 8);

			if (key.length() >= 24) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, 8);
			} else if (key.length() >= 16) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, key.length() - 16);
			} else if (key.length() >= 8) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, key.length() - 8);
				memcpy(ke3, key.c_str(), 8);
			} else {
				memcpy(ke1, key.c_str(), key.length());
				memcpy(ke2, key.c_str(), key.length());
				memcpy(ke3, key.c_str(), key.length());
			}

			DES_key_schedule ks1, ks2, ks3;
			DES_set_key_unchecked(&ke1, &ks1);
			DES_set_key_unchecked(&ke2, &ks2);
			DES_set_key_unchecked(&ke3, &ks3);

			const_DES_cblock inputText;
			DES_cblock outputText;
			vector<unsigned char> vecCiphertext;
			unsigned char tmp[8];

			for (int i = 0; i < cleartext.length() / 8; i ++) {
				memcpy(inputText, cleartext.c_str() + i * 8, 8);
				DES_ecb3_encrypt(&inputText, &outputText, &ks1, &ks2, &ks3, DES_ENCRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCiphertext.push_back(tmp[j]);
			}

			if (cleartext.length() % 8 != 0) {
				int tmp1 = cleartext.length() / 8 * 8;
				int tmp2 = cleartext.length() - tmp1;
				memset(inputText, 0, 8);
				memcpy(inputText, cleartext.c_str() + tmp1, tmp2);

				DES_ecb3_encrypt(&inputText, &outputText, &ks1, &ks2, &ks3, DES_ENCRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCiphertext.push_back(tmp[j]);
			}

			strCipherText.clear();
			strCipherText.assign(vecCiphertext.begin(), vecCiphertext.end());
		}
		break;
	case TRIPLE_CBC:
		{
			DES_cblock ke1, ke2, ke3, ivec;
			memset(ke1, 0, 8);
			memset(ke2, 0, 8);
			memset(ke2, 0, 8);

			if (key.length() >= 24) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, 8);
			} else if (key.length() >= 16) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, key.length() - 16);
			} else if (key.length() >= 8) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, key.length() - 8);
				memcpy(ke3, key.c_str(), 8);
			} else {
				memcpy(ke1, key.c_str(), key.length());
				memcpy(ke2, key.c_str(), key.length());
				memcpy(ke3, key.c_str(), key.length());
			}

			DES_key_schedule ks1, ks2, ks3;
			DES_set_key_unchecked(&ke1, &ks1);
			DES_set_key_unchecked(&ke2, &ks2);
			DES_set_key_unchecked(&ke3, &ks3);

			memcpy(ivec, cbc_iv, sizeof(cbc_iv));

			int iLength = cleartext.length() % 8 ? (cleartext.length() / 8 + 1) * 8 : cleartext.length();
			unsigned char* tmp = new unsigned char[iLength + 16];
			memset(tmp, 0, iLength);

			DES_ede3_cbc_encrypt((const unsigned char*)cleartext.c_str(), tmp, cleartext.length()+1, &ks1, &ks2, &ks3, &ivec, DES_ENCRYPT);

			strCipherText = (char*)tmp;

			delete [] tmp;
		}
		break;
	}

	return strCipherText;
}

string DES_Decrypt(const string ciphertext, const string key, CRYPTO_MODE mode)
{
	string strClearText;

	switch (mode) {
	case GENERAL:
	case ECB:
		{
			DES_cblock keyEncrypt;
			memset(keyEncrypt, 0, 8);

			if (key.length() <= 8) 
				memcpy(keyEncrypt, key.c_str(), key.length());
			else 
				memcpy(keyEncrypt, key.c_str(), 8);

			DES_key_schedule keySchedule;
			DES_set_key_unchecked(&keyEncrypt, &keySchedule);	

			const_DES_cblock inputText;
			DES_cblock outputText;
			vector<unsigned char> vecCleartext;
			unsigned char tmp[8];

			for (int i = 0; i < ciphertext.length() / 8; i ++) {
				memcpy(inputText, ciphertext.c_str() + i * 8, 8);
				DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_DECRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCleartext.push_back(tmp[j]);
			}

			if (ciphertext.length() % 8 != 0) {
				int tmp1 = ciphertext.length() / 8 * 8;
				int tmp2 = ciphertext.length() - tmp1;
				memset(inputText, 0, 8);
				memcpy(inputText, ciphertext.c_str() + tmp1, tmp2);

				DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_DECRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCleartext.push_back(tmp[j]);
			}

			strClearText.clear();
			strClearText.assign(vecCleartext.begin(), vecCleartext.end());
		}
		break;
	case CBC:
		{
			DES_cblock keyEncrypt, ivec;
			memset(keyEncrypt, 0, 8);

			if (key.length() <= 8) 
				memcpy(keyEncrypt, key.c_str(), key.length());
			else 
				memcpy(keyEncrypt, key.c_str(), 8);

			DES_key_schedule keySchedule;
			DES_set_key_unchecked(&keyEncrypt, &keySchedule);	

			memcpy(ivec, cbc_iv, sizeof(cbc_iv));

			int iLength = ciphertext.length() % 8 ? (ciphertext.length() / 8 + 1) * 8 : ciphertext.length();
			unsigned char* tmp = new unsigned char[iLength];
			memset(tmp, 0, iLength);

			DES_ncbc_encrypt((const unsigned char*)ciphertext.c_str(), tmp, ciphertext.length()+1, &keySchedule, &ivec, DES_DECRYPT);

			strClearText = (char*)tmp;

			delete [] tmp;
		}
		break;
	case CFB:
		{
			DES_cblock keyEncrypt, ivec;
			memset(keyEncrypt, 0, 8);

			if (key.length() <= 8) 
				memcpy(keyEncrypt, key.c_str(), key.length());
			else 
				memcpy(keyEncrypt, key.c_str(), 8);

			DES_key_schedule keySchedule;
			DES_set_key_unchecked(&keyEncrypt, &keySchedule);	

			memcpy(ivec, cbc_iv, sizeof(cbc_iv));

			unsigned char* outputText = new unsigned char[ciphertext.length()];
			memset(outputText, 0, ciphertext.length());

			const unsigned char* tmp = (const unsigned char*)ciphertext.c_str();

			DES_cfb_encrypt(tmp, outputText, 8, 32/*ciphertext.length() - 16*/, &keySchedule, &ivec, DES_DECRYPT);

			strClearText = (char*)outputText;

			delete [] outputText;
		}
		break;
	case TRIPLE_ECB:
		{
			DES_cblock ke1, ke2, ke3;
			memset(ke1, 0, 8);
			memset(ke2, 0, 8);
			memset(ke2, 0, 8);

			if (key.length() >= 24) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, 8);
			} else if (key.length() >= 16) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, key.length() - 16);
			} else if (key.length() >= 8) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, key.length() - 8);
				memcpy(ke3, key.c_str(), 8);
			} else {
				memcpy(ke1, key.c_str(), key.length());
				memcpy(ke2, key.c_str(), key.length());
				memcpy(ke3, key.c_str(), key.length());
			}

			DES_key_schedule ks1, ks2, ks3;
			DES_set_key_unchecked(&ke1, &ks1);
			DES_set_key_unchecked(&ke2, &ks2);
			DES_set_key_unchecked(&ke3, &ks3);

			const_DES_cblock inputText;
			DES_cblock outputText;
			vector<unsigned char> vecCleartext;
			unsigned char tmp[8];

			for (int i = 0; i < ciphertext.length() / 8; i ++) {
				memcpy(inputText, ciphertext.c_str() + i * 8, 8);
				DES_ecb3_encrypt(&inputText, &outputText, &ks1, &ks2, &ks3, DES_DECRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCleartext.push_back(tmp[j]);
			}

			if (ciphertext.length() % 8 != 0) {
				int tmp1 = ciphertext.length() / 8 * 8;
				int tmp2 = ciphertext.length() - tmp1;
				memset(inputText, 0, 8);
				memcpy(inputText, ciphertext.c_str() + tmp1, tmp2);

				DES_ecb3_encrypt(&inputText, &outputText, &ks1, &ks2, &ks3, DES_DECRYPT);
				memcpy(tmp, outputText, 8);

				for (int j = 0; j < 8; j++)
					vecCleartext.push_back(tmp[j]);
			}

			strClearText.clear();
			strClearText.assign(vecCleartext.begin(), vecCleartext.end());
		}
		break;
	case TRIPLE_CBC:
		{
			DES_cblock ke1, ke2, ke3, ivec;
			memset(ke1, 0, 8);
			memset(ke2, 0, 8);
			memset(ke2, 0, 8);

			if (key.length() >= 24) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, 8);
			} else if (key.length() >= 16) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, 8);
				memcpy(ke3, key.c_str() + 16, key.length() - 16);
			} else if (key.length() >= 8) {
				memcpy(ke1, key.c_str(), 8);
				memcpy(ke2, key.c_str() + 8, key.length() - 8);
				memcpy(ke3, key.c_str(), 8);
			} else {
				memcpy(ke1, key.c_str(), key.length());
				memcpy(ke2, key.c_str(), key.length());
				memcpy(ke3, key.c_str(), key.length());
			}

			DES_key_schedule ks1, ks2, ks3;
			DES_set_key_unchecked(&ke1, &ks1);
			DES_set_key_unchecked(&ke2, &ks2);
			DES_set_key_unchecked(&ke3, &ks3);

			memcpy(ivec, cbc_iv, sizeof(cbc_iv));

			int iLength = ciphertext.length() % 8 ? (ciphertext.length() / 8 + 1) * 8 : ciphertext.length();
			unsigned char* tmp = new unsigned char[iLength];
			memset(tmp, 0, iLength);

			DES_ede3_cbc_encrypt((const unsigned char*)ciphertext.c_str(), tmp, ciphertext.length()+1, &ks1, &ks2, &ks3, &ivec, DES_DECRYPT);

			strClearText = (char*)tmp;

			delete [] tmp;
		}
		break;
	}

	return strClearText;
}

3. main.cpp:

#include "stdafx.h"
#include "cryptotest.h"
#include <iostream>
#include <string>

using namespace std;

void test_DES()
{
	string cleartext = "中国北京12345$abcde%ABCDE@！！！!";
	string ciphertext = "";
	string key = "beijingchina1234567890ABCDEFGH!!!";

	CRYPTO_MODE mode = TRIPLE_CBC;

	ciphertext = DES_Encrypt(cleartext, key, mode);
	string decrypt = DES_Decrypt(ciphertext, key, mode);

	cout<<"src cleartext: "<<cleartext<<endl;
	cout<<"genarate ciphertext: "<<ciphertext<<endl;
	cout<<"src ciphertext: "<<ciphertext<<endl;
	cout<<"genarate cleartext: "<<decrypt<<endl;

	if (strcmp(cleartext.c_str(), decrypt.c_str()) == 0)
		cout<<"DES crypto ok!!!"<<endl;
	else
		cout<<"DES crypto error!!!"<<endl;
}


int main(int argc, char* argv[])
{
	test_DES();

	cout<<"ok!!!"<<endl;

	return 0;
}

GitHub： https://github.com/fengbingchun/OpenSSL_Test

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

OpenSSL中对称加密算法DES常用函数使用举例的相关文章

SBUS2 协议初探

SBUS2和SBUS的区别 1 xff1a 总线类型不一样 sbus是单向传输 xff0c 只做控制使用 xff0c 不做输入 SBUS2是非标准的双向总线 xff0c 可以做控制输出 xff0c 也可以做信息输入 2 xff1a 结束符不
IAR 中如何调用EmEditor

IAR 中如何调用EmEditor 文本编辑器我一直都用EmEditor Emeditor是一款很优秀的纯文本编辑器 xff0c 它对中日韩等亚洲字符集支持的很好 xff0c 不仅有语法高亮显示功能 xff0c 搜索替换功能也是近乎可爱的强
花了一下午，弄明白四个名词 USCI，USI，LIN，IrDa

最近在看MSP的程序 xff0c TI的官方例子程序 xff0c 有些名词看了却不知道什么意思 xff0c 本着穷根问底的态度 xff0c 上网搜索 xff0c 花了一下午 xff0c 弄明白四个名词 USCI xff0c USI xff0
Cadence 17.2学习笔记--显示元件丝印及元件标号的设置

快捷键Ctrl 43 F5 调出Color Dialog 左侧菜单第三项Geometry选项钩选图中Silkscreen Top或Silkscreen Bottom可打开或关闭元件外形丝印的显示同样Color Dialog对话框左侧菜
【Android UI】色板

Hex CodeColor FFFFFF FFFFCC FFFF99 FFFF66 FFFF33 FFFF00 FFCCFF FFCCCC FFCC99 FFCC66 FFCC33 FFCC00 FF99FF FF99CC FF9999 F
对称加密算法AES简介及在OpenSSL中使用举例

高级加密标准 AES Advanced Encryption Standard 由美国国家标准和技术协会 NIST 于2000年公布 xff0c 它是一种对称加密算法 xff0c 用来替代DES AES也称为Rijndael算法 xff0c
基于Hash的消息认证码HMAC简介及在OpenSSL中使用举例

HMAC Hash based Message Authentication Code xff1a 基于Hash的消息认证码 xff0c 是一种通过特别计算方式之后产生的消息认证码 MAC xff0c 使用密码散列函数 xff0c 同时结合
在Windows和Linux上编译gRPC源码操作步骤(C++)

gRPC最新发布版本为v1 23 0 xff0c 下面以此版本为例说明在Windows和Linux下编译过程 Windows7 10 vs2103编译gRPC源码操作步骤 xff1a 1 需要本机已安装Git CMake Perl Go y
gRPC简介及简单使用(C++)

gRPC是一个现代的开源的高性能远程过程调用 RPC 框架 xff0c 可以在任何平台运行 gRPC使客户端和服务器端应用程序能够透明地进行通信 xff0c 并简化了连接系统的构建 gRPC支持的语言包括C 43 43 Ruby Pyt
C语言中select函数简介及使用

select函数用来检查套接字描述符 sockets descriptors 是否已准备好读写 xff0c 提供了一种同时检查多个套接字的方法 Linux中select函数的声明在 usr include x86 64 linux gnu
VS Code离线安装C/C++插件cpptools-linux-aarch64.vsix

一问题最近VS Code连接jetson nano xff0c 经常提示加载C C 43 43 插件失败二解决方法根据提示 xff0c 在githup上 https github com microsoft vscode cppt
开源库BearSSL介绍及使用

BearSSL是用C语言实现的SSL TLS协议 xff0c 它的源码可直接通过git clone https www bearssl org git BearSSL 下载 xff0c 它的license是MIT xff0c 最新版本为0
对称加密算法AES之GCM模式简介及在OpenSSL中使用举例

AES Advanced Encryption Standard 即高级加密标准 xff0c 由美国国家标准和技术协会 NIST 于2000年公布 xff0c 它是一种对称加密算法关于AES的更多介绍可以参考 xff1a https bl
ASN.1简介及OpenSSL中ASN.1接口使用举例

ASN 1 Abstract Syntax Notation One 是一套标准 xff0c 是描述数据的表示编码传输解码的灵活的记法它提供了一套正式无歧义和精确的规则以描述独立于特定计算机硬件的对象结构 OpenSSL的编码方法就
从openssl rsa pem文件中提取公私钥数据实现

RSA为非对称加密算法 xff0c 关于其介绍可以参考 xff1a https blog csdn net fengbingchun article details 43638013 OpenSSL最新版为 1 1 1g xff0c 在Wi
通过OpenSSL的接口实现Base64编解码

对openssl genrsa产生的rsa私钥pem文件 xff0c 使用普通的base64解码会有问题 xff0c 如使用https blog csdn net fengbingchun article details 85218653
JWT(JSON Web Token)简介及实现

JWT JSON Web Token xff1a 是一个开放标准 RFC 7519 xff0c 它定义了一种紧凑且自包含的方式 xff0c 用于在各方之间作为Json对象安全地传输信息由于此信息是经过数字签名的 xff0c 因此可以被验证
SSL/TLS单向认证和双向认证介绍

为了便于理解SSL TLS的单向认证和双向认证执行流程 xff0c 这里先介绍一些术语 1 散列函数 Hash function xff1a 又称散列算法哈希函数 xff0c 是一种从任何一种数据中创建小的数字指纹的方法散列函数把消
使用OpenSSL生成自签名证书相关命令

在用于小范围测试等目的的时候 xff0c 用户也可以自己生成数字证书 xff0c 但没有任何可信赖的机构签名 xff0c 此类数字证书称为自签名证书证书一般采用X 509标准格式下面通过OpenSSL相关命令介绍如何生成自签证书 1 生
Windows/Linux TCP Socket网络编程简介及测试代码

典型的网络应用是由一对程序即客户程序和服务器程序组成的 xff0c 它们位于两个不同的端系统中当运行这两个程序时 xff0c 创建了一个客户进程和一个服务器进程 xff0c 同时它们通过从套接字 socket 读出和写入数据在彼此之间

随机推荐

基于BearSSL实现自签名证书双向认证测试代码

客户端服务器端双向认证大致过程 xff1a 可以参考 xff1a https blog csdn net fengbingchun article details 106856332 1 客户端发起连接请求 xff1b 2 服务器端返回消
C:\KEIL\C51\intrins.h包含不正确的路径。Keil 头文件路径错误

步骤1 xff1a 先检查工程中的 include intrins h include stdio h xff0c 各文件之间是否正确调用步骤2 xff1a 将 include lt intrins h gt lt reg52 h gt
分享一个Centos8的国内yum源

使用的是阿里巴巴开源镜像站 xff0c 文件地址 xff1a https span class token punctuation span span class token operator span span class token o
网络数据包分析软件Wireshark简介

Wireshark是被广泛使用的免费开源的网络协议分析软件 network protocol analyzer 或网络数据包分析软件 xff0c 它可以让你在微观层面上查看网络上发生的事情 xff0c 它的功能是截取网络数据包 xff0c
HTTP请求方法介绍

之前在https blog csdn net fengbingchun article details 85039308 中介绍过HTTP协议 xff0c 在https blog csdn net fengbingchun article
TCP Flags标志位介绍

传输控制协议 Transmission Control Protocol xff0c TCP 是一种传输层协议 TCP使数据包从源到目的地的传输更加顺畅它是一种面向连接的端到端协议每个数据包由TCP包裹在一个报头中 xff0c 该报头由
代理服务器简介及libcurl测试

代理服务器英文全称是Proxy Server xff0c 其功能就是将局域网用户连接到Internet xff0c 代理网络用户去获得网络信息形象地说 xff0c 它是网络信息的中转站 xff0c 是连接内部局域网和Internet的一种
CMake中find_package的使用

CMake中的命令find package用于查找指定的package find package支持两种主要的搜索方法 xff1a 注意 xff1a lt PackageName gt 是区分大小写的 1 Config mode 配置模式
CMake中link_directories/target_link_directories的使用

CMake中的link directories命令用于添加目录使链接器能在其查找库 add directories in which the linker will look for libraries xff0c 其格式如下 xff1a
UDP协议在Windows上使用示例

UDP User Datagram Protocol xff0c 用户数据报协议是无连接的 xff0c 因此在两个进程通信前没有握手过程 UDP协议提供一种不可靠数据传送服务 xff0c 也就是说 xff0c 当进程将一个报文发送进UDP
代码覆盖率工具OpenCppCoverage在Windows上的使用

OpenCppCoverage是用在Windows C 43 43 上的开源的代码覆盖率工具 xff0c 源码地址为https github com OpenCppCoverage OpenCppCoverage xff0c 最新发布版本为
nerfstudio介绍及在windows上的配置、使用

nerfstudio提供了一个简单的API xff0c 可以简化创建训练和可视化NeRF的端到端过程该库通过模块化每个组件来支持可解释的NeRF实现 nerfstudio源码地址 https github com nerfstudio
Qt中QDebug的使用

QDebug类为调试信息 debugging information 提供输出流它的声明在 lt QDebug gt 中 xff0c 实现在Core模块中将调试或跟踪信息 debugging or tracing information
OkHttpUtil

package com example someutil util import com google gson Gson import java util Iterator import java util Map import java
Sourcetree介绍及使用

Sourcetree是一个操作简单但功能强大的免费Git客户端管理工具 xff0c 可应用在Windows和Mac平台 Sourcetree的安装 xff1a 1 从Sourcetree Free Git GUI for Mac and W
C++14中lambda表达式新增加的features的使用

lambda表达式是在C 43 43 11中引入的 xff0c 它们可以嵌套在其它函数甚至函数调用语句中 xff0c C 43 43 11中lambda表达式的使用参考 xff1a https blog csdn net fengbingc
OpenSSL简介及在Windows、Linux、Mac系统上的编译步骤

OpenSSL介绍 xff1a OpenSSL是一个强大的安全套接字层密码库 xff0c 囊括主要的密码算法常用的密钥和证书封装管理功能及SSL协议 xff0c 并提供丰富的应用程序供测试或其它目的使用 SSL是SecureSockets
信息安全领域相关术语介绍

一 SSL 安全套接字层 SSL Secure Sockets Layer 是一种协议 xff0c 支持服务通过网络进行通信而不损害安全性它在客户端和服务器之间创建一个安全连接然后通过该连接安全地发送任意数据量 SSL最初是用来保障数据
对称加密算法之DES介绍

DES Data Encryption Standard 是分组对称密码算法 DES采用了64位的分组长度和56位的密钥长度 xff0c 它将64位的输入经过一系列变换得到64位的输出解密则使用了相同的步骤和相同的密钥 DES的密钥长度为
OpenSSL中对称加密算法DES常用函数使用举例

主要包括3个文件 xff1a 1 cryptotest h ifndef CRYPTOTEST H define CRYPTOTEST H include lt string gt using namespace std typedef e

OpenSSL中对称加密算法DES常用函数使用举例

OpenSSL中对称加密算法DES常用函数使用举例 的相关文章

随机推荐

热门标签

OpenSSL中对称加密算法DES常用函数使用举例的相关文章