C++ 信息系统框架集成第三方产品

最新推荐文章于 2023-12-04 06:00:00 发布
最新推荐文章于 2023-12-04 06:00:00 发布
阅读量356 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ai_King/article/details/104078102
版权

模拟公司信息系统框架继承第三方产品

头文件

CSocketProtocol.h

#pragma once
#include <iostream>
using namespace std;

class CSoketProtocl
{
public:
	CSoketProtocl()
	{
		;
	}
	virtual ~CSoketProtocl()
	{
		;
	}

	//客户端初始化 获取handle
	virtual int cltSoketInit(/*out*/) = 0;

	//客户端发报文
	virtual int cltSoketSend(unsigned char* buf/*in*/, int buflen/*in*/) = 0;

	//客户端收报文
	virtual int cltSoketRev(unsigned char* buf/*in*/, int* buflen/*in out*/) = 0;

	//客户端释放资源
	virtual int cltSoketDestroy() = 0;

};

CSckFactoryImp1.h

#pragma once
#include "CSocketProtocol.h"

class CSckFactoryImp1 :public CSoketProtocl
{
public:
	//客户端初始化 获取handle
	virtual int cltSoketInit(/*out*/);

	//客户端发报文
	virtual int cltSoketSend(unsigned char* buf/*in*/, int buflen/*in*/);

	//客户端收报文
	virtual int cltSoketRev(unsigned char* buf/*in*/, int* buflen/*in out*/);

	//客户端释放资源
	virtual int cltSoketDestroy();

private:
	unsigned char* p;
	int len;
};

DES.h （用于Des加密解密）

#ifndef _DES_H_
#define _DES_H_

#include <string>

#define BITS_PER_CHAR 8
#define KEY_SZIE 8
#define SUBKEY_NUM 16
#define SUBKEY_LENGHT 48
#define EXPAND_SIZE 48
#define PC_2_SIZE 48
#define PC_1_SIZE 56
#define BIT_STR_SIZE 64

class DES
{
public:
	DES();
	~DES();

	//加密
	int Encrypt(unsigned char* plain, int plainlen, unsigned char* cipher, int* cipherlen, const std::string& key);
	//解密
	int Decrypt(unsigned char* cipher, int cipherlen, unsigned char* plain, int* plainlen, const std::string& key);

private:
	//生成16个子秘钥
	bool CreateSubKey(const std::string& key, char subKey[SUBKEY_NUM][SUBKEY_LENGHT]);

	//加密8字节数据块
	bool EncryptBlock(std::string& block, char subKey[SUBKEY_NUM][SUBKEY_LENGHT]);
	//解密8字节数据块
	bool DecryptBlock(std::string& block, char subKey[SUBKEY_NUM][SUBKEY_LENGHT]);


private:
	//----------------------------------转换工具-----------------------------------------------
	bool PC1_Transform(const std::string& bitStr, std::string& PC1BitStr);

	bool PC2_Transform(const std::string& PC1BitStr, char subKey[SUBKEY_LENGHT]);

	bool IP_Transform(std::string& bitStr);

	bool Expand_Transform(const std::string& halfBitStr, std::string& eBitStr);

	bool SBox_Transform(const std::string& eBitStr, std::string& halfBitStr);

	bool Permute_Transform(std::string& halfBitStr);

	bool IP_1_Transform(std::string& bitStr);

private:
	//------------------------------------基础工具------------------------------------------------
	bool Char8ToBit64(const std::string& str, std::string& bitStr);
	bool Bit64ToChar8(const std::string& bitStr, std::string& str);

	bool XOR(std::string& strFirst, std::string& strSecond, size_t num);

	bool LeftCycle(std::string& str, size_t beginSection, size_t endSection, size_t step);

private:
	//------------------------------------生成秘钥需要的表----------------------------------------
	//置换选择表1
	//压缩换位去掉每个字节的第8位，用作奇偶校检，基本上第8位可忽略
	static char PC1_Table[PC_1_SIZE];
	//左循环距离表
	static char Move_Table[SUBKEY_NUM];
	//置换选择表2
	//选择其中的某些位将其减少到48位
	static char PC2_Table[PC_2_SIZE];


	//----------------------------------加密或解密需要的表--------------------------------------------
	//初始置换表
	//表中的数值表示输入为被置换后的新位置
	static char IP_Table[BIT_STR_SIZE];
	//扩展表
	//通过重复某些位将32位的右半部分按照表扩展成48位
	static char Expand_Table[EXPAND_SIZE];
	//单纯置换表
	static char Permute_Table[BIT_STR_SIZE / 2];
	//反置换表
	static char IP_1_Table[BIT_STR_SIZE];
	//置换盒
	static char SBox_Table[KEY_SZIE][4][16];
};

#endif

CEncDesProtocol.h

#pragma once
class CEncDesProtocol
{
public:
	CEncDesProtocol()
	{
	}

	virtual ~CEncDesProtocol()
	{
	}
	virtual int EncData(unsigned char* plain, int plainlen, unsigned char* cryptdata, int* cryptlen) = 0;
	virtual int DecData(unsigned char* cryptdata, int cryptlen, unsigned char* plain, int* plainlen) = 0;

};

HwEncDec.h

#pragma once
#include <iostream>
#include "CEncDesProtocol.h"
using namespace std;

class HwEncDec :public CEncDesProtocol
{
public:
	virtual int EncData(unsigned char* plain, int plainlen, unsigned char* cryptdata, int* cryptlen);
	virtual int DecData(unsigned char* cryptdata, int cryptlen, unsigned char* plain, int* plainlen);

};

源文件

CSckFactoryImp1.cpp

#include "CSckFactoryImp1.h"

//客户端初始化 获取handle
int CSckFactoryImp1::cltSoketInit(/*out*/)
{
	p = NULL;
	len = 0;
	return 0;
}

//客户端发报文
int CSckFactoryImp1::cltSoketSend(unsigned char* buf/*in*/, int buflen/*in*/)
{
	p = new unsigned char[buflen];
	if (p == NULL)
	{
		return -1;
	}
	memcpy(p, buf, buflen);
	len = buflen;
	return 0;
}

//客户端收报文
int CSckFactoryImp1::cltSoketRev(unsigned char* buf/*in*/, int* buflen/*in out*/)
{
	if (buf == NULL || buflen == NULL)
	{
		return -1;
	}

	*buflen = this->len;
	memcpy(buf, this->p, this->len);
	return 0;
}

//客户端释放资源
int CSckFactoryImp1::cltSoketDestroy()
{
	if (p != NULL)
	{
		delete[] p;
		p = NULL;
		len = 0;
	}
	return 0;
}

DES.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "DES.h"


//------------------------------------生成秘钥需要的表----------------------------------------

char DES::PC1_Table[PC_1_SIZE] = {
						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 };

char DES::Move_Table[SUBKEY_NUM] = { 23,10,2,5,9,2,3,2,3,2,5,7,2,9,2,7 };

char DES::PC2_Table[PC_2_SIZE] = {
						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,46,43,48,38,55,
						33,52,45,41,49,35,28,31 };


//----------------------------------加密或解密需要的表--------------------------------------------

char DES::IP_Table[BIT_STR_SIZE] = {
						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,
						56,48,40,32,24,16,8,0,
						58,50,42,34,26,18,10,2,
						60,52,44,36,28,20,12,4,
						62,54,46,38,30,22,14,6 };

char DES::Expand_Table[EXPAND_SIZE] = {
						31, 0, 1, 2, 3, 4,
						3,  4, 5, 6, 7, 8,
						7,  8, 9,10,11,12,
						11,12,13,14,15,16,
						15,16,17,18,19,20,
						19,20,21,22,23,24,
						23,24,25,26,27,28,
						27,28,29,30,31, 0 };

char DES::Permute_Table[BIT_STR_SIZE / 2] = {
						15, 6,19,20,28,11,27,16,
						0,14,22,25, 4,17,30, 9,
						1, 7,23,13,31,26, 2, 8,
						18,12,29, 5,21,10, 3,24 };

char DES::IP_1_Table[BIT_STR_SIZE] = {
						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,0,40,8,48,16,56,24 };

char DES::SBox_Table[KEY_SZIE][4][16] = {
	//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}} };

DES::DES() {}

DES::~DES() {}


int DES::Encrypt(unsigned char* plain, int plainlen, unsigned char* cipher, int* cipherlen, const std::string& key)
{
	std::string result;
	if (plain == NULL || key.empty())
		return -1;

	char subKey[16][48];
	if (!CreateSubKey(key, subKey))
		return -1;

	std::string s1((char*)plain, plainlen);
	for (size_t i = 0; i < s1.size() / 8; ++i)
	{
		std::string block = s1.substr(i * 8, 8);
		EncryptBlock(block, subKey);
		result.append(block);
	}
	int remainder = s1.size() % 8;
	if (remainder)
	{
		std::string block = s1.substr(s1.size() - remainder, remainder);
		block.append(8 - remainder, '\0');
		EncryptBlock(block, subKey);
		result.append(block);
	}

	*cipherlen = (int)result.size();
	cipher = new unsigned char[*cipherlen];
	strcpy((char*)cipher, result.c_str());
	(unsigned char*)cipher;
	return 0;
}

int DES::Decrypt(unsigned char* cipher, int cipherlen, unsigned char* plain, int* plainlen, const std::string& key)
{
	std::string result;
	if (cipher == NULL || plain == NULL || plainlen == NULL || key.empty())
		return -2;
	
	if (sizeof(cipher) % 8)
		return -3;

	char subKey[16][48];
	CreateSubKey(key, subKey);

	std::string s2((char*)cipher);
	for (size_t i = 0; i < s2.size() / 8; ++i)
	{
		std::string block = s2.substr(i * 8, 8);
		DecryptBlock(block, subKey);
		result.append(block);
	}

	*plainlen = result.size();
	plain = new unsigned char[*plainlen];
	strcpy((char*)plain, result.c_str());
	(unsigned char*)plain;
	return 0;
}


bool DES::EncryptBlock(std::string& block, char subKey[SUBKEY_NUM][SUBKEY_LENGHT])
{
	if (block.size() != KEY_SZIE)
		return false;

	std::string bitStr;
	bitStr.resize(BIT_STR_SIZE);
	Char8ToBit64(block, bitStr);

	IP_Transform(bitStr);

	std::string halfBitStr;
	halfBitStr.resize(bitStr.size() / 2);
	std::string eBitStr;
	eBitStr.resize(EXPAND_SIZE);
	for (size_t i = 0; i < SUBKEY_NUM; ++i)
	{
		Expand_Transform(bitStr.substr(bitStr.size() / 2), eBitStr);

		std::string s2(subKey[i], SUBKEY_LENGHT);
		XOR(eBitStr, s2, SUBKEY_LENGHT);

		SBox_Transform(eBitStr, halfBitStr);

		Permute_Transform(halfBitStr);

		XOR(bitStr, halfBitStr, halfBitStr.size());

		if (i != SUBKEY_NUM - 1)
			LeftCycle(bitStr, 0, bitStr.size(), bitStr.size() / 2);
	}
	IP_1_Transform(bitStr);

	Bit64ToChar8(bitStr, block);

	return true;
}

bool DES::DecryptBlock(std::string& block, char subKey[SUBKEY_NUM][SUBKEY_LENGHT])
{
	if (block.size() != KEY_SZIE)
		return false;

	std::string bitStr;
	bitStr.resize(BIT_STR_SIZE);
	Char8ToBit64(block, bitStr);

	IP_Transform(bitStr);

	std::string halfBitStr;
	halfBitStr.resize(bitStr.size() / 2);
	std::string eBitStr;
	eBitStr.resize(EXPAND_SIZE);
	for (int i = SUBKEY_NUM - 1; i >= 0; --i)
	{
		Expand_Transform(bitStr.substr(bitStr.size() / 2), eBitStr);
		std::string s1(subKey[i], SUBKEY_LENGHT);
		XOR(eBitStr, s1, SUBKEY_LENGHT);

		SBox_Transform(eBitStr, halfBitStr);
		Permute_Transform(halfBitStr);

		XOR(bitStr, halfBitStr, halfBitStr.size());

		if (i != 0)
			LeftCycle(bitStr, 0, bitStr.size(), bitStr.size() / 2);
	}
	IP_1_Transform(bitStr);
	Bit64ToChar8(bitStr, block);

	return true;
}



bool DES::CreateSubKey(const std::string& key, char subKey[SUBKEY_NUM][SUBKEY_LENGHT])
{
	std::string tmpKey(key);
	if (tmpKey.size() < KEY_SZIE)
		tmpKey.append(KEY_SZIE - tmpKey.size(), '\0');
	else if (tmpKey.size() > KEY_SZIE)
		tmpKey = tmpKey.substr(0, KEY_SZIE);

	std::string bitStr;
	bitStr.resize(BIT_STR_SIZE);//64
	Char8ToBit64(tmpKey, bitStr);

	std::string PC1BitStr;
	PC1BitStr.resize(PC_1_SIZE);//56
	if (!PC1_Transform(bitStr, PC1BitStr))
		return false;

	for (int i = 0; i < SUBKEY_NUM; ++i)
	{
		LeftCycle(PC1BitStr, 0, PC_1_SIZE / 2, Move_Table[i]);
		LeftCycle(PC1BitStr, PC_1_SIZE / 2, PC_1_SIZE, Move_Table[i]);

		PC2_Transform(PC1BitStr, subKey[i]); // 48
	}

	return true;
}


//-------------------------------------------------------------------------------------转换工具-----------------------------------------------

bool DES::PC1_Transform(const std::string& bitStr, std::string& PC1BitStr)
{
	if (bitStr.size() != BIT_STR_SIZE || PC1BitStr.size() != PC_1_SIZE)
		return false;

	for (size_t i = 0; i < PC1BitStr.size(); ++i)
		PC1BitStr[i] = bitStr[PC1_Table[i]];

	return true;
}

bool DES::PC2_Transform(const std::string& PC1BitStr, char subKey[SUBKEY_LENGHT])
{
	if (PC1BitStr.size() != PC_1_SIZE)
		return false;

	for (size_t i = 0; i < PC_2_SIZE; ++i)
		subKey[i] = PC1BitStr[PC2_Table[i]];

	return true;
}


bool DES::IP_Transform(std::string& bitStr)
{
	if (bitStr.size() != BIT_STR_SIZE)
		return false;

	std::string tmpBitStr;
	tmpBitStr.resize(bitStr.size());
	for (size_t i = 0; i < bitStr.size(); ++i)
		tmpBitStr[i] = bitStr[IP_Table[i]];

	bitStr.swap(tmpBitStr);

	return true;
}

bool DES::Expand_Transform(const std::string& halfBitStr, std::string& eBitStr)
{
	if (halfBitStr.size() != BIT_STR_SIZE / 2 || eBitStr.size() != EXPAND_SIZE)
		return false;

	for (size_t i = 0; i < eBitStr.size(); ++i)
		eBitStr[i] = halfBitStr[Expand_Table[i]];

	return true;
}

bool DES::SBox_Transform(const std::string& eBitStr, std::string& halfBitStr)
{
	if (eBitStr.size() != EXPAND_SIZE || halfBitStr.size() != BIT_STR_SIZE / 2)
		return false;

	for (size_t i = 0; i < KEY_SZIE; ++i)
	{
		size_t j = i * 6;
		size_t row = (eBitStr[j] << 1) + eBitStr[j + eBitStr.size() / KEY_SZIE - 1];
		size_t column = (eBitStr[j + 1] << 3) + (eBitStr[j + 2] << 2) + (eBitStr[j + 3] << 1) + eBitStr[j + 4];

		int x = SBox_Table[i][row][column];


		halfBitStr[i * 4] = x >> 3;
		halfBitStr[i * 4 + 1] = (x >> 2) & 0x1;
		halfBitStr[i * 4 + 2] = (x >> 1) & 0x1;
		halfBitStr[i * 4 + 3] = x & 0x1;

	}
	return true;
}

bool DES::Permute_Transform(std::string& halfBitStr)
{
	if (halfBitStr.size() != BIT_STR_SIZE / 2)
		return false;

	std::string tmpStr;
	tmpStr.resize(halfBitStr.size());

	for (size_t i = 0; i < halfBitStr.size(); ++i)
		tmpStr[i] = halfBitStr[Permute_Table[i]];

	halfBitStr.swap(tmpStr);

	return true;
}

bool DES::IP_1_Transform(std::string& bitStr)
{
	if (bitStr.size() != BIT_STR_SIZE)
		return false;

	std::string tmpStr;
	tmpStr.resize(BIT_STR_SIZE);
	for (size_t i = 0; i < bitStr.size(); ++i)
		tmpStr[i] = bitStr[IP_1_Table[i]];

	bitStr.swap(tmpStr);

	return true;
}


//-------------------------------------------------------------------------------------基础工具------------------------------------------------

bool DES::Char8ToBit64(const std::string& str, std::string& bitStr)
{
	if (str.size() != KEY_SZIE || bitStr.size() != BIT_STR_SIZE)
		return false;

	for (size_t i = 0; i < str.size(); ++i)
	{
		for (size_t j = 0; j < BITS_PER_CHAR; ++j)
			bitStr[i * BITS_PER_CHAR + j] = (str[i] >> j) & 0x1;
	}
	return true;
}

bool DES::Bit64ToChar8(const std::string& bitStr, std::string& str)
{
	if (bitStr.size() < BIT_STR_SIZE || str.size() != KEY_SZIE)
		return false;

	str = "";
	str.resize(KEY_SZIE);

	for (size_t i = 0; i < KEY_SZIE; ++i)
	{
		for (size_t j = 0; j < BITS_PER_CHAR; ++j)
			str[i] |= bitStr[i * KEY_SZIE + j] << j;
	}

	return true;
}

bool DES::LeftCycle(std::string& str, size_t beginSection, size_t endSection, size_t step)
{
	if (endSection > str.size())
		return false;

	size_t tmpStep = step % (endSection - beginSection);
	std::string tmpStr = str.substr(beginSection + tmpStep, endSection - beginSection - tmpStep);

	tmpStr.append(str.substr(beginSection, tmpStep));

	for (size_t i = beginSection; i < endSection; ++i)
		str[i] = tmpStr[i - beginSection];

	return true;
}

bool DES::XOR(std::string& strFirst, std::string& strSecond, size_t num)
{
	if (strFirst.size() < num || strSecond.size() < num)
		return false;

	for (size_t i = 0; i < num; ++i)
		strFirst[i] ^= strSecond[i];

	return true;
}

HwEncDec.cpp

#pragma once
#include <iostream>
#include "HwEncDec.h"
#include "DES.h"

using namespace std;

//

int HwEncDec::EncData(unsigned char* plain, int plainlen, unsigned char* cryptdata, int* cryptlen)
{
	int ret = 0;
	std::string s1((char*)plain);
	std::string key = "19970505";
	DES p;

	//加密
	ret = p.Encrypt(plain, plainlen, cryptdata, cryptlen, key);
	if (ret != 0)
	{
		cout << "Encrypt() err:" << ret << endl;
		return ret;
	}
	return ret;
}

int HwEncDec::DecData(unsigned char* cryptdata, int cryptlen, unsigned char* plain, int* plainlen)
{
	int ret = 0;
	std::string s1((char*)plain);
	std::string key = "19970505";
	DES p;

	//解密
	ret = p.Decrypt(cryptdata, cryptlen, plain, plainlen, key);
	if (ret != 0)
	{
		cout << "HwEncDec Encrypt() err:" << ret << endl;
		return ret;
	}
	return ret;
}

mainclass03.cpp (框架类)

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include "CSocketProtocol.h"
#include "CSckFactoryImp1.h"
#include "CSckFactoryImp2.h"
#include "HwEncDec.h"
using namespace std;

class MainOp
{
public:
	MainOp()
	{
		sp = NULL;
		ed = NULL;
	}
	MainOp(CSoketProtocl* sp, CEncDesProtocol* ed)
	{
		this->sp = sp;
		this->ed = ed;
	}

	void setSP(CSoketProtocl* sp)
	{
		this->sp = sp;
	}

	void setED(CEncDesProtocol* ed)
	{
		this->ed = ed;
	}

	int SckSendAndRec_EncDec3(CSoketProtocl* sp, CEncDesProtocol* ed, unsigned char* in, int inlen, unsigned char* out, int* outlen);
	int SckSendAndRec_EncDec3(unsigned char* in, int inlen, unsigned char* out, int* outlen);
private:
	CSoketProtocl* sp;
	CEncDesProtocol* ed;
};

//面向抽象类编程，框架实现完毕
int MainOp::SckSendAndRec_EncDec3(CSoketProtocl* sp, CEncDesProtocol* ed, unsigned char* in, int inlen, unsigned char* out, int* outlen)
{
	int ret = 0;
	unsigned char data[4096];
	int datalen = 0;

	ret = sp->cltSoketInit();
	if (ret != 0)
	{
		goto End;
	}

	ret = ed->EncData(in, inlen, data, &datalen);
	if (ret != 0)
	{
		goto End;
	}

	ret = sp->cltSoketSend(data, datalen);//发送加密数据
	if (ret != 0)
	{
		goto End;
	}

	ret = sp->cltSoketRev(data, &datalen);//接收密文
	if (ret != 0)
	{
		goto End;
	}

	ret = ed->DecData(data, datalen, out, outlen);
	if (ret != 0)
	{
		goto End;
	}

End:
	ret = sp->cltSoketDestroy();

	return 0;
}

int MainOp::SckSendAndRec_EncDec3(unsigned char* in, int inlen, unsigned char* out, int* outlen)
{
	int ret = 0;
	unsigned char data[4096];
	int datalen = 0;

	ret = this->sp->cltSoketInit();
	if (ret != 0)
	{
		goto End;
	}

	ret = this->ed->EncData(in, inlen, data, &datalen);
	if (ret != 0)
	{
		goto End;
	}

	ret = this->sp->cltSoketSend(data, datalen);//发送加密数据
	if (ret != 0)
	{
		goto End;
	}

	ret = this->sp->cltSoketRev(data, &datalen);//接收密文
	if (ret != 0)
	{
		goto End;
	}

	ret = this->ed->DecData(data, datalen, out, outlen);
	if (ret != 0)
	{
		goto End;
	}

End:
	ret = this->sp->cltSoketDestroy();

	return 0;
}

int main()
{
	int ret = 0;
	unsigned char in[4096];
	int inlen;
	unsigned char out[4096];
	int outlen = 0, outlen2 = 0;

	strcpy((char*)in, "I am the best one!");
	inlen = (const int)strlen((char*)in);

	MainOp* myMainOp = new MainOp;

	CSoketProtocl* sp = NULL;
	CEncDesProtocol* ed = NULL;

	sp = new CSckFactoryImp1;
	ed = new HwEncDec;

	myMainOp->setSP(sp);//注入框架
	myMainOp->setED(ed);

	ret = myMainOp->SckSendAndRec_EncDec3(in, inlen, out, &outlen);
	if (ret != 0)
	{
		cout << "SckSendAndRec() err:" << ret << endl;
	}

	delete ed;
	delete sp;
	delete myMainOp;

	return 0;
}
banjitino
关注
专栏目录
C/C++框架和第三方库汇总
编程与实战的博客
07-12 4506
根据读者反馈，发现此篇汇总获赞率异常的高，为了照顾一下新加入的粉丝，故重新发一遍，供粉丝查阅温习。值得学习的C语言开源项目- 1. WebbenchWebbench是一个在linux下使用...
【QT开发教程】Qt与第三方库的集成技巧
最新发布
科技改变人类，技术成就未来
08-22 1103
在现代应用程序开发中，集成第三方库可以显著提高开发效率和功能丰富性。Qt作为一个强大的C++框架，提供了多种方式来集成第三方库。本文将详细介绍如何在Qt中集成第三方库，并提供一些实用的示例代码。
企业信息系统集成框架（设计思路）C++模式
weixin_34009794的博客
08-04 158
设计要求： 1.企业信息系统框架、第三方产品通过接口层进行分层。 2.企业信息系统框架如何自由的继承第三方产品：通过一个抽象类。（软件设计要求：模块要求松，接口要求紧）。 设计步骤： 1.报文的接受与发送抽象类； 　　C++与C语言设计区别：C语言中有个句柄，原因是需要分配一个结构体资源，把发送和接受的信息存储起来。而C++中由于有类的存在，可以直接将这个句柄内容存储在子类中，不...
多态案例：C++信息系统框架集成第三方产品
weixin_44457930的博客
02-24 414
C++教程综合练习
socket库C++模型设计和实现--企业信息系统框架集成第三方产品案例
Bixiwen_liu的博客
07-25 1249
本文主要介绍C++面向对象编程的一个综合示例：socket库C++模型设计和实现--企业信息系统框架集成第三方产品案例。下面是示例的主要内容介绍。
【c++随笔15】c++常用第三方库
junxuezheng的博客
12-04 1895
一、数据库相关：HDFS、libpq、SQLite、RocksDB、unixODBC、Nanobdc、Ignite; 二、网络通信相关： libcurl、libevent、libssh、mosquitto、nghttp2、libuv； 三、加密和安全相关： 1、OpenSSL四、序列化和数据格式相关： Protobuf、json(nlohmann)、Rapidjson、pugixml、Xlnt、Yamlcpp、Libxl:五、压缩compress\Minilzo、Snappy、zlib；
著名的C/C++框架和第三方库（转载）
疯狂挖掘机的博客
04-08 783
转载地址：https://blog.csdn.net/zz861126/article/details/80408470  值得学习的C语言开源项目 - 1. Webbench Webbench是一个在linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力下工作的性能，最多可以模拟3万个并发连接去测试网站的负载能力。Webbench使用C语言编写, 代码实在太简洁，源码加起来不到600行。 下载链接：http://home.tisca
著名的C/C++框架和第三方库
FY_2018的博客
02-02 1083
值得学习的C语言开源项目 - 1. Webbench Webbench是一个在linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力下工作的性能，最多可以模拟3万个并发连接去测试网站的负载能力。Webbench使用C语言编写, 代码实在太简洁，源码加起来不到600行。 下载链接：http://home.tiscali.cz/~cz2...
史上最全的常用iOS的第三方框架
热门推荐
sky_2016的专栏
05-05 3万+
图像： 1.图片浏览控件MWPhotoBrowser        实现了一个照片浏览器类似 iOS 自带的相册应用，可显示来自手机的图片或者是网络图片，可自动从网络下载图片并进行缓存。可对图片进行缩放等操作。       下载：https://github.com/mwaterfall/MWPhotoBrowser 目前比较活跃的社区仍旧是Github，除此以外也有一
C++ 信息系统框架集成第三方产品案例程序源码
08-20
传智博客 C++ 信息系统框架集成第三方产品案例程序源码
C++编程 信息系统框架集成第三方案例
05-10
本案例的"信息系统框架集成第三方案例"可能包含一个或多个以上提到的实践操作，通过逐步讲解从基础编写到链接编译调试的过程，帮助学习者理解并掌握C++在系统框架集成中的应用。通过实际的代码示例和运行测试，将...
基于C++ Workflow的RPC框架
01-26
- **编解码器**：C++ Workflow库可能不直接提供编解码功能，但可以通过集成第三方库如Protobuf、JSON等来实现消息的序列化和反序列化。这样可以确保请求和响应在不同系统间正确传递。 4. **性能优化**： C++ ...
C++ 纯虚函数的简单实现
Ai_King的博客
01-22 3895
纯虚函数的简单实现 纯虚函数是一个在基类中说明的虚函数，在基类中没有定义，要求任何派生类都定义自己的版本 纯虚函数为个派生类提供一个公共界面（接口的封装和设计、软件的模块功能划分） 含有纯虚函数的类，称为抽象基类，不可实列化。即不能创建对象，存在的意义就是被继承，提供族类的公共接口。 纯虚函数只有声明，没有实现，被“初始化”为0。 如果一个类中声明了纯虚函数，而在派生类中没有对该函数定义，则该...
C++ 和 C 的关系、区别
Ai_King的博客
01-16 2920
1. C++对C语言的加强 1. namespace命名空间 1）当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std,需要这样做。std::cout。 2）c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。 3） C++命名空间的定义： n...
C++ 采用顺序栈的回文判断
Ai_King的博客
11-02 2476
采用顺序栈的回文判断 栈是一种后进先出（LIFO）的线性表，限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 下面给出顺序栈的操作实现 顺序栈 //SqStack.h #pragm...
C++ 抽象类实现计算雇员工资
Ai_King的博客
01-24 2130
抽象类实现计算雇员工资 公司有三类雇员：管理员：Manger（按月薪发工资）；钟点工：HourlyWorker（按工时和时薪发工资）；计件工：PieceWorker（按月总工件数和工件单价发工资） 实现如下： 头文件 employee.h #define _CRT_SECURE_NO_WARNINGS #include "employee.h" employee::employee(const...
C++ 判断两个圆是否相交
Ai_King的博客
01-17 1804
定义一个Point类，其属性包括点的坐标，提供计算两点之间距离的方法； 定义一个圆Circle类，其属性包括圆心和半径； 创建两个圆形对象，提示用户输入，判断两圆是否相交。 #include <iostream> #include <cmath> using namespace std; class Point { public: Point(); ~Point()...
C++实现选择排序
Ai_King的博客
11-03 1790
选择排序 选择排序（SelectSort）是一种简单直观的排序算法。 算法原理：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 #include<iostream> using namespace std...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

banjitino

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

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

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

打赏作者

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

抵扣说明：

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

余额充值